SpringBoot过滤器、监听器、拦截器、aop学习

1、过滤器

        过滤器是Servlet容器层面的，可以对所有路径请求进行过滤、增强，有三种实现方式

     1）无法设置路径和顺序

                通过@Compoment实现，实现Filter接口，默认是拦截/*

import org.springframework.stereotype.Component;

import javax.servlet.*;
import java.io.IOException;

@Component
public class DemoFilter1 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //过滤器初始化
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
        //执行操作,可以进行参数
        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {
        //过滤器销毁
    }
}

     2）可以设置路径，无法设置顺序

                实现Filte，通过在拦截器类上的@WebFilter和主类上的@ServletCompomentScan实现，可以通过@WebFilter配置路径、拦截器名等

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


/**
 *  filterName : 过滤器名字
 *  urlPatterns : 过滤路径
 */
@WebFilter
public class DemoFilter2 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

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

    @Override
    public void destroy() {

    }
}

     3）可以设置路径和顺序（推荐）

                实现Filter方法，通过配置类来注册、配置拦截器

DemoFilter3类

import javax.servlet.*;
import java.io.IOException;

public class DemoFilter3 implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {

    }

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

    }

    @Override
    public void destroy() {

    }
}

过滤器配置类

import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class DemoFilter3Config {

    @Bean
    public FilterRegistrationBean AFilter(){
        FilterRegistrationBean filterRegistrationBean = new FilterRegistrationBean();
        //将自己的过滤器注册
        filterRegistrationBean.setFilter(new DemoFilter3());
        //配置路径和名字等
        filterRegistrationBean.setName("");
        filterRegistrationBean.addUrlPatterns();
        return filterRegistrationBean;
    }
}

2、监听器

     监听器是Servlet层面的，可以实现对Web应用对象的监听，主要分为三类：

        1）ServletContext：对应application，实现接口ServletContextListener。在整个Web服务中只有一个，在Web服务关闭时销毁。可用于做数据缓存，例如结合redis，在Web服务创建时从数据库拉取数据到缓存服务器。
        2）HttpSession：对应session会话，实现接口HttpSessionListener。在会话起始时创建，一端关闭会话后销毁。可用作获取在线用户数量。
        3）ServletRequest：对应request，实现接口ServletRequestListener。request对象是客户发送请求时创建的，用于封装请求数据，请求处理完毕后销毁。可用作封装用户信息。

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class DemoListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent servletContextEvent) {
        //初始化上下文
    }

    @Override
    public void contextDestroyed(ServletContextEvent servletContextEvent) {
        //销毁
    }
}

3、拦截器

        拦截器依赖于Spring框架，不是Servlet层面的，区别于过滤器，拦截器只能拦截SpringMVC的请求，实现通过一下两个步骤：

           1）声明拦截器的类：通过实现HandlerInterceptor接口，实现preHandle、postHandle和afterCompletion方法。

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 {
        //预处理
        return HandlerInterceptor.super.preHandle(request, response, handler);
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        //拦截后处理
        HandlerInterceptor.super.postHandle(request, response, handler, modelAndView);
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        //整个流程结束后处理
        HandlerInterceptor.super.afterCompletion(request, response, handler, ex);
    }
}

           2）通过配置类配置拦截器：通过实现WebMvcConfigurer接口，实现addInterceptors方法。

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 DemoInterceptorConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        WebMvcConfigurer.super.addInterceptors(registry);
    }
}

4、aop

        引入jar包，通过注解就可以使用

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect
//标明切面类
public class DemoAop {

    //用于确认切点，execution表明在执行方法时触发，*表明是任意返回值类型，然后是包路径， .*是包下任意类，.*然后是任意方法，(..)是任意参数
    @Pointcut("execution(* 路径.*.*(..))")
    public void test(){

    }

    //切点运行之前运行
    @Before("test()")
    public void before(){
        System.out.println("before。。。。。。。。。。");
    }

    //切点运行之后运行
    @After("test()")
    public void after(){
        System.out.println("after/");
    }
    
    //环绕通知，在切点执行前后执行
    @Around("test()")
    public void around(ProceedingJoinPoint joinPoint){

        System.out.println("before");

        try {
            //启动目标方法的执行
            joinPoint.proceed();
        } catch (Throwable e) {
            throw new RuntimeException(e);
        }

        System.out.println("after");
    }

}