解决shiro redis 重写sessiondao多次查询Redis问题

怼烎@ 2022-06-18 05:10 491阅读 0赞

发现 一直调用 sessiondao 的 doReadSession 方法  
doReadSession   
doCreate   
update   
doReadSession    
update   
doReadSession    
doReadSession    
update  
常常还出现这个异常

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);
    			}
    		}
    	}
    }

然后在SpringBoot启动时注册监听

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);
        }
    }

2.获取到可访问的URL地址后创建一个过滤器Filter

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摧毁成功-----");
    	}
     
    }

SpringBoot注册过滤器

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;
        }
    }

PS: 此处  @Order是拦截器的优先级  要优于Shrio的拦截器先

3.启动服务 发现AcceeFilter要由于shiroFilter先执行  
![Center][]  
4.测试结果  再次访问URL后发现已不再进行Redis查询  
![Center 1][]

[Center]: /images/20220618/bb786b61cfd84219a071cfb7a7f5743f.png
[Center 1]: /images/20220618/d37e2e97193f43bebd06ae0d802dbb41.png