Spring过滤器与拦截器

过滤器 Filter,是在 Servlet 规范中定义的,是 Servlet 容器支持的,该接口定义在 javax.servlet
包下,主要是在客户端请求(HttpServletRequest)进行预处理,以及对服务器响应(HttpServletResponse)进行后处理。接口代码如下:

package javax.servlet;

import java.io.IOException;

public interface Filter {
    void init(FilterConfig var1) throws ServletException;

    void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;

    void destroy();
}

复制代码

对上面三个接口方法进行分析:

  • init(FilterConfig)
    : 初始化接口,在用户自定义的 Filter 初始化时被调用,它与 Servlet 的 init 方法的作用是一样的。
  • doFilter(ServletRequest,ServletResponse,FilterChain)
    : 在每个用户的请求进来时这个方法都会被调用,并在 Servlet 的 service 方法之前调用(如果我们是开发 Servlet 项目),而 FilterChain 就代表当前的整个请求链,通过调用 FilterChain.doFilter
    可以将请求继续传递下去,如果想拦截这个请求,可以不调用 FilterChain.doFilter,那么这个请求就直接返回了, 所以 Filter 是一种责任链设计模式
    ,在 spring security
    就大量使用了过滤器,有一条过滤器链。
  • destroy
    : 当 Filter 对象被销毁时,这个方法被调用,注意,当 Web 容器调用这个方法之后,容器会再调用一次 doFilter 方法。

如何实现自己的过滤器

首先我们需要创建一个类,让它实现 Filter 接口,然后重写接口中的方法:

package com.example.demojava.filter;

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.servlet.*;
import javax.servlet.annotation.WebFilter;
import javax.servlet.http.HttpServletRequest;
import java.io.IOException;

@Component
@Order(1)   // 过滤顺序,值越小越先执行
@WebFilter(urlPatterns = "/demoFilter", filterName = "filterTest")
public class Filter1 implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("filter初始化中...");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        System.out.println("doFilter()开始执行:发往 " + ((HttpServletRequest) servletRequest).getRequestURL().toString() + " 的请求已被拦截");

        System.out.println("检验接口是否被调用,尝试获取contentType如下: " + servletResponse.getContentType());

        // filter的链式调用;将请求转给下一条过滤链
        filterChain.doFilter(servletRequest, servletResponse);

        System.out.println("检验接口是否被调用,尝试获取contentType如下: " + servletResponse.getContentType());

        System.out.println("doFilter()执行结束。");

    }

    @Override
    public void destroy() {
        System.out.println("filter销毁中...");
    }
}

复制代码

当我们配置了多个 filter,且一个请求能够被多次拦截时,该请求将沿着 客户端 -> 过滤器1 -> 过滤器2 -> servlet -> 过滤器2 -> 过滤器1 -> 客户端
链式流转

@Component
@Order(2)   // 过滤顺序,值越小越先执行
@WebFilter(urlPatterns = "/demoFilter", filterName = "filterTest2")
public class Filter2 implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("filter2初始化中...");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

        System.out.println("doFilter2()开始执行:发往 " + ((HttpServletRequest) servletRequest).getRequestURL().toString() + " 的请求已被拦截");

        System.out.println("检验接口是否被调用,尝试获取contentType如下: " + servletResponse.getContentType());

        // filter的链式调用;将请求转给下一条过滤链
        filterChain.doFilter(servletRequest, servletResponse);

        System.out.println("检验接口是否被调用,尝试获取contentType如下: " + servletResponse.getContentType());

        System.out.println("doFilter2()执行结束。");

    }

    @Override
    public void destroy() {
        System.out.println("filter2销毁中...");
    }
}
复制代码

然后创建一个 Controller,对外提供两条请求路径:

@RestController
@RequestMapping("demoFilter")
public class FilterController {

    @GetMapping("hello")
    public String hello() {
        System.out.println("接口被调用:hello() ");
        return "hello filter";
    }

    @GetMapping("hi")
    public String hi() {
        System.out.println("接口被调用:hi()");
        return "hi filter";
    }
}
复制代码

启动项目,可以看到我们的过滤器已经随着程序的启动被成功初始化了。

分别对这两个接口发送请求, 看到结果:

doFilter()开始执行:发往 http://localhost:8080/demoFilter/hi 的请求已被拦截
检验接口是否被调用,尝试获取contentType如下: null

doFilter2()开始执行:发往 http://localhost:8080/demoFilter/hi 的请求已被拦截
检验接口是否被调用,尝试获取contentType如下: null

接口被调用:hi()

检验接口是否被调用,尝试获取contentType如下: text/plain;charset=UTF-8
doFilter2()执行结束。

检验接口是否被调用,尝试获取contentType如下: text/plain;charset=UTF-8
doFilter()执行结束。
复制代码

最后使项目停止运行,则过滤器随之销毁。

可以看出,当请求同时满足多个过滤器的过滤条件时, filterChain.doFilter()
会将其按一定顺序(可以通过 @Order 指定)依次传递到下一个 filter,直到进入 servlet 进行接口的实际调用。调用完成后,响应结果将沿着原路返回,并在再一次经过各个 filter 后,最终抵达客户端。

拦截器

什么是拦截器

拦截器是 AOP 的一种实现策略,用于在某个方法或字段被访问前对它进行拦截,然后在其之前或之后加上某些操作。同 filter 一样,interceptor 也是链式调用。每个 interceptor 的调用会依据它的声明顺序依次执行。一般来说拦截器可以用于以下方面 :

  • 日志记录 :几率请求信息的日志,以便进行信息监控、信息统计等等

  • 权限检查 :对用户的访问权限,认证,或授权等进行检查

  • 性能监控 :通过拦截器在进入处理器前后分别记录开始时间和结束时间,从而得到请求的处理时间

  • 通用行为 :读取 cookie 得到用户信息并将用户对象放入请求头中,从而方便后续流程使用

拦截器的接口方法

SpringMVC 中,DispatcherServlet 捕获每个请求,在到达对应的 Controller 之前,请求可以被拦截器处理,在拦截器中进行前置处理后,请求最终才到达 Controller。

拦截器的接口是 org.springframework.web.servlet.HandlerInterceptor
接口,接口代码如下:

public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

复制代码

接口方法解读:

  • preHandle 方法
    :对客户端发过来的请求进行前置处理,如果方法返回 true,继续执行后续操作,如果返回 false,执行中断请求处理,请求不会发送到 Controller
  • postHandler 方法
    :在请求进行处理后执行,也就是在 Controller 方法调用之后处理,当然前提是之前的 preHandle
    方法返回 true。具体来说, postHandler
    方法会在 DispatcherServlet 进行视图返回渲染前被调用,也就是说我们可以在这个方法中对 Controller 处理之后的 ModelAndView
    对象进行操作
  • afterCompletion 方法
    : 该方法在整个请求结束之后执行,当然前提依然是 preHandle
    方法的返回值为 true 才行。该方法一般用于资源清理工作

如何实现一个自己的拦截器

同样,首先创建一个类,让它实现 HandlerInterceptor 接口,然后重写接口中的方法 :

package com.demo.demofilter.demofilter.interceptor;

import org.springframework.lang.Nullable;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

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

@Component
public class DemoInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("preHandle");
        return true;
    }

    @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("afterHandle");
    }
}
复制代码
复制代码

紧接着需要对拦截器进行注册,指明使用哪个拦截器,及该拦截器对应拦截的 URL :

package com.demo.demofilter.demofilter.interceptor;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 如果有多个拦截器,继续registry.add往下添加就可以啦
        registry.addInterceptor(new DemoInterceptor()).addPathPatterns("/demoInterceptor/**");
    }

}
复制代码
复制代码

最后是 Controller

package com.demo.demofilter.demofilter.interceptor;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("demoInterceptor")
public class InterceptorController {

    @GetMapping("hello")
    public String hello() {
        System.out.println("接口被调用:hello() ");
        return "hello interceptor";
    }

    @GetMapping("hi")
    public String hi() {
        System.out.println("接口被调用:hi()");
        return "hi interceptor";
    }
}
复制代码
复制代码

运行结果如下 :

preHandler
接口被调用: hello()
postHandler
afterHandler
复制代码

其他注意事项

在 Http 的请求执行过程中,要经过以下几个步骤  :

  1. 由 DispatcherServlet 捕获请求
  2. DispatcherServlet 将接收到的 URL 和对应的 Controller 进行映射
  3. 在请求到达相应的 Controller 之前,由拦截器对请求进行处理
  4. 处理完成之后,进行视图的解析
  5. 返回视图

所以,只有经过 DispatcherServlet 的请求才会被拦截器捕获,而我们自定义的 Servlet 请求则不会被拦截的。

原文 

https://juejin.im/post/5f146a216fb9a07eb57d3026

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » Spring过滤器与拦截器

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址