Springboot的拦截过滤与监听

「这是我参与11月更文挑战的第14天，活动详情查看：2021最后一次更文挑战」

一、监听器

1.1 定义

Servlet 监听器是 Servlet 规范中定义的一种特殊类，用于监听 ServletContext、HttpSession 和 ServletRequest 等域对象的创建与销毁事件，以及监听这些域对象中属性发生修改的事件。监听器是观察者模式的应用，它关注特定事物，并伺机而动，所以监听器具有异步的特性。

Servlet Listener 监听三大域对象的创建和销毁事件，三大对象分别是：

0. ServletContext：application 级别，整个应用只存在一个，可以进行全局应用配置。
1. HttpSession：session 级别，针对每一个对话，如统计会话总数。
2. ServletRequest：request 级别，针对每一个客户请求，

1.2 使用场景

Servlet 规范设计监听器的作用是在事件发生前、发生后进行一些处理，一般可以用来统计在线人数和在线用户、统计网站访问量、系统启动时初始化信息等。我们可以在容器启动时初始化 Log4j 信息，添加自己对容器状态的监控，初始化 Spring 组件等。

1.3 监听器的实现

创建一个ServletRequest监听器(其他监听器类似创建)

@WebListener
@Slf4j
public class Customlister implements ServletRequestListener{
​
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        log.info(" request监听器：销毁");
    }
​
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        log.info(" request监听器：可以在这里记录访问次数哦");
    }
​
}
复制代码

在启动类中加入@ServletComponentScan进行自动注册即可。

二、过滤器

2.1 定义

过滤器是一种可重用的代码，可以转换 HTTP 请求、响应和头信息，通俗来说就是过滤器可以在请求到达服务器之前，对请求头进行预先处理，在响应内容到达客户端之前，对服务器做出的响应进行后置处理。根据这个定义，我们就不难理解为什么它是位于 Listener 的下游，Servlet 的上游了？过滤器必须是在容器启动之后，接收到请求后开始处理，所以它是在 Listener 执行之后；在请求到达 Servlet 之前进行预处理，所以它又处于 Servlet 之前的位置。从命名上理解，它就是对请求和响应的数据内容进行过滤处理的，并非前端传过来的数据都全单接收，而是有原则地进行过滤处理，以保证后端服务器业务的安全。

2.2 使用场景

Servlet 3.1 中定义了几种常见的过滤器组件：

过滤器	作用
Authentication filters：	授权类，如用户登陆会话校验；
Logging and auditing filters：	日志和安全审计类；
Image conversion filters：	图片转换；
Data compression filters：	数据压缩；
Encryption filters：	加密、解密类；
Tokenizing filters：	词法类；
Filters that trigger resource access events：	触发资源访问事件类；
XSL/T filters that transform XML content：	XML文件转换类；
MIME-type chain filters：	MIME文件；
Caching filters：	缓存类；

或者我们社交应用经常需要的敏感词过滤，都可以使用过滤器。过滤器主要的特点在于，它能够改变请求内容。

2.3 过滤器的实现

过滤器Filter，是Servlet的的一个实用技术了。可通过过滤器，对请求进行拦截，比如读取session判断用户是否登录、判断访问的请求URL是否有访问权限(黑白名单)等。主要还是可对请求进行预处理。接下来介绍下，在springboot如何实现过滤器功能。

1.1 实现方式一:利用WebFilter注解配置

@WebFilter是Servlet3.0新增的注解，原先实现过滤器，需要在web.xml中进行配置，而现在通过此注解，启动启动时会自动扫描自动注册。

编写Filter类：

//注册器名称为customFilter,拦截的url为所有
@WebFilter(filterName="customFilter",urlPatterns={"/*"})
@Slf4j
public class CustomFilter implements Filter{
​
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("filter 初始化");
    }
​
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        log.info("customFilter 请求处理之前");
        //对request、response进行一些预处理
        // 比如设置请求编码
        // request.setCharacterEncoding("UTF-8");
        // response.setCharacterEncoding("UTF-8");
​
        //链路 直接传给下一个过滤器
        chain.doFilter(request, response);
​
        log.info("customFilter 请求处理之后");
    }
​
    @Override
    public void destroy() {
        log.info("filter 销毁");
    }
}
复制代码

然后在启动类加入@ServletComponentScan注解即可。使用这种方法，当注册多个过滤器时，无法指定执行顺序的，原本使用web.xml配置过滤器时，是可指定执行顺序的，但使用@WebFilter时，没有这个配置属性的(需要配合@Order进行)，所以接下来介绍下通过FilterRegistrationBean进行过滤器的注册。

–小技巧–通过过滤器的java类名称，进行顺序的约定，比如LogFilter和AuthFilter，此时AuthFilter就会比LogFilter先执行，因为首字母A比L前面。

1.2.FilterRegistrationBean方式FilterRegistrationBean是springboot提供的，此类提供setOrder方法，可以为filter设置排序值，让spring在注册web filter之前排序后再依次注册。首先要改写filter, 其实就除了@webFilter注解即可。其他的都没有变化。启动类中利用@bean注册FilterRegistrationBean

@Configuration
public class FilterRegistration {
    @Bean
    public FilterRegistrationBean filterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        //当过滤器有注入其他bean类时，可直接通过@bean的方式进行实体类过滤器，这样不可自动注入过滤器使用的其他bean类。
        //当然，若无其他bean需要获取时，可直接new CustomFilter()，也可使用getBean的方式。
        registration.setFilter(customFilter());
        //过滤器名称
        registration.setName("customFilter");
        //拦截路径
        registration.addUrlPatterns("/*");
        //设置顺序
        registration.setOrder(10);
        return registration;
    }
​
    @Bean
    public Filter customFilter() {
        return new CustomFilter();
    }
}
复制代码

注册多个时，就注册多个FilterRegistrationBean即可,启动后，效果和第一种是一样的。

三、servlet

3.1定义：

在java程序员10年以前做web开发的时候，所有的请求都是由servlet来接受并响应的。每一个请求，就要写一个servlet。这种方式很麻烦，大家就想能不能根据请求的路径以及参数不同，映射到不同的方法上去执行，这样就可以在一个servlet类里面处理多个请求，每个请求就是一个方法。这个思想后来就主键发展为structs、SpringMVC。

3.2使用场景

目前来看，servlet使用的场景已经被springMVC架构全面覆盖。但是不排除，老项目向spring boot项目迁移，需要支持servlet的情况。

3.3 实现

下面我们就看一下，在spring boot里面如何实现servlet。

@WebServlet(name = "firstServlet", urlPatterns = "/firstServlet") //标记为servlet，以便启动器扫描。
public class FirstServlet extends HttpServlet {
​
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().append("firstServlet");
    }
​
}
复制代码

然后在启动类加入@ServletComponentScan注解即可。

四、拦截器

4.1定义

在 Servlet 规范中并没有拦截器的概念，它是面向切面编程的一种应用：在需要对方法进行增强的场景下，例如在方法调用前执行一段代码，或者在方法完成后额外执行一段操作，拦截器的一种实现方式就是动态代理。把过滤器和拦截器放在一起比较，我觉得是没有意义的，本质上是不同概念，并没有可比性，它位于过滤器的下游，是面向 Servlet 方法的。

4.2使用场景

AOP 编程思想面对的是横向的切面，而非纵向的业务。举个简单的例子，每个方法处理过程中，除了业务逻辑外，我们都会有一些相同的操作：参数校验，日志打印等，虽然这些处理代码并不多，但是每个方法都要写这类东西，工作量就不小了。能否使用程序来统一加入这类操作，而不用程序员自己手写呢？这就是切面编程思想的应用，利用 Java 的代理，在调用真正的方法之前或者之后，添加一些额外的增强功能。

4.3拦截器的实现

以上的过滤器、监听器都属于Servlet的api，我们在开发中处理利用以上的进行过滤web请求时，还可以使用Spring提供的拦截器(HandlerInterceptor)进行更加精细的控制。

编写自定义拦截器类

@Slf4j
public class CustomHandlerInterceptor implements HandlerInterceptor{
​
 @Override
 public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
   throws Exception {
  log.info("preHandle:请求前调用");
  //返回 false 则请求中断
  return true;
 }
​
 @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
   ModelAndView modelAndView) throws Exception {
  log.info("postHandle:请求后调用");
​
 }
​
 @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
   throws Exception {
  log.info("afterCompletion:请求调用完成后回调方法，即在视图渲染完成后回调");
​
 }
​
}
复制代码

通过继承WebMvcConfigurerAdapter注册拦截器。WebMvcConfigurerAdapter类已经被废弃，请实现WebMvcConfigurer接口完成拦截器的注册。

@Configuration
//废弃：public class MyWebMvcConfigurer extends WebMvcConfigurerAdapter{
public class MyWebMvcConfigurer implements WebMvcConfigurer 
 @Override
  public void addInterceptors(InterceptorRegistry registry) {
   //注册拦截器 拦截规则
  //多个拦截器时 以此添加 执行顺序按添加顺序
  registry.addInterceptor(getHandlerInterceptor()).addPathPatterns("/*");
  }
    
 @Bean
 public static HandlerInterceptor getHandlerInterceptor() {
  return new CustomHandlerInterceptor();
 }
}
复制代码

五、自定义事件和自定义监听器类

自定义事件和自定义监听器类的实现方式自定义事件：继承自ApplicationEvent抽象类，然后定义自己的构造器自定义监听：实现ApplicationListener接口，然后实现onApplicationEvent方法

springboot进行事件监听有四种方式1.手工向ApplicationContext中添加监听器2.将监听器装载入spring容器3.在application.properties中配置监听器4.通过@EventListener注解实现事件监听

5.1、代码实现

下面讲下4种事件监听的具体实现

方式1.

首先创建MyListener1类

@Slf4j
public class MyListener1 implements ApplicationListener<MyEvent> {
    public void onApplicationEvent(MyEvent event) {
        log.info(String.format("%s监听到事件源：%s.", MyListener1.class.getName(), event.getSource()));
    }
}
复制代码

然后在springboot应用启动类中获取ConfigurableApplicationContext上下文，装载监听

@SpringBootApplication
public class BootLaunchApplication {
​
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(BootLaunchApplication.class, args);
        //装载监听
        context.addApplicationListener(new MyListener1());
    }
}
复制代码

方式2（推荐）.

创建MyListener2类，并使用@Component注解将该类装载入spring容器中

@Component
@Slf4j
public class MyListener2 implements ApplicationListener<MyEvent> {
​
    public void onApplicationEvent(MyEvent event) {
        log.info(String.format("%s监听到事件源：%s.", MyListener2.class.getName(), event.getSource()));
    }
​
}
复制代码

方式3.

首先创建MyListener3类

@Slf4j
public class MyListener3 implements ApplicationListener<MyEvent> {
    public void onApplicationEvent(MyEvent event) {
        log.info(String.format("%s监听到事件源：%s.", MyListener3.class.getName(), event.getSource()));
    }
}
复制代码

然后在application.yml中配置监听

context:
  listener:
    classes: club.krislin.customlistener.MyListener3
复制代码

方式4（推荐）.

创建MyListener4类，该类无需实现ApplicationListener接口，使用@EventListener装饰具体方法

@Slf4j
@Component
public class MyListener4 {
    @EventListener
    public void listener(MyEvent event) {
        log.info(String.format("%s监听到事件源：%s.", MyListener4.class.getName(), event.getSource()));
    }
}
复制代码

自定义事件代码如下：

@SuppressWarnings("serial")
public class MyEvent extends ApplicationEvent
{
 public MyEvent(Object source)
 {
  super(source);
 }
}
复制代码

5.2、测试监听事件发布

有了applicationContext，想在哪发布事件就在哪发布事件

@RunWith(SpringRunner.class)
@SpringBootTest
public class CustomListenerTest {
​
    @Resource private
    ApplicationContext applicationContext;
​
    @Test
    public void testEvent(){
        applicationContext.publishEvent(new MyEvent("测试事件."));
    }
}
复制代码

启动后，日志打印如下。（下面截图是在启动类发布事件后的截图，在单元测试里面监听器1监听不到，执行顺序问题）：

由日志打印可以看出，SpringBoot四种事件的实现方式监听是有序的。无论执行多少次都是这个顺序。

小结

以上介绍了监听器，过滤器，servlet，拦截器，以及# 自定义事件和自定义监听器类的过程，通过对以上操作的学习，可以完成一些特殊场景下的功能。