Spring过滤器和拦截器的区别

Spring过滤器和拦截器的区别

 

两者的作用

 

过滤器：

是在javaweb中，你传入的request、response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者struts的action进行业务逻辑，比如过滤掉非法url（不是login.do的地址请求，如果用户没有登陆都过滤掉），或者在传入servlet或者 struts的action前统一设置字符集，或者去除掉一些非法字符.。

 

拦截器 ：

是在面向切面编程的就是在你的service或者一个方法，前调用一个方法，或者在方法后调用一个方法比如动态代理就是拦截器的简单实现，在你调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在你调用方法后打印出字符串，甚至在你抛出异常的时候做业务逻辑的操作。

 

 

从具体实现区分

1. 过滤器是servlet的

2. 拦截器是spring aop的

 

 

细节区别

①拦截器是基于Java的反射机制的，而过滤器是基于函数回调。

②拦截器不依赖于servlet容器，过滤器依赖于servlet容器。

③拦截器只能对action请求起作用，而过滤器则可以对几乎所有的请求起作用。

④拦截器可以访问action上下文、值栈里的对象，而过滤器不能访问。

⑤在action的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。

⑥拦截器可以获取IOC容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑。

 

 

工作流程及顺序

 

 

 

应用场景

1. 对于一些不需要用到bean的request预处理和response后处理，可以过滤器，如：encoding，cors

2. 对于一些要用到用到bean，或者逻辑比较复杂，有特殊处理的，可以用拦截器

3. 不过不怕麻烦，也可以自己建AOP

 

 

代码实现

 

拦截器：

继承spring的HandlerInterceptorAdapter

Java代码 

1. public class SessionInterceptor extends HandlerInterceptorAdapter {  
2.   
3.     private static ThreadLocal<UserSessionVO> threadLocal = new ThreadLocal<UserSessionVO>();  
4.   
5.     private final Logger logger = LoggerFactory.getLogger(this.getClass());  
6.   
7.     @Autowired  
8.     private UserSessionService userSessionService;  
9.   
10.     @PostConstruct  
11.     public void init() {  
12.         logger.info("init");  
13.     }  
14.   
15.     @PreDestroy  
16.     public void destroy() {  
17.         logger.info("destroy");  
18.     }  
19.   
20.     @Override  
21.     public boolean preHandle(final HttpServletRequest request, final HttpServletResponse response, final Object handler) throws Exception {  
22.         logger.debug("SessionInterceptor.preHandle run....");  
23.   
24.         final URLAnalysis urlAnalysis = (URLAnalysis) request.getAttribute(Constants.URL_ANALYSIS);  
25.   
26.         final String userIdString = urlAnalysis.getParam(Constants.USERID);  
27.         final String accessToken = urlAnalysis.getParam(Constants.ACCESSTOKEN);  
28.         if (!StringUtils.isNotEmpty(userIdString)) {  
29.             throw new InvalidArgumentException("userId is required");  
30.         }  
31.         if (!StringUtils.isNotEmpty(accessToken)) {  
32.             throw new InvalidArgumentException("accessToken is required");  
33.         }  
34.         if (!NumberUtils.isNumber(userIdString)) {  
35.             throw new InvalidArgumentException("userId[" + userIdString + "] invalid");  
36.         }  
37.   
38.         final boolean result = userSessionService.checkLogin(Long.valueOf(userIdString), accessToken);  
39.         if (!result) {  
40.             throw new InvalidUserSessionException("Invalid accessToken[" + accessToken + "]");  
41.         }  
42.   
43.         final UserSessionVO userSessionVO = new UserSessionVO();  
44.         userSessionVO.setUserId(Long.valueOf(userIdString));  
45.         userSessionVO.setAccessToken(accessToken);  
46.         threadLocal.set(userSessionVO);  
47.         return result;  
48.     }  
49.   
50.     @Override  
51.     public void afterCompletion(final HttpServletRequest request, final HttpServletResponse response, final Object handler, final Exception ex) throws Exception {  
52.         logger.debug("SessionInterceptor.afterCompletion run....");  
53.   
54.         final UserSessionVO userSessionVO = threadLocal.get();  
55.   
56.         if (userSessionVO != null) {  
57.             // renewal session  
58.             userSessionService.renewalSessoin(userSessionVO.getUserId(), userSessionVO.getAccessToken());  
59.         }  
60.         threadLocal.remove();  
61.     }  
62. }  

 

过滤器：

继承java的Filter，其实现是servlet

Java代码 

1. public class CorsFilter implements Filter {  
2.   
3. //    private final Log logger = LogFactory.getLog(this.getClass());  
4.   
5.     private final String allowedOrigins;  
6.     private final String allowCredentials;  
7.   
8.     public CorsFilter(final String allowedOrigins, final String allowCredentials) {  
9.         this.allowedOrigins = allowedOrigins;  
10.         this.allowCredentials = allowCredentials;  
11.     }  
12.   
13.     @Override  
14.     public void init(final FilterConfig filterConfig) throws ServletException {  
15.     }  
16.   
17.     @Override  
18.     public void doFilter(final ServletRequest req, final ServletResponse res, final FilterChain chain) throws IOException, ServletException {  
19.         final HttpServletRequest request = (HttpServletRequest) req;  
20.         final HttpServletResponse response = (HttpServletResponse) res;  
21.         final String method = request.getMethod();  
22.         // this origin value could just as easily have come from a database  
23.         response.setHeader("Access-Control-Allow-Origin", allowedOrigins);  
24.         response.setHeader("Access-Control-Allow-Methods", "GET, HEAD, POST, PUT, DELETE, OPTIONS");  
25.         response.setHeader("Access-Control-Max-Age", "3600");  
26.         response.setHeader("Access-Control-Allow-Credentials", allowCredentials);  
27.         // "Content-Type, X-Requested-With, accept, Origin, Access-Control-Request-Method, Access-Control-Request-Headers"  
28.         response.setHeader("Access-Control-Allow-Headers", "Origin,Accept,X-Requested-With,Content-Type,Access-Control-Request-Method,Access-Control-Request-Headers,Authorization," + Constants.SESSIONID + "," + Constants.CSRFTOKEN);  
29.         if ("OPTIONS".equals(method)) {  
30.             response.setStatus(HttpStatus.OK.value());  
31.         } else {  
32.             chain.doFilter(req, res);  
33.         }  
34.     }  
35.   
36.     @Override  
37.     public void destroy() {  
38.     }  
39. }