一、引言

　　在开发过程中我们经常会遇到 过滤器(Filter) 和 拦截器(Interceptor)，找个也是面试中容易被问道的一个问题，两者的使用和作用又颇为相似，是个容易被大家混淆的问题，在此总结下，希望能对大家有所帮助。

二、Filter 过滤器介绍

1. Filter定义

　　Filter是sun公司中servlet2.3后增加的一个新功能，在javaEE中定义了一个接口 javax.servlet.Filter来描述过滤器。

　　Filter可以认为是Servlet的一种“加强版”，它主要用于对用户请求进行预处理，也可以对HttpServletResponse进行后处理，是个典型的处理链。Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序.它依赖于servlet容器,在实现上，基于函数回调,它可以对几乎所有请求进行过滤。Filter也可以对用户请求生成响应，这一点与Servlet相同，但实际上很少会使用Filter向用户请求生成响应。

　　它是随你的web应用启动而启动的，只初始化一次，以后就可以拦截相关请求，只有当你的web应用停止或重新部署的时候才销毁。

2. Filter工作原理

　　Servlet中的过滤器Filter是实现了javax.servlet.Filter接口的服务器端程序，其工作原理是，只要你在web.xml文件配置好要拦截的客户端请求，它都会帮你拦截到请求，此时你就可以对请求或响应(Request、Response)统一处理等。

　　使用Filter完整的流程是：Filter对用户请求进行预处理，接着将请求交给Servlet进行处理并生成响应，最后Filter再对服务器响应进行后处理。

　　当服务器启动，会创建Filter对象，并调用init方法，只调用一次。

　　当访问资源，路径与Filter的拦截路径匹配，会执行Filter中的doFilter方法，

　　当服务器关闭时，会调用Filter的destroy方法来进行销毁操作。

3. Filter应用场景

　　在过滤器中修改字符编码（CharacterEncodingFilter）、在过滤器中修改HttpServletRequest的一些参数（XSSFilter(自定义过滤器)），如：过滤低俗文字、危险字符、敏感词过滤、响应信息压缩、控制权限、控制转向、做一些业务逻辑判断等

4. Filter代码实战

public class TestFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //对filter进行一个初始化
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        //doFilter()前的代码是对用户请求进行预处理
        System.out.println("我是Filter,执行filterChain.doFilter之前。");
        //执行Filter链中的下一个Filter
        filterChain.doFilter(request, response);
        //doFilter()后的代码是对用户请求进行后处理
        System.out.println("我是Filter,执行filterChain.doFilter之后。");
    }

    @Override
    public void destroy() {
        //对filter进行一个销毁
    }
}

配置方式1 ：在web-xml 中进行配置

<filter>
    <description>测试过滤器</description>
    <filter-name>TestFilter</filter-name>
    <filter-class>com.test.filtes.TestFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>TestFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>　

配置方式2：通过@WebFilter注解配置

@WebFilter(urlPatterns = "/test001")
public class TestFilter1 implements Filter {
    @Override
    public void init(javax.servlet.FilterConfig filterConfig) throws ServletException {
        System.out.println("TestFilter1 init");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //在DispatcherServlet之前执行
        System.out.println("doFilter before");
        filterChain.doFilter(servletRequest, servletResponse);
        // 在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后
        System.out.println("doFilter after");
    }

    @Override
    public void destroy() {
        System.out.println("TestFilter destroy");
    }
}
//2.在启动类添加@ServletComponentScan

@SpringBootApplication
@ServletComponentScan
public class TestbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(TestbootApplication.class, args);
    }
}

PS: 多个filter 实现@WebFilter，难以控制filter 的过滤顺序，与其包名和文件名有关，慎用。

配置方式3 ：通过@Bean来配置

//1.初始化Filter
@Component
public class TestFilter2 implements Filter{
    @Override
    public void init(javax.servlet.FilterConfig filterConfig) throws ServletException {
        System.out.println("Filter2 init");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //在DispatcherServlet之前执行
        System.out.println("doFilter2 before");
        filterChain.doFilter(servletRequest, servletResponse);
        // 在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后
        System.out.println("doFilter2 after");
    }

    @Override
    public void destroy() {
        System.out.println("Filter2 destroy");
    }
}
@Component
public class TestFilter3 implements Filter{
    @Override
    public void init(javax.servlet.FilterConfig filterConfig) throws ServletException {
        System.out.println("Filter3 init");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //在DispatcherServlet之前执行
        System.out.println("doFilter3 before");
        filterChain.doFilter(servletRequest, servletResponse);
        // 在视图页面返回给客户端之前执行，但是执行顺序在Interceptor之后
        System.out.println("doFilter3 after");
    }

    @Override
    public void destroy() {
        System.out.println("Filter3 destroy");
    }
}

//2.注册到config
@Configuration
public class FilterConfig {

    @Bean
    public FilterRegistrationBean testFilter3RegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean(new TestFilter2());
        registration.addUrlPatterns("/hello world");
        registration.setOrder(1); // 值越小越靠前，此处配置有效
        return registration;
    }

    @Bean
    public FilterRegistrationBean testFilter4RegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean(new TestFilter3());
        registration.addUrlPatterns("/hello world");
        registration.setOrder(2);
        return registration;
    }
}

三、Interceptor 拦截器介绍（只针对spring介绍）

1. Interceptor 定义

　　拦截器（Interceptor）和Servlet无关，它依赖于Web框架，在SpringMVC中就依赖于SpringMVC框架，由SpringMVC框架实现。在Struts2中同理，它是一种可以让你在Action执行之前和Result执行之后进行一些功能处理的机制。

　　在实现上,基于Java的反射机制，属于面向切面编程（AOP）的一种运用。可以用于在某个方法或者字段被访问之前，进行拦截，然后在之前或者之后加入某些统一的处理方法。就是在action的前、后、甚至抛出异常时进行处理，比如动态代理就是拦截器的简单实现。

　　拦截器将很多service或者Controller中共有的行为提炼出来，在某些方法执行的前后执行，提炼为通用的处理方式，让被拦截的方法都能享受这一共有的功能，让代码更加简洁，同时，当共有的功能需要发生调整、变动的时候，不必修改很多的类或者方法，只要修改这个拦截器就可以了，可复用性很强。

　　SpringMVC的拦截器基于HandlerInterceptor接口来实现，所以只要实现HandlerInterceptor接口或者继承它的实现类。

2. Interceptor 工作原理

拦截器的实现分为两步：

第一步，创建一个普通的拦截器，实现 HandlerInterceptor 接口，并重写接口中的相关方法；

第二步，将上一步创建的拦截器加入到 Spring Boot 的配置文件中。

preHandler(HttpServletRequest request, HttpServletResponse response, Object handler) 方法在请求处理之前被调用。如果已经是最后一个 Interceptor 的时候就会调用当前请求的 Controller 方法。

postHandler(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) 方法在当前请求处理完成之后，所以我们可以在这个方法中对 Controller 处理之后的 ModelAndView 对象进行操作。

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

3. Interceptor 应用场景

1. 日志记录：记录请求操作日志(用户ip,访问时间等)

2. 权限检查：判断用户是否有权限访问资源,如校验token 日志记录

3. 性能监控：记录请求->响应时间，preHandle：记录开始时间，afterCompletion：记录结束时间，开始时间相减去结束时间

4. 登录验证：判断用户是否登录

5. sign校验，封禁校验等

6. 处理cookie，主题，国际化，本地化等

7. filter可以实现的功能intercepter基本上都能实现

4. Interceptor 代码实战

配置方式1 ：在springmvc.xml 中进行配置

public class BaseInterceptor implements HandlerInterceptor{
    public boolean preHandle(HttpServletRequest arg0, HttpServletResponse arg1,
                      Object arg2) throws Exception {
    System.out.println("Before...");
    System.out.println("返回true继续执行,返回false则结束请求");
    return true;
    }
 
    public void postHandle(HttpServletRequest arg0, HttpServletResponse arg1,
                      Object arg2, ModelAndView arg3) throws Exception {
    System.out.println("渲染试图前,action执行后...");
    }
 
    public void afterCompletion(HttpServletRequest arg0, HttpServletResponse
                      arg1, Object arg2, Exception arg3)
    System.out.println("整个请求结束之后，进行资源清理等");
}

<mvc:interceptors>
    <!-- 如果直接配置bean,代表对所有请求都拦截 -->
    <bean name="baseInterceptor" class="com.test.interceptor.BaseInterceptor" />
    <mvc:interceptor>
           <!-- /**：拦截所有，/*拦截一层目录结构请求 -->
        <mvc:mapping path="/**"/>
        <!-- 不拦截的请求 -->
        <mvc:exclude-mapping path="/testRequestEntity"/>
        <!-- 自定义的拦截器引用 -->
        <ref bean="baseInterceptor"></ref>
    </mvc:interceptor>
<mvc:interceptors/>

配置方式2 ：WebConfig将拦截器注册添加到拦截器链

/**
 * 自定义拦截器
 */
@Component
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        // 统一拦截（查询token)
        String token = request.getHeader("token");
        if(StringUtils.isEmpty(token)){
            // return  false;
        }

        System.out.println("preHandle方法在控制器的处理请求方法调用之后，解析视图之前执行");
        return true; // 返回 true: 正常执行   false:该请求停止向下运行
    }

    @Override
    public  void  postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
        System.out.println("postHandle方法在控制器的处理请求方法调用之后，解析视图之前执行");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
        System.out.println("Time Taken afterCompletion ");

    }

}

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(myInterceptor()).addPathPatterns("/**");
        // .excludePathPatterns("/user/get")/.addPathPatterns(). 可以排除和指定设置
    }

    @Bean
    public MyInterceptor myInterceptor() {
        return new MyInterceptor();
    }
}

四、过滤器(Filter)和拦截器(Interceptor) 、servlet、controller的执行顺序

五、过滤器(Filter)和拦截器(Interceptor)区别

更多消息资讯，请访问昂焱数据。https://www.ayshuju.com/home