Spring filter和拦截器的区别和执行顺序

Posted 2023-05-11

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了Spring filter和拦截器的区别和执行顺序相关的知识，希望对你有一定的参考价值。

参考技术A filter和拦截器的区别和执行顺序

　　1.Filter过滤器只过滤jsp文件不过滤action请求解决方案

解决办法：在web.xml中将filter的配置放在struts2配置的前面。

2.拦截器与Filter的区别
Spring的拦截器与Servlet的Filter有相似之处，比如二者都是AOP编程思想的体现，都能实现权限检查、日志记录等。不同的是：

使用范围不同：Filter是Servlet规范规定的，只能用于Web程序中。而拦截器既可以用于Web程序，也可以用于Application、Swing程序中。

规范不同：Filter是在Servlet规范中定义的，是Servlet容器支持的。而拦截器是在Spring容器内的，是Spring框架支持的。

使用的资源不同：同其他的代码块一样，拦截器也是一个Spring的组件，归Spring管理，配置在Spring文件中，因此能使用Spring里的任何资源、对象，例如Service对象、数据源、事务管理等，通过IoC注入到拦截器即可；而Filter则不能。

深度不同：Filter在只在Servlet前后起作用。而拦截器能够深入到方法前后、异常抛出前后等，因此拦截器的使用具有更大的弹性。所以在Spring构架的程序中，要优先使用拦截器。

　　实际上Filter和Servlet极其相似，区别只是Filter不能直接对用户生成响应。实际上Filter里doFilter()方法里的代码就是从多个Servlet的service()方法里抽取的通用代码，通过使用Filter可以实现更好的复用。
　　filter是一个可以复用的代码片段，可以用来转换HTTP请求、响应和头信息。Filter不像Servlet，它不能产生一个请求或者响应，它只是修改对某一资源的请求，或者修改从某一的响应。
　　JSR中说明的是，按照多个匹配的Filter，是按照其在web.xml中配置的顺序来执行的。

所以这也就是，把自己的Filter或者其他的Filter（比如UrlRewrite的Filter）放在Struts的 DispatcherFilter的前面的原因。因为，它们需要在请求被Struts2框架处理之前，做一些前置的工作。

当Filter被调用，并且进入了Struts2的DispatcherFilter中后，Struts2会按照在Action中配置的Interceptor Stack中的Interceptor的顺序，来调用Interceptor。

拦截器（Interceptor）和过滤器（Filter）的执行顺序和区别

1、过滤器（Filter）

首先说一下Filter的使用地方，我们在配置web.xml时，总会配置下面一段设置字符编码，不然会导致乱码问题：

<filter>
   <filter-name>encoding</filter-name>
   <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
   <init-param>
       <param-name>encoding</param-name>
       <param-value>UTF-8</param-value>
   </init-param>
   <init-param>
       <param-name>forceEncoding</param-name>
       <param-value>true</param-value>
   </init-param>
</filter>

<filter-mapping>
   <filter-name>encoding</filter-name>
   <servlet-name>/*</servlet-name>
</filter-mapping>

配置这个地方的目的，是让所有的请求都需要进行字符编码的设置，下面来介绍一下Filter。

过滤器(Filter)：

它依赖于servlet容器。在实现上，基于函数回调，它可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。

使用过滤器的目的，是用来做一些过滤操作，获取我们想要获取的数据。

比如：在Javaweb中，对传入的request、response提前过滤掉一些信息，或者提前设置一些参数，然后再传入servlet或者Controller进行业务逻辑操作。

通常用的场景是：在过滤器中修改字符编码（CharacterEncodingFilter）、在过滤器中修改HttpServletRequest的一些参数（XSSFilter(自定义过滤器)）。

如：过滤低俗文字、危险字符等。

2、拦截器（Interceptor）

拦截器的配置一般在SpringMVC的配置文件中，使用Interceptors标签，具体配置如下：

<mvc:interceptors>
   <mvc:interceptor>
       <mvc:mapping path="/**" />
       <bean class="com.scorpios.atcrowdfunding.web.LoginInterceptor"></bean>
   </mvc:interceptor>
   <mvc:interceptor>
       <mvc:mapping path="/**" />
       <bean class="com.scorpios.atcrowdfunding.web.AuthInterceptor"></bean>
   </mvc:interceptor>
</mvc:interceptors>

拦截器（Interceptor）：

它依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。在实现上,基于Java的反射机制，属于面向切面编程（AOP）的一种运用。

就是在service或者一个方法前，调用一个方法，或者在方法后，调用一个方法，比如动态代理就是拦截器的简单实现，在调用方法前打印出字符串（或者做其它业务逻辑的操作）。

也可以在调用方法后打印出字符串，甚至在抛出异常的时候做业务逻辑的操作。由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。

但是缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。

三、代码

下面在一个项目中我们使用既有多个过滤器，又有多个拦截器，并观察它们的执行顺序：

（1）第一个过滤器：

public class TestFilter1 extends Filter {  
 
   @Override
       protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {  
       //在DispatcherServlet之前执行  
   System.out.println("############TestFilter1 doFilterInternal executed############");  
       filterChain.doFilter(request, response);  
       //在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后  
       System.out.println("############TestFilter1 doFilter after############");  
   }  
}

（2）第二个过滤器：

public class TestFilter2 extends Filter {  

 @Override
   protected void doFilter(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {  
     //在DispatcherServlet之前执行  
       System.out.println("############TestFilter2 doFilterInternal executed############");  
       filterChain.doFilter(request, response);  
       //在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后 
       System.out.println("############TestFilter2 doFilter after############");  
   }  
}

（3）在web.xml中注册这两个过滤器：

<!-- 自定义过滤器：testFilter1 -->   
    <filter>  
         <filter-name>testFilter1</filter-name>  
         <filter-class>com.scorpios.filter.TestFilter1</filter-class>  
     </filter>  
     <filter-mapping>  
         <filter-name>testFilter1</filter-name>  
         <url-pattern>/*</url-pattern>  
     </filter-mapping>  
     <!-- 自定义过滤器：testFilter2 -->   
    <filter>  
         <filter-name>testFilter2</filter-name>  
         <filter-class>com.scorpios.filter.TestFilter2</filter-class>  
     </filter>  
     <filter-mapping>  
         <filter-name>testFilter2</filter-name>  
         <url-pattern>/*</url-pattern>  
     </filter-mapping>

再定义两个拦截器：

（4）第一个拦截器：

public class BaseInterceptor implements HandlerInterceptor{  
    
   /** 
    * 在DispatcherServlet之前执行 
    * */  
   public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  
       System.out.println("************BaseInterceptor preHandle executed**********");  
       return true;  
   }  

   /** 
    * 在controller执行之后的DispatcherServlet之后执行 
    * */  
   public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {  
       System.out.println("************BaseInterceptor postHandle executed**********");  
   }  
    
   /** 
    * 在页面渲染完成返回给客户端之前执行 
    * */  
   public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3)  
           throws Exception {  
       System.out.println("************BaseInterceptor afterCompletion executed**********");  
   }  
}

（5）第二个拦截器：

public class TestInterceptor implements HandlerInterceptor {  

   public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2) throws Exception {  
       System.out.println("************TestInterceptor preHandle executed**********");  
       return true;  
   }  

   public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, ModelAndView arg3) throws Exception {  
       System.out.println("************TestInterceptor postHandle executed**********");  
   }  

   public void afterCompletion(HttpServletRequest arg0, HttpServletResponse arg1, Object arg2, Exception arg3) throws Exception {  
       System.out.println("************TestInterceptor afterCompletion executed**********");  
   }  
}

（6）、在SpringMVC的配置文件中，加上拦截器的配置：

<!-- 拦截器 -->  
 <mvc:interceptors>  
     <!-- 对所有请求都拦截，公共拦截器可以有多个 -->  
     <bean name="baseInterceptor" class="com.scorpios.interceptor.BaseInterceptor" />  
   
   <mvc:interceptor> 
       <!-- 对/test.html进行拦截 -->       
         <mvc:mapping path="/test.html"/>  
         <!-- 特定请求的拦截器只能有一个 -->  
         <bean class="com.scorpios.interceptor.TestInterceptor" />  
     </mvc:interceptor>  
 </mvc:interceptors>

（7）、定义一个Controller控制器：

package com.scorpios.controller;  
import org.springframework.stereotype.Controller;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.servlet.ModelAndView;  
 
@Controller  
public class TestController {  
   @RequestMapping("/test")  
   public ModelAndView handleRequest(){  
       System.out.println("---------TestController executed--------");  
       return new ModelAndView("test");  
   }  
}