SpringMVC的拦截器（Interceptor）和过滤器（Filter）详解

一简介（1）过滤器：依赖于servlet容器。在实现上基于函数回调，可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的是用来做一些过滤操作，获取我们想要获取的数据，比如：在过滤器中修改字符编码；在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等关于过滤器的一些用法可以参考我写过的这些文章：继承HttpServ

梦里梦见醒不来丶

4359人浏览 · 2017-06-01 11:54:48

梦里梦见醒不来丶 · 2017-06-01 11:54:48 发布

一简介

（1）过滤器：

依赖于servlet容器。在实现上基于函数回调，可以对几乎所有请求进行过滤，但是缺点是一个过滤器实例只能在容器初始化时调用一次。使用过滤器的目的是用来做一些过滤操作，获取我们想要获取的数据，比如：在过滤器中修改字符编码；在过滤器中修改HttpServletRequest的一些参数，包括：过滤低俗文字、危险字符等

关于过滤器的一些用法可以参考我写过的这些文章：

继承HttpServletRequestWrapper以实现在Filter中修改HttpServletRequest的参数：https://www.zifangsky.cn/677.html

在SpringMVC中使用过滤器（Filter）过滤容易引发XSS的危险字符：https://www.zifangsky.cn/683.html

（2）拦截器：

依赖于web框架，在SpringMVC中就是依赖于SpringMVC框架。在实现上基于Java的反射机制，属于面向切面编程（AOP）的一种运用。由于拦截器是基于web框架的调用，因此可以使用spring的依赖注入（DI）进行一些业务操作，同时一个拦截器实例在一个controller生命周期之内可以多次调用。但是缺点是只能对controller请求进行拦截，对其他的一些比如直接访问静态资源的请求则没办法进行拦截处理

关于过滤器的一些用法可以参考我写过的这些文章：

在SpringMVC中使用拦截器（interceptor）拦截CSRF攻击（修）：https://www.zifangsky.cn/671.html

SpringMVC中使用Interceptor+cookie实现在一定天数之内自动登录：https://www.zifangsky.cn/700.html

二多个过滤器与拦截器的代码执行顺序

如果在一个项目中仅仅只有一个拦截器或者过滤器，那么我相信相对来说理解起来是比较容易的。但是我们是否思考过：如果一个项目中有多个拦截器或者过滤器，那么它们的执行顺序应该是什么样的？或者再复杂点，一个项目中既有多个拦截器，又有多个过滤器，这时它们的执行顺序又是什么样的呢？

下面我将用简单的代码来测试说明：

（1）先定义两个过滤器：

i）过滤器1：

    <a target="_blank" href="http://www.07net01.com/tags-package-0.html" class="infotextkey" style="background:transparent; color:rgb(66,139,202)">package</a> cn.zifangsky.filter;  

    import java.io.IOException;  

    import javax.servlet.FilterChain;  
    import javax.servlet.ServletException;  
    import javax.servlet.http.HttpServletRequest;  
    import javax.servlet.http.HttpServletResponse;  

    import org.springframework.web.filter.OncePerRequestFilter;  

    public class TestFilter1 extends OncePerRequestFilter {  

        protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)  
                throws ServletException, IOException {  
            //在DispatcherServlet之前执行  
            <a target="_blank" href="http://www.07net01.com/tags-system-0.html" class="infotextkey" style="background:transparent; color:rgb(66,139,202)">system</a>.out.println("############TestFilter1 doFilterInternal executed############");  
            filterChain.doFilter(request, response);  
            //在视图页面返回给<a target="_blank" href="http://www.07net01.com/tags-%E5%AE%A2%E6%88%B7%E7%AB%AF-0.html" class="infotextkey" style="background:transparent; color:rgb(66,139,202)">客户端</a>之前执行，但是执行顺序在Interceptor之后  
            System.out.println("############TestFilter1 doFilter after############");  
    //      try {  
    //          Thread.sleep(10000);  
    //      } catch (InterruptedException e) {  
    //          e.printStackTrace();  
    //      }  
        }  

    }

ii）过滤器2：

package cn.zifangsky.filter;  

import java.io.IOException;  

import javax.servlet.FilterChain;  
import javax.servlet.ServletException;  
import javax.servlet.http.HttpServletRequest;  
import javax.servlet.http.HttpServletResponse;  

import org.springframework.web.filter.OncePerRequestFilter;  

public class TestFilter2 extends OncePerRequestFilter {  

    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)  
            throws ServletException, IOException {  
        System.out.println("############TestFilter2 doFilterInternal executed############");  
        filterChain.doFilter(request, response);  
        System.out.println("############TestFilter2 doFilter after############");  

    }  

}

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

 <!-- 自定义过滤器：testFilter1 -->   
   <filter>  
        <filter-name>testFilter1</filter-name>  
        <filter-class>cn.zifangsky.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>cn.zifangsky.filter.TestFilter2</filter-class>  
    </filter>  
    <filter-mapping>  
        <filter-name>testFilter2</filter-name>  
        <url-pattern>/*</url-pattern>  
    </filter-mapping>

（2）再定义两个拦截器：

i）拦截器1，基本拦截器：

    package cn.zifangsky.interceptor;  

    import javax.servlet.http.HttpServletRequest;  
    import javax.servlet.http.HttpServletResponse;  

    import org.springframework.web.servlet.HandlerInterceptor;  
    import org.springframework.web.servlet.ModelAndView;  

    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**********");  
    //      Thread.sleep(10000);  
        }  

    }

ii）指定controller请求的拦截器：

    package cn.zifangsky.interceptor;  

    import javax.servlet.http.HttpServletRequest;  
    import javax.servlet.http.HttpServletResponse;  

    import org.springframework.web.servlet.HandlerInterceptor;  
    import org.springframework.web.servlet.ModelAndView;  

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

iii）在SpringMVC的配置文件中注册这两个拦截器：

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

（3）定义一个测试使用的controller：

    package cn.zifangsky.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.html")  
        public ModelAndView handleRequest(){  
            System.out.println("---------TestController executed--------");  
            return new ModelAndView("test");  
        }  
    }

（4）视图页面test.jsp：

    <%@ page language="java" contentType="text/html; charset=UTF-8"  
        pageEncoding="UTF-8"%>  
    <%  
    String path = request.getContextPath();  
    String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";  
    %>      
    <html>  
    <head>  
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">  
    <base href="http://983836259.blog.51cto.com/7311475/">  
    <title>FilterDemo</title>  
    </head>  
    <body>  
        <%  
            System.out.println("test.jsp is loading");  
        %>  
        <div align="center">  
            This is test page  
        </div>  
    </body>  
    </html>

（5）测试效果：

启动此测试项目，可以看到控制台中输出如下：

这就说明了过滤器的运行是依赖于servlet容器的，跟springmvc等框架并没有关系。并且，多个过滤器的执行顺序跟xml文件中定义的先后关系有关

接着清空控制台中的输出内容并访问：http://localhost:9180/FilterDemo/test.html

可以看到，此时的控制台输出结果如下：

相信从这个打印输出，大家就可以很清晰地看到有多个拦截器和过滤器存在时的整个执行顺序了。当然，对于过个拦截器它们之间的执行顺序跟在SpringMVC的配置文件中定义的先后顺序有关

注：对于整个SpringMVC的执行流程来说，如果加上上面的拦截器和过滤器，其最终的执行流程就如下图所示：

向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...