Caused by: org.apache.shiro.session.UnknownSessionException: There is no session with id [517a249d-f921-43c4-8c07-c9c6e4cfba73]

解決方式：

這個是shiro  設計上的問題， 主要是因為shiro 框架獲取 session裡面的屬性時，每次都去拿取session，一次請求中會有很多次 獲取 session 裡面的屬性。

我的解決思路是首先獲取Spring啟動後獲取可請求的地址，然後放到快取中，Shiro框架是基於過濾器實現的，我在進入Shiro的過濾器前先判定當前請求是否合法，如果合法的話，進入下一個過濾器，不合法的話返回提示，然後也不去Redis中進行查詢。

以下基於Spring Boot框架

1.建立一個監聽獲取Spring啟動後可訪問的地址

package com.abroad.common.listener;

import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.mvc.condition.PatternsRequestCondition;
import org.springframework.web.servlet.mvc.method.RequestMappingInfo;
import org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping;

import com.abroad.common.cache.LocalCache;

/**
 * 當容器啟動時獲取當前容器的可請求地址，並把它放到快取中
 * 
 * @ClassName: RequestURLListener
 * @Description: TODO()
 * @author: mengxr
 * @date 2017年3月29日 下午6:25:36
 */
public class RequestUrlListener implements
		ApplicationListener<ContextRefreshedEvent> {
	private Logger logger = LoggerFactory.getLogger(this.getClass());
	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		if (event.getApplicationContext().getParent() == null) {// root application context 沒有parent，他就是老大.
			try {
				ApplicationContext applicationContext = event
						.getApplicationContext();
				RequestMappingHandlerMapping bean = applicationContext
						.getBean(RequestMappingHandlerMapping.class);
				Set<String> result = new HashSet<String>();
				Map<RequestMappingInfo, HandlerMethod> handlerMethods = bean
						.getHandlerMethods();
				for (RequestMappingInfo rmi : handlerMethods.keySet()) {
					PatternsRequestCondition pc = rmi.getPatternsCondition();
					Set<String> pSet = pc.getPatterns();
					result.addAll(pSet);
				}
				LocalCache.ACCESS_URL.addAll(result);
				logger.info("-----------初始化RequestUrlListener成功 ");
			} catch (Exception e) {
				logger.error("-----------獲取RequestUrlListener失敗 ",e);
			}
		}
	}
}
 

package com.abroad;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.abroad.common.listener.RequestUrlListener;

/**
* @ClassName: SecurityApplication
* @Description: TODO(許可權管理框架)
* @author: mengxr
* @date 2017年3月23日 上午10:52:13
*/
@SpringBootApplication
public class SecurityApplication {
    public static void main(String[] args) {
    	SpringApplication springApplication = new SpringApplication(SecurityApplication.class);
    	springApplication.addListeners(new RequestUrlListener()); //新增一個啟動後監聽
    	springApplication.run(args);
    }
}
 

package com.abroad.common.filter;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.abroad.common.cache.LocalCache;
import com.abroad.common.comn.ResponseJson;
import com.abroad.common.comn.StatusCode;
import com.abroad.common.comn.web.ServletTools;

/**
* @ClassName: AccessFilter
* @Description: TODO(訪問過濾器)
* @author: mengxr
* @date 2017年3月29日 下午6:08:54
*/
public class AccessFilter implements Filter {
	
	private Logger logger = LoggerFactory.getLogger(this.getClass());
    @Override
    public void doFilter(ServletRequest request, ServletResponse response,
            FilterChain chain) throws IOException, ServletException {
    	String url = ServletTools.getContextPath((HttpServletRequest)request);
    	boolean flag = LocalCache.ACCESS_URL.contains(url);
    	if(flag){ //如果還有的話繼續走下一個過濾器
            chain.doFilter(request, response);
    	}else{
    		//沒有找到相應的資源
    		ServletTools.sendResponse((HttpServletResponse) response, new ResponseJson(StatusCode.NOT_FOUND, false));
    	}
    }

	@Override
	public void init(FilterConfig filterConfig) throws ServletException {
		logger.info("訪問過濾器AccessFilter註冊成功----");
	}

	@Override
	public void destroy() {
		logger.info("訪問過濾器AccessFilter摧毀成功-----");
	}
 
}

package com.abroad.common.config;

import org.springframework.boot.context.embedded.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.annotation.Order;

import com.abroad.common.filter.AccessFilter;

/**
 * 
* @ClassName: AccessConfigue
* @Description: TODO(訪問控制)
* @author: mengxr
* @date 2017年3月29日 下午5:58:39
*/
@Configuration
public class AccessConfigue {
    /**
     * 由於shrio框架在每次請求的時候都要向快取查詢當前的Session效率十分低，並且shrio框架是基於過濾器實現的，
     * 所以在進入shrioFilter前先對訪問的資料進行過濾，如果不存在的換直接跳轉到404狀態
    * @Title: accessFilterRegistration
    * @Description: TODO(這裡用一句話描述這個方法的作用)
    * @param @return    設定檔案
    * @return FilterRegistrationBean    返回型別
    * @author: mengxr
    * @date 2017年3月29日 下午6:03:17
    * @throws
    */
    @Bean
    @Order(Integer.MAX_VALUE) //攔截器優先順序最高
    public FilterRegistrationBean accessFilterRegistration() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        AccessFilter accessFilter = new AccessFilter();
        registration.setFilter(accessFilter);
        registration.addUrlPatterns("/*");
        registration.addInitParameter("paramName", "paramValue");
        registration.setName("accessFilter");
        return registration;
    }
}

3.啟動服務 發現AcceeFilter要由於shiroFilter先執行

4.測試結果  再次訪問URL後發現已不再進行Redis查詢