SpringBoot使用过滤器或拦截器

阳光穿透心脏的1/2处 2022-03-11 08:07 281阅读 0赞

# 开篇 #

在Web应用中，常常存在拦截全部或部分请求进行统一处理的应用场景，如权限校验、参数校验、性能监控等。 在SpringMVC框架中，我们可以通过过滤器或拦截器实现相关功能，spring-boot-starter-web模块底层实际就是SpringMVC框架，那么在SpringBoot项目中如何使用过滤器或拦截器呢？

# 过滤器与拦截器的区别 #

<table> 
 <thead> 
  <tr> 
   <th>项目</th> 
   <th>过滤器Filter</th> 
   <th>拦截器Interceptor</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>规范定义</td> 
   <td>Servlet规范中定义，与SpringMVC框架无关。</td> 
   <td>SpringMVC提供组件之一。</td> 
   <td>过滤器不依赖于Spring MVC框架。</td> 
  </tr> 
  <tr> 
   <td>调用顺序</td> 
   <td>在Spring DispatchServlet执行前</td> 
   <td>在Spring DispatchServlet中调用</td> 
   <td>故过滤器执行会在拦截器之前。</td> 
  </tr> 
  <tr> 
   <td>容器资源</td> 
   <td>无法使用Spring容器资源，如果需要使用，可以通过ApplicationContext上下文对象获取</td> 
   <td>拦截器本身就是Spring的容器资源，可以通过Ioc进行依赖注</td> 
   <td>入直接使用容器资源。</td> 
  </tr> 
 </tbody> 
</table>

# 过滤器与拦截器的使用 #

## 创建项目 ##

创建一个maven项目spring-boot-examples-intercept，添加一下依赖：

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
            </dependency>
        </dependencies>

## 添加业务接口 ##

添加一个`HelloController`类，实现一个Restful的测试接口`/hello`，代码如下：

@RestController
    @Slf4j
    public class HelloController {
    
        /**
         * 测试请求方法
         *
         * @return
         */
        @GetMapping("/hello")
        public String hello() {
            log.info("[{}]执行{}方法！", this.getClass().getSimpleName(), "hello");
            return "Hello!";
        }
    }

## 添加过滤器 ##

### 过滤器开发 ###

*  添加第一个过滤器`FirstFilter`类，实现`Filter`接口，代码如下：

@Slf4j
    public class FirstFilter implements Filter {
    
        /**
         *
         * @param servletRequest
         * @param servletResponse
         * @param filterChain
         * @throws IOException
         * @throws ServletException
         */
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            log.info("[{}]执行{}方法：Before！", this.getClass().getSimpleName(), "doFilter");
            //执行下一个filter
            filterChain.doFilter(servletRequest, servletResponse);
            log.info("[{}]执行{}方法：After！", this.getClass().getSimpleName(), "doFilter");
        }
    }

*  添加第二个过滤器`SecondFilter`类，实现`Filter`接口，代码如下：

@Slf4j
    public class SecondFilter implements Filter {
    
        /**
         * @param servletRequest
         * @param servletResponse
         * @param filterChain
         * @throws IOException
         * @throws ServletException
         */
        @Override
        public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
            log.info("[{}]执行{}方法：Before！", this.getClass().getSimpleName(), "doFilter");
            //执行下一个filter
            filterChain.doFilter(servletRequest, servletResponse);
            log.info("[{}]执行{}方法：After！", this.getClass().getSimpleName(), "doFilter");
        }
    }

### 过滤器配置 ###

配置过滤器有两种方式，分别是通过配置类或者注解的方式，两种方式都可以将过滤器配置到服务中，但是通过注解的方式我还没发现指定过滤器顺序的方法（通过`@Order`注解是无效的），所以如果需要指定过滤器执行顺序的，建议使用方式一，否则使用方式二代码更简洁。

*  **方式一：通过配置类配置过滤器。** 添加一个Spring Boot的配置类`FilterConfig`，里面注册两个FilterRegistrationBean类型的Bean，代码如下：

@Configuration
    public class FilterConfig {
    
        /**
         * 注册第一个过滤器
         * @return
         */
        @Bean
        public FilterRegistrationBean firstFilter() {
            FilterRegistrationBean registrationBean = new FilterRegistrationBean(new FirstFilter());
            //可不设置，默认过滤路径即为：/*
            registrationBean.addUrlPatterns("/*");
            registrationBean.setOrder(1);
            return registrationBean;
        }
    
        /**
         * 注册第二个过滤器
         * @return
         */
        @Bean
        public FilterRegistrationBean secondFilter() {
            FilterRegistrationBean registrationBean = new FilterRegistrationBean(new SecondFilter());
            //可不设置，默认过滤路径即为：/*
            registrationBean.addUrlPatterns("/*");
            registrationBean.setOrder(2);
            return registrationBean;
        }
    }

*  **方式二：通过注解配置过滤器** 在FirstFilter和SecondFilter类上分别添加注解配置`@WebFilter(urlPatterns = "/*")`，由于`@WebFilter`并不是Spring提供的注解，所以还需要在项目的启动类中添加注解配置`@ServletComponentScan`，告诉Spring扫描路径，如下：

@SpringBootApplication
    @ServletComponentScan(basePackages = "org.cent.springboot.example.intercept.filter")
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    }

## 添加拦截器 ##

### 开发拦截器 ###

*  添加第一个拦截器`FirstInterceptor`类，实现HandlerInterceptor接口，代码如下：

@Slf4j
    public class FirstInterceptor implements HandlerInterceptor {
    
        /**
         * controller方法调用前调用。
         *
         * @param request
         * @param response
         * @param handler
         * @return 往下执行则返回true，否则返回false
         * @throws Exception
         */
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            log.info("[{}]执行{}方法！", this.getClass().getSimpleName());
            return true;
        }
    
        /**
         * controller方法调用后视图渲染前执行。
         *
         * @param request
         * @param response
         * @param handler
         * @param modelAndView
         * @throws Exception
         */
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            log.info("[{}]执行{}方法！", this.getClass().getSimpleName(), "postHandle");
        }
    
        /**
         * controller方法调用且视图渲染完成后执行
         *
         * @param request
         * @param response
         * @param handler
         * @param ex
         * @throws Exception
         */
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            log.info("[{}]执行{}方法！", this.getClass().getSimpleName(), "afterCompletion");
        }

*  添加第二个拦截器`SecondInterceptor`类，实现HandlerInterceptor接口，代码如下：

@Slf4j
    public class SecondInterceptor implements HandlerInterceptor {
    
        /**
         * controller方法调用前调用。
         *
         * @param request
         * @param response
         * @param handler
         * @return 往下执行则返回true，否则返回false
         * @throws Exception
         */
        @Override
        public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
            log.info("[{}]执行{}方法！", this.getClass().getSimpleName(), "preHandle");
            return true;
        }
    
        /**
         * controller方法调用后视图渲染前执行。
         *
         * @param request
         * @param response
         * @param handler
         * @param modelAndView
         * @throws Exception
         */
        @Override
        public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
            log.info("[{}]执行{}方法！", this.getClass().getSimpleName(), "postHandle");
        }
    
        /**
         * controller方法调用且视图渲染完成后执行
         *
         * @param request
         * @param response
         * @param handler
         * @param ex
         * @throws Exception
         */
        @Override
        public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
            log.info("[{}]执行{}方法！", this.getClass().getSimpleName(), "afterCompletion");
        }

### 配置拦截器 ###

添加一个Spring Boot配置类，实现WebMvcConfigurer接口以覆盖容器默认配置，代码如下：

@Configuration
    public class InterceptorConfig implements WebMvcConfigurer {
    
        /**
         * 重写添加拦截器方法
         *
         * @param registry
         */
        @Override
        public void addInterceptors(InterceptorRegistry registry) {
            registry.addInterceptor(new FirstInterceptor())
                    .addPathPatterns("/**")
                    .order(1);//指定执行顺序，数值越小越优先
            registry.addInterceptor(new SecondInterceptor())
                    .addPathPatterns("/hello")
                    .order(2);//指定执行顺序，数值越小越优先
        }
    
    }

## 启动测试 ##

启动服务，访问[http://localhost:8120/hello][http_localhost_8120_hello]接口，后台输入日志如下图，会发现Filter执行会在Interceptor之前，也验证上面表格中的说法。 ![image.png][]

# 示例代码 #

码云：[https://gitee.com/centy/spring-boot-examples/tree/master/spring-boot-examples-intercept][https_gitee.com_centy_spring-boot-examples_tree_master_spring-boot-examples-intercept]

# 尾巴 #

过滤器依赖于Servlet容器，而Interceptor则为SpringMVC的一部分。过滤器能够拦截所有请求，而Interceptor只能拦截Controller的请求，所以从覆盖范围来看，Filter应用更广一些。但是在Spring逐渐一统Java框架、前后端分离越演越烈，实际上大部分的应用场景，拦截器都可以满足了。

原文地址: [https://my.oschina.net/centychen/blog/3018007][https_my.oschina.net_centychen_blog_3018007]

[http_localhost_8120_hello]: http://localhost:8120/hello
[image.png]: /images/20220311/dca3b5f840674e4d8d10d5669ad65353.png
[https_gitee.com_centy_spring-boot-examples_tree_master_spring-boot-examples-intercept]: https://gitee.com/centy/spring-boot-examples/tree/master/spring-boot-examples-intercept
[https_my.oschina.net_centychen_blog_3018007]: https://my.oschina.net/centychen/blog/3018007