spring中的过滤器与拦截器

时间  2019-11-16
标签 spring 过滤器 拦截 栏目 Spring 繁體版
原文   原文链接

过滤器 Filter

什么是过滤器？

与 Servlet 类似，过滤器是一些 web 应用程序组件，能够绑定到一个 web 应用程序中。可是与其余 web 应用组件不一样的是，过滤器是“链”在容器的处理过程当中的。这就意味着它们能够在请求达到 servlet 以前对其进行访问，也能够在响应信息返回到客户端以前对其进行拦截。这种访问使得过滤器能够检查并修改请求和响应的内容。java

Filter 的接口方法有哪些？

init ：web

Filter 的初始化，在 Servlet 容器建立过滤器实例的时候调用，以确保过滤器可以正常工做。在 init() 方法执行过程当中遇到以下问题时，web 容器将不会配置其可用 ：spring

  • 抛出 ServletException
  • 没有在 web 容器设定的时间内返回

doFilter ：cookie

Filter 的核心方法，用于对每一个拦截到的请求作一些设定好的操做。app

典型用途以下：框架

  • 在 HttpServletRequest 到达 Servlet 以前，拦截客户的 HttpServletRequest。
  • 根据须要检查 HttpServletRequest ，也能够修改 HttpServletRequest 头和数据。
  • 在 HttpServletResponse 到达客户端以前，拦截 HttpServletResponse。
  • 根据须要检查 HttpServletResponse，能够修改 HttpServletResponse 头和数据。

destory ：ide

Filter 的销毁，在 Servlet 容器销毁过滤器实例时调用，以释放其占用的资源。只有在 doFilter() 方法中的全部线程退出或超时后，web 容器才会调用此方法。函数

如何实现一个本身的 Filter

首先咱们须要建立一个类，让它实现 Filter 接口，而后重写接口中的方法：post

package com.demo.demofilter.demofilter.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 DemoFilter 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("\ndoFilter()开始执行：发往 " + ((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()执行结束。\n");
    }

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

而后建立一个 Controller，对外提供两条请求路径：性能

package com.demo.demofilter.demofilter.filter;

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

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

启动项目，能够看到咱们的过滤器已经随着程序的启动被成功初始化了

分别对这两个接口发送请求：

最后使项目中止运行，则过滤器随之销毁

什么是 Filter 的链式调用？

当咱们配置了多个 filter，且一个请求可以被屡次拦截时，该请求将沿着 客户端 -> 过滤器1 -> 过滤器2 -> servlet -> 过滤器2 -> 过滤器1 -> 客户端 链式流转，以下图所示 ：

以上面的代码为例，因为咱们只定义了一个过滤器，在执行到 filterChain.doFilter(servletRequest, servletResponse); 的时候，请求就会被直接转送到 servlet 中进行调用。

因此咱们须要稍微给它改造一下，看看再添加一个 DemoFilter2 会发生什么：

package com.demo.demofilter.demofilter.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(2)   // 过滤顺序，值越小越先执行，值相同或不指定时按filterName排序
// 注意这里的urlPatterns要与前面保持一致
@WebFilter(urlPatterns = "/demoFilter", filterName = "filterTest2") 
public class DemoFilter2 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("\ndoFilter2()开始执行：发往 " + ((HttpServletRequest) servletRequest).getRequestURL().toString() + " 的请求已被拦截");

        System.out.println("检验接口是否被调用，尝试获取contentType以下： " + servletResponse.getContentType());
        filterChain.doFilter(servletRequest, servletResponse);
        System.out.println("检验接口是否被调用，尝试获取contentType以下： " + servletResponse.getContentType());

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

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

运行结果以下：

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

拦截器 Interceptor

什么是拦截器？

拦截器是 AOP 的一种实现策略，用于在某个方法或字段被访问前对它进行拦截，而后在其以前或以后加上某些操做。同 filter 同样，interceptor 也是链式调用。每一个 interceptor 的调用会依据它的声明顺序依次执行。通常来讲拦截器能够用于如下方面 ：

  • 日志记录 ：概率请求信息的日志，以便进行信息监控、信息统计等等
  • 权限检查 ：对用户的访问权限，认证，或受权等进行检查
  • 性能监控 ：经过拦截器在进入处理器先后分别记录开始时间和结束时间，从而获得请求的处理时间
  • 通用行为 ：读取 cookie 获得用户信息并将用户对象放入请求头中，从而方便后续流程使用

拦截器的接口方法有哪些？

preHandler：

方法的前置处理，将在请求处理以前被调用。通常用它来对方法进行一些前置初始化操做，或是对当前请求作一些预处理；此外也能够用来进行权限校验之类的判断，来决定请求是否要继续进行下去。

该方法返回一个布尔值，若该值为 false，则请求结束，后续的 Interceptor 和 Controller 都不会再执行；若该值为 true，则会继续调用下一个 Interceptor 的 preHandler() 方法，若是已经到达最后一个 interceptor 了，就会调用当前请求的 Controller。

postHandler：

方法的后置处理，将在请求处理以后被调用。虽然是在 Controller 方法调用后再执行，但它的调用依然在 DispatcherServlet 进行视图渲染并返回以前，因此通常能够经过它对 Controller 处理以后的 ModelAndView 对象进行操做。

afterCompletion：

在整个请求处理完成（包括视图渲染）后执行，主要用来进行一些资源的清理工做。

如何实现一个本身的拦截器

一样，首先建立一个类，让它实现 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";
    }
}
复制代码

运行结果以下 ：

其余注意事项

在 Http 的请求执行过程当中，要通过如下几个步骤 ：

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

因此，只有通过 DispatcherServlet 的请求才会被拦截器捕获，而咱们自定义的 Servlet 请求则不会被拦截的。

过滤器与拦截器

做为AOP思想的两种典型实现，过滤器与拦截器有着许多类似的地方。而二者最大的区别在于 ：过滤器是在 Servlet 规范中定义的，是由 Servlet 容器支持的；拦截器是在 Spring 容器内的，由 Spring 框架支持。

所以，做为 Spring 的一个组件，拦截器能够经过IOC容器进行管理，获取其中的各个 bean 实例，对 spring 中的各类资源、对象，如 Service 对象、数据源、事务管理等进行调用；而过滤器则不能。

总的来讲，二者主要在以下方面存在着差别 ：

  • 过滤器是基于函数的回调，而拦截器是基于 Java 反射机制的
  • 过滤器能够修改 request，而拦截器则不能
  • 过滤器须要在 servlet 容器中实现，拦截器能够适用于 JavaEE、JavaSE 等各类环境
  • 拦截器能够调用 IOC 容器中的各类依赖，而过滤器不能
  • 过滤器只能在请求的先后使用，而拦截器能够详细到每一个方法

最后补两张图嘿嘿 ：

  1. filter、servlet、interceptor 触发时机

    过滤器的触发时机是在容器后，servlet 以前，因此过滤器的 doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) 的入参是 ServletRequest，而不是 HttpServletRequest，由于过滤器是在 HttpServlet 以前。

  2. 过滤器拦截器运行前后步骤

    第二步中，SpringMVC 的机制是由 DispaterServlet 来分发请求给不一样的 Controller，其实这一步是在 Servlet 的 service() 方法中执行的。
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程