filter和interceptor的区别&执行顺序

最新推荐文章于 2023-07-05 12:10:52 发布

liuyuinsdu

最新推荐文章于 2023-07-05 12:10:52 发布

阅读量723

点赞数

分类专栏： Spring

Spring 专栏收录该内容

23 篇文章 2 订阅

订阅专栏

前言

最近在面试的时候，被问到了这个问题，觉得答得不是很好，在此进行整理和记录，供自己学习，也希望能帮助到大家。

什么是Filter

在java的javax.servlet下有一个接口Filter。任何实现了Filter接口的类都可以称之为filter。Filter的主要用途是设置字符集、控制权限、控制转向等等。在使用filter的过程中，如果是传统的web项目，带有web.xml文件这种。我们需要在xml里面进行配置。比如下面这样。

<filter> 
    <description>字符集过滤器</description> 
    <filter-name>encodingFilter</filter-name> 
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> 
    <init-param> 
        <description>字符集编码</description> 
        <param-name>encoding</param-name> 
        <param-value>UTF-8</param-value> 
    </init-param> 
</filter> 
<filter-mapping> 
    <filter-name>encodingFilter</filter-name> 
    <url-pattern>/*</url-pattern> 
</filter-mapping>

这种使用方式直接将我们的请求和响应的字符集全部改为utf-8的形式。

如果是在spingboot这种项目中使用，我们定义好自己的filter类之后，需要使用filterregisterbean将filter进行注入。

Filter随着项目的启动而启动，只初始化一次，随着web项目的停止而销毁。

Filter主要用于对用户请求的预处理和程序返回response的后处理。可以在请求到达servlet之前进行request的处理或者添加头和一些其他数据。或者在reponse到达之前，修改response的头和数据。

filter中总共有三个方法。
void init(FilterConfig config):用于完成Filter的初始化。
void destory():用于filter销毁前，完成资源的回收。
void doFilter(ServletRequest request,ServletResponse response,FilterChain chain):该方法是filter的核心过滤方法。通过request进行请求处理，然后调用chain.doFilter。调用完之后，可以通过response进行响应处理。

拦截器

拦截器是aop的一种实现方案，是aop思想的体现。在我们调用方法之前，调用拦截器的一个方法或者在调用方法之后，调用拦截器的一个方法。

SpringMVC 中的Interceptor 拦截请求是通过HandlerInterceptor 来实现的。在SpringMVC 中定义一个Interceptor 非常简单，主要有两种方式，第一种方式是要定义的Interceptor类要实现了Spring 的HandlerInterceptor 接口，或者是这个类继承实现了HandlerInterceptor 接口的类，比如Spring 已经提供的实现了HandlerInterceptor 接口的抽象类HandlerInterceptorAdapter ；第二种方式是实现Spring的WebRequestInterceptor接口，或者是继承实现了WebRequestInterceptor的类。

（1）preHandle (HttpServletRequest request, HttpServletResponse response, Object handle) 方法，该方法将在请求处理之前进行调用。SpringMVC 中的Interceptor 是链式调用，在一个应用中或者说是在一个请求中可以同时存在多个Interceptor。每个Interceptor 的调用会依据它的声明顺序依次执行，而且最先执行的都是Interceptor 中的preHandle 方法，所以可以在这个方法中进行一些前置初始化操作或者是对当前请求的一个预处理，也可以在这个方法中进行一些判断来决定请求是否要继续进行下去。该方法的返回值是布尔值Boolean类型的，当它返回为false时，表示请求结束，后续的Interceptor和Controller都不会再执行；当返回值为true时就会继续调用下一个Interceptor的preHandle方法，如果已经是最后一个Interceptor的时候就会是调用当前请求的Controller方法。

（2）postHandle (HttpServletRequest request, HttpServletResponse response, Object handle, ModelAndView modelAndView) 方法，由preHandle 方法的解释我们知道这个方法包括后面要说到的afterCompletion方法都只能是在当前所属的Interceptor的preHandle方法的返回值为true时才能被调用。postHandle方法，顾名思义就是在当前请求进行处理之后，也就是Controller方法调用之后执行，但是它会在DispatcherServlet进行视图返回渲染之前被调用，所以我们可以在这个方法中对Controller处理之后的ModelAndView对象进行操作。postHandle方法被调用的方向跟preHandle是相反的，也就是说先声明的Interceptor的postHandle方法反而会后执行。

（3）afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handle, Exception ex) 方法，该方法也是需要当前对应的Interceptor 的preHandle 方法的返回值为true 时才会执行。顾名思义，该方法将在整个请求结束之后，也就是在DispatcherServlet 渲染了对应的视图之后执行。这个方法的主要作用是用于进行资源清理工作的。
执行的顺序如下：

需要注意的点就是当preHandler为true的时候，postHandler才能执行。当为false的时候，afterCompletion仍然会执行。

filter和interceptor的区别总结

1、filter接口在javax.servlet包下面。inteceptor定义在org.springframework.web.servlet中。
2、filter是servlet规定的，interceptor即可用于web程序，也可用于application中。
3、filter是servlet容器支持的，interceptor是spring框架支持的。
4、filter通过dochain放行，interceptor通过prehandler放行。
5、filter只在方法前后执行，interceptor粒度更细，可以深入到方法前后，异常抛出前后。

下面重点讲执行顺序

一、引言

本来想记录一下关于用户登陆和登陆之后的权限管理、菜单管理的问题，想到解决这个问题用到Interceptor，但想到了Interceptor，就想到了Filter，于是就想说一下它们的执行顺序和区别。关于Interceptor解决权限和菜单管理的问题，在放在下一篇写吧，就酱紫。

二、区别

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。

（1）过滤器(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>

（2）拦截器（Interceptor）：它依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。在实现上,基于Java的反射机制，属于面向切面编程（AOP）的一种运用，就是在service或者一个方法前，调用一个方法，或者在方法后，调用一个方法，比如动态代理就是拦截器的简单实现，在调用方法前打印出字符串（或者做其它业务逻辑的操作），也可以在调用方法后打印出字符串，甚至在抛出异常的时候做业务逻辑的操作。由于拦截器是基于web框架的调用，因此可以使用Spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。但是缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理。

三、代码

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

public class TestFilter1 implements 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 implements 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");   
    }   
}

（8）、测试结果：
启动测试项目，地址如下：http://www.localhost:8080/demo，可以看到控制台中输出如下：
这里写图片描述
这就说明了过滤器的运行是依赖于servlet容器，跟springmvc等框架并没有关系。并且，多个过滤器的执行顺序跟xml文件中定义的先后关系有关。

接着清空控制台，并访问：http://www.localhost:8080/demo/test，再次看控制台的输出：
这里写图片描述
从这个控制台打印输出，就可以很清晰地看到有多个拦截器和过滤器存在时的整个执行顺序了。当然，对于多个拦截器它们之间的执行顺序跟在SpringMVC的配置文件中定义的先后顺序有关。

四、总结

对于上述过滤器和拦截器的测试，可以得到如下结论：
（1）、Filter需要在web.xml中配置，依赖于Servlet；
（2）、Interceptor需要在SpringMVC中配置，依赖于框架；
（3）、Filter的执行顺序在Interceptor之前，具体的流程见下图；
这里写图片描述
（4）、两者的本质区别：拦截器（Interceptor）是基于Java的反射机制，而过滤器（Filter）是基于函数回调。从灵活性上说拦截器功能更强大些，Filter能做的事情，都能做，而且可以在请求前，请求后执行，比较灵活。Filter主要是针对URL地址做一个编码的事情、过滤掉没用的参数、安全校验（比较泛的，比如登录不登录之类），太细的话，还是建议用interceptor。不过还是根据不同情况选择合适的。

liuyuinsdu

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
filter和interceptor的区别&执行顺序

前言最近在面试的时候，被问到了这个问题，觉得答得不是很好，在此进行整理和记录，供自己学习，也希望能帮助到大家。什么是Filter在java的javax.servlet下有一个接口Filter。任何实现了Filter接口的类都可以称之为filter。Filter的主要用途是设置字符集、控制权限、控制转向等等。在使用filter的过程中，如果是传统的web项目，带有web.xml文件这种。我们需要在xml里面进行配置。比如下面这样。<filter> <descrip
复制链接

扫一扫

专栏目录