【总结】SpringBoot 中过滤器、拦截器、监听器的基本使用

过滤器 Filter 与 拦截器 Interceptor

Filter 与 Interceptor 的执行顺序

Filter 与 Interceptor 的应用场景

过滤器对 Servlet 容器调用 service 的过程进行拦截，其基本使用场景如下：

• 统一设置字符编码
• 过滤敏感字符
• 进行登录校验以及 url 级别的访问权限控制

拦截器本质上是面向切面编程 AOP，符合切面编程的关注点都可以通过拦截器来实现，其基本使用场景如下：

• 登陆验证以及权限验证
• 进行日志记录
• 对 cookie 进行处理
• 性能监控，记录请求处理时长

Filter 与 Interceptor 在 SpringBoot 中的使用

过滤器 Filter

构造过滤器，实现Filter接口，编写过滤逻辑

/**
 * 自定义过滤器1
 */
public class MyFilter1 implements Filter {

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        // 进入过滤器前处理逻辑
        System.out.println("===过滤器1前处理===");
        // 执行 doFilter() 方法
        filterChain.doFilter(servletRequest, servletResponse);
        // Controller 返回之后，客户端返回之前处理逻辑
        System.out.println("===过滤器1后处理===");
    }

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        Filter.super.init(filterConfig);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

配置过滤器，对过滤器的过滤请求路径以及执行顺序进行配置，此处配置了两个过滤器，过滤逻辑完全一致

/**
 * 配置过滤器
 */
@Configuration
public class FilterConfig {
    /**
     * 过滤路径
     */
    private static final String[] URLS = new String[]{"/test/filter", "/test/all"};

    @Bean("myFilter1")
    public FilterRegistrationBean<Filter> myFilter1() {
        FilterRegistrationBean<Filter> registrationBean = new FilterRegistrationBean<>(new MyFilter1());
        // 配置要应用过滤器的路径，若存在多个则传入 String[]
        registrationBean.addUrlPatterns(URLS);
        // 设置执行顺序，数值越小，越先执行，服务器返回客户端时则相反
        registrationBean.setOrder(1);
        return registrationBean;
    }

    @Bean("myFilter2")
    public FilterRegistrationBean<Filter> myFilter2() {
        FilterRegistrationBean<Filter> registrationBean = new FilterRegistrationBean<>(new MyFilter2());
        registrationBean.addUrlPatterns(URLS);
        registrationBean.setOrder(2);
        return registrationBean;
    }

}

拦截器 Interceptor

构造拦截器实现HandlerInterceptor接口，编写拦截逻辑

/**
 * 自定义拦截器1
 */
public class MyInterceptor1 implements HandlerInterceptor {

    /**
     * 在 controller 执行之前进行拦截，返回结果将决定后续操作是否执行
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 编写拦截器逻辑
        System.out.println("===拦截器1前处理===");
        return true;
    }

    /**
     * 在执行完 controller 的方法后进行拦截，可对 model 和 view 进行修改
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("===拦截器1后处理===");
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    /**
     * 在整个请求完成之后执行，即视图渲染之后执行，若返回 json 数据则不会执行此方法
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

配置拦截器实现WebMvcConfigurer接口，配置拦截路径以及拦截顺序，此处同样配置了两个拦截逻辑相同的拦截器

/**
 * 配置拦截器
 */
@Configuration
public class InterceptorConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 拦截路径
        String[] urls = new String[]{"/test/interceptor", "/test/all"};
        // 配置自定义的拦截器，配置路径以及顺序
        registry.addInterceptor(new MyInterceptor1()).addPathPatterns(urls).order(1);
        registry.addInterceptor(new MyInterceptor2()).addPathPatterns(urls).order(2);
    }
}

测试 Filter/Interceptor

编写控制器进行测试

@RestController
@RequestMapping("/test")
public class TestController {

    @GetMapping("/filter")
    public String testFilter() {
        System.out.println("===执行 controller===");
        System.out.println("===调用 service 进行业务处理===");
        System.out.println("===执行 return===");
        return "测试过滤器~";
    }

    @GetMapping("/interceptor")
    public String testInterceptor() {
        System.out.println("===执行 controller===");
        System.out.println("===调用 service 进行业务处理===");
        System.out.println("===执行 return===");
        return "测试拦截器~";
    }

    @GetMapping("/all")
    public String testAll() {
        System.out.println("===执行 controller===");
        System.out.println("===调用 service 进行业务处理===");
        System.out.println("===执行 return===");
        return "测试过滤器and拦截器~";
    }

}

过滤器 Filter 测试结果

拦截器 Interceptor 测试结果

同时测试，验证过滤器和拦截器的执行顺序

监听器 Litener

Listener 的应用场景

监听器是 Servlet 中的类，可以帮助我们监听 web 中的特定事件，比如ServletContext、HttpSession、ServletRequest的创建和销毁或者变量的创建、销毁和修改，其使用场景主要包括：

• 监听 Servlet 进行数据的初始化
• 监听 HttpSession 获取实时在线人数
• 监听客户端请求的 ServletRequest 对象以获取用户的访问信息

Listener 在 SpringBoot 中的使用

新建一个 User 实体类，模拟从数据库查询到数据的过程

/**
 * 实体类
 */
@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private String username;

    private String password;

}

构造自定义事件继承ApplicationEvent

/**
 * 自定义事件
 */
public class MyEvent extends ApplicationEvent {

    private User user;

    public MyEvent(Object source, User user) {
        super(source);
        this.user = user;
    }

    public User getUser() {
        return user;
    }

}

构造自定义监听器继承ApplicationListener，编写监听事件发生后的处理逻辑

/**
 * 自定义事件监听器
 */
@Component
public class MyListener implements ApplicationListener<MyEvent> {

    @Override
    public void onApplicationEvent(MyEvent myEvent) {
        // 监听到相应事件后的处理逻辑
        User user = myEvent.getUser();
        System.out.println("监听到事件发生>>> User 对象创建");
        System.out.println("username>>>  " + user.getUsername());
        System.out.println("password>>>  " + user.getPassword());
    }
}

测试 Listener

利用 SpringBoot 定时任务定时发布事件，查看监听器监听到事件后的处理，记得在启动类上允许定时任务@EnableScheduling

@Service
public class ListenerService {

    @Resource
    private ApplicationContext applicationContext;

    /**
     * 定时任务模拟时间发生进行测试
     *
     * 5s 执行一次
     */
    @Scheduled(cron = "*/10 * * * * ?")
    public void testListenerEvent() {
        // 模拟事件发生
        System.out.println("模拟事件发生>>> User 对象创建");
        User user = User.builder()
                .username("test" + Math.random())
                .password("123@qq.com")
                .build();
        // 手动发布事件
        MyEvent myEvent = new MyEvent(this, user);
        applicationContext.publishEvent(myEvent);
    }

}

监听器测试结果

在springboot中使用拦截器

目前有一个需求，是在现有项目中集成一个简单的登录功能，想到了使用过滤器和拦截器实现，这篇文章介绍如何使用spring的拦截器。

1 拦截器定义

拦截器是在面向切面编程中应用的，就是在你的service或者一个方法前调用一个方法，或者在方法后调用一个方法。是基于JAVA的反射机制。

1.1 拦截器（Interceptor）执行顺序

1. 请求到达 DispatcherServlet
2. DispatcherServlet 发送至 Interceptor ，执行 preHandle
3. 请求达到 Controller
4. 请求结束后，postHandle 执行

1.2 拦截器（Interceptor）和过滤器（Filter）的执行顺序

过滤前->拦截前->Action处理->拦截后->过滤后

1.3 方法介绍

1）预处理preHandle()方法

用户发送请求时，先执行preHandle()方法。会先按照顺序执行所有拦截器的preHandle方法，一直遇到return false为止，比如第二个preHandle方法是return false，则第三个以及以后所有拦截器都不会执行。若都是return true，则执行用户请求的url方法。

2）后处理postHandle()方法

调用了Service并返回ModelAndView，但未进行页面渲染，可以在这里继续修改ModelAndView或者返回值

3）返回处理afterCompletion()方法

已经渲染了页面，在afterCompletion中，可以根据ex是否为null判断是否发生了异常，进行日志记录。

注：一般使用preHandle这个拦截器进行预处理，对url进行请求拦截

2 拦截器编写（实现HandlerInterceptor接口）

需要继承HandlerInterceptorAdapter类
注意，在更高版本中HandlerInterceptorAdapter已经弃用，推荐实现HandlerInterceptor接口

@Slf4j
@Component
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        log.info("进入到拦截器中:preHandle() 方法");
        System.out.println(request.getServletPath());
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        log.info("进入到拦截器中:postHandle() 方法中");
        System.out.println(request.getRequestURI());
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        log.info("进入到拦截器中:afterCompletion() 方法中");
        System.out.println(request.getServletPath());
    }
}

3 拦截器注册（实现WebMvcConfigurer接口）

需要继承WebMvcConfigurerAdapter类，注意，在更高版本中WebMvcConfigurerAdapter已经弃用，推荐实现WebMvcConfigurer接口；

需要重写addInterceptors(InterceptorRegistry registry)方法，这里是对根目录"/"进行拦截，可以指定拦截url请求目录

也可以通过继承WebMvcConfigurationSupport类来实现，但是只能继承一次，而且会导致其他不注册在此类中的拦截器失效，不建议使用。

@Configuration
public class InterceptorAdapterConfig  implements WebMvcConfigurer {

    private final LoginInterceptor loginInterceptor;

    public InterceptorAdapterConfig(LoginInterceptor loginInterceptor) {
        this.loginInterceptor = loginInterceptor;
    }

    @Override
    public void addInterceptors(InterceptorRegistry registry)
    {
        //注册自己的拦截器并设置拦截的请求路径
        registry.addInterceptor(loginInterceptor).addPathPatterns("/**");
    }
}

4 对指定方法进行拦截

这里的注册监听器，自定义监听器写法和前面一致。

如果对url目录下所有的请求进行了监听，但需要对某些请求方法不进行拦截或单独拦截，可以采用自定义注解方式，对方法加上自定义注解，拦截器进行扫描，对出现过自定义注解的方法进行单独处理

3.1 编写一个注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface NeedLogin {
    boolean LoginSuccess() default true;
}

3.2 修改拦截器

public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    log.info("进入到拦截器中:preHandle() 方法");
    HandlerMethod handlerMethod = (HandlerMethod) handler;
    NeedLogin loginVerify = handlerMethod.getMethodAnnotation(NeedLogin.class);
    if (loginVerify == null) {
        log.info("不需要对该路径 进行拦截");
        return true;
    }else {
        log.info("对该路径 进行拦截");
        log.info("业务操作...");
        return true;
    }
}

/**
 * 拦截后自定义响应
 */
public  void sendResponse(HttpServletResponse httpServletResponse, Object object) throws IOException {
    httpServletResponse.setContentType("application/json;charset=UTF-8");
    httpServletResponse.addHeader("Access-Control-Allow-Origin", "*");
    ServletOutputStream out = httpServletResponse.getOutputStream();
    out.write(objectMapper.writeValueAsString(object).getBytes(StandardCharsets.UTF_8));
    out.flush();
    out.close();
}

3.3 编写controller测试

@GetMapping("/test")
@NeedLogin
public String test() {
    System.out.println(LocalDateTime.now());
    return LocalDateTime.now().toString();
}

@GetMapping("/test2")
public String test2() {
    System.out.println(LocalDateTime.now());
    return LocalDateTime.now().toString();
}

5 拦截器中获取类注解和方法注解

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

        //必须强转为HandlerMethod
        HandlerMethod handlerMethod = (HandlerMethod) handler;

        //获取类上的注解
        IgnoreAuth clazzAnnotation = handlerMethod.getBeanType().getAnnotation(IgnoreAuth.class);

        //判断类上是否有打该注解
        boolean clazzAnnotationPresent = handlerMethod.getBeanType().isAnnotationPresent(IgnoreAuth.class);

        //获取方法上的注解 方式1
        IgnoreAuth methodAnnotation_1 = handlerMethod.getMethodAnnotation(IgnoreAuth.class);

        //获取方法上的注解 方式2
        IgnoreAuth methodAnnotation_2 = handlerMethod.getMethod().getAnnotation(IgnoreAuth.class);

        //判断方法上是否有打该注解
        boolean methodsAnnotationPresent = handlerMethod.getMethod().isAnnotationPresent(IgnoreAuth.class);
        
    }