springboot的过滤器、拦截器、AOP

1、作用优先级

谨记： 过滤器 > 拦截器 > AOP

2、三者定义

2.1 过滤器（拦截器拦截的是URL）

Spring中自定义过滤器（Filter），当请求到达web容器时，会探测当前请求地址是否配置有过滤器，有则调用该过滤器的 doFilter 方法（可能会有多个过滤器），然后调用filterChain.doFilter(request,response)方法，才调用真实的业务逻辑，至此过滤器任务完成。

2.2 拦截器（拦截器拦截的是URL）

拦截器（HandlerInterceptor）有三个方法，相对于过滤器更加细致，有被拦截逻辑执行前、后等。Spring中拦截器有三个方法：preHandle，postHandle，afterCompletion。当请求匹配到对应的拦截器时，先执行 preHandle方法，返回值为boolean类型，true代表继续执行，false代表请求终止。若为true时，执行完preHandle方法，则执行真正的业务请求方法。postHandle在处理完业务请求后，返回时生效。而afterCompletion是整个请求完成才执行。

2.2 AOP（面向切面）

面向切面拦截的是类的元数据（包、类、方法名、参数等）

相对于过滤器、拦截器更加细致，而且非常灵活，拦截器只能针对URL做拦截，而AOP针对具体的代码，能够实现更加复杂的业务逻辑

3、三者使用场景

从过滤器–》拦截器–》切面，拦截规则越来越细致，执行顺序依次是过滤器、拦截器、切面。一般情况下数据被过滤的时机越早对服务的性能影响越小，因此我们在编写相对比较公用的代码时，优先考虑过滤器，然后是拦截器，最后是aop。比如权限校验，一般情况下，所有的请求都需要做登陆校验，此时就应该使用过滤器在最顶层做校验；日志记录，一般日志只会针对部分逻辑做日志记录，而且牵扯到业务逻辑完成前后的日志记录，因此我们会考虑到使用AOP实现，AOP可以针对代码的方法级别做拦截，很适合日志功能。

4、小试牛刀

ps：springboot版本 1.5.14.RELEASE ，由于属于springmvc内容，版本影响应该不大。注释内容都可以试试，我自己留个印象，我就不删了

4.1 过滤器 filter

两种实现方式：一、 注解@WebFilter 二、 配置文件
自定义filter，可以用@WebFilter进行注册（启动类记得添加注解 @ServletComponentScan 进行扫描），亲测本版本使用@order注解未能对过滤器进行排序，其他版本请自行测试。

/**
 * 自定义 过滤器   启动类添加 @ServletComponentScan//扫描自定义过滤器
 * 过滤器可以改变用户请求的资源  例如修改用户请求路径
 * 过滤器不能直接处理用户请求，返回数据
 */
@Slf4j
//@WebFilter(urlPatterns = "/*", filterName = "myFilter")  注解方式不支持排序
public class myFilter implements Filter {
    private FilterConfig filterConfig;

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        this.filterConfig=filterConfig;
        //可以这里设置初始化参数 也可以在下面第二种方式：配置文件中配置
       //filterConfig.getServletContext().setInitParameter("encoding","utf-8");
        //
        System.out.println("初始化参数，自定义过滤器加载----------------------------------------------------");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        log.info("进入自定义过滤器1--------------------");
        //System.out.println(this.filterConfig.getInitParameter("test0"));
        HttpServletResponse httpServletResponse=  (HttpServletResponse)response;
        HttpServletRequest httpServletRequest = (HttpServletRequest) request;
        //System.out.println(this.filterConfig.getInitParameter("test0"));
        //统一设置编码 utf-8(encoding 自定义初始化参数)
        //if(StringUtils.isNotBlank(this.filterConfig.getInitParameter("encoding"))){
            //httpServletRequest.setCharacterEncoding(this.filterConfig.getInitParameter("encoding"));
       // }

//        //避免重定向路径 死循环
//        if(httpServletRequest.getRequestURI().contains("/excel/index")){
//            filterChain.doFilter(request,response);
//            return;
//        }
        //重定向（浏览器路径发生改变,重定向到xxx路径）
        //httpServletResponse.sendRedirect("/excel/index");
        //转发（浏览器路径不会发生改变）
        //request.getRequestDispatcher("/excel/index").forward(request,response);
        filterChain.doFilter(request,response);
       // httpServletRequest.setCharacterEncoding("utf-8");
        log.info("离开自定义过滤器1--------------------");

    }

    @Override
    public void destroy() {
        System.out.println("自定义过滤器删除----------------------------------------------------");}
}

方式二、采用配置文件，进行注册，可以实现多过滤器执行排序，order越小 优先级越高

/**
 * 自定义 请求过滤器配置   order越小优先级约高  同理 order越大优先级约低
 */
@Configuration
public class MyFilterConfig {

	//过滤器一
    @Bean
    public FilterRegistrationBean myFilter(){
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(new myFilter());
        //自定义一些参数
        registrationBean.addInitParameter("test0","true");
        registrationBean.addInitParameter("test1", "test");
         registrationBean.addInitParameter("encoding","utf-8");
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(100); // 设置排序
        //设置监听级别      FORWARD（转发）,INCLUDE,REQUEST（请求）,ASYNC（异步）,ERROR
        registrationBean.setDispatcherTypes(DispatcherType.REQUEST);
        return registrationBean;
    }

	//过滤器二
    @Bean
    public FilterRegistrationBean mySecondFilter(){
        FilterRegistrationBean registrationBean = new FilterRegistrationBean();
        registrationBean.setFilter(new mySecondFilter());
        registrationBean.addInitParameter("test2","true");
        registrationBean.addInitParameter("test3", "test");
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(10); // 设置排序
        registrationBean.setDispatcherTypes(DispatcherType.REQUEST);
        return registrationBean;
    }
}

过滤器Filter依赖于Servlet容器，过滤范围大。

4.2 拦截器 Interceptor

实现拦截器有两个接口，继承 HandlerInterceptor 或者继承 WebRequestInterceptor都可以。本章节只实现HandlerInterceptor。原因是 HandlerInterceptor更加强大。

**
 *自定义 拦截器   也可以集成 WebRequestInterceptor作为拦截器
 */
public class myHandlerInterceptor implements HandlerInterceptor
{
    /**
     *  * 返回值 false  请求终止
     *  * 返回值 true   请求继续执行
     *   Object o 表示被拦截的请求目标对象 即controller对象
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("执行了拦截器  --------------preHandle方法");


        //return false;
        return true;
    }

    /**
     * 请求执行结束，返回时候，执行该方法
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("执行了拦截器  --------------postHandle");
        //可以通过 modelAndView 修改视图路径

    }

    /**
     * 请求返回后，最后执行的方法
     * @param httpServletRequest
     * @param httpServletResponse
     * @param o
     * @param e
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("执行了拦截器  --------------afterCompletion");
    }
}

注册自定义 拦截器myHandlerInterceptor 到容器 ，注意WebMvcConfigurer 有许多实现接口，但是为了美观，删除了，用到时候，引入一下就可以了，其他接口方法的用途请自行百度学习。

@Configuration
public class InterceptorConfig implements WebMvcConfigurer {


    /**
     * 拦截器注册
     * @param interceptorRegistry
     */
    @Override
    public void addInterceptors(InterceptorRegistry interceptorRegistry) {
        //多拦截器，就继续添加interceptorRegistry.addInterceptor  添加的顺序，就是拦截器的顺序

        interceptorRegistry.addInterceptor(new myHandlerInterceptor()).addPathPatterns("/test/*").excludePathPatterns("/test/test2");
        interceptorRegistry.addInterceptor(new myHandlerInterceptor2()).addPathPatterns("/test/*").excludePathPatterns("/test/test2");


    }


}

4.3 面向切面 AOP

AOP中 @Before @After @AfterThrowing@AfterReturning的执行顺序
基于 自定义注解作为切点 实现对日志的记录。

/**
 * 操作注解
 * @author 曾  自定义注解 用于操作日志
 */
@Target(ElementType.METHOD) //注解放置的目标位置,METHOD是可注解在方法级别上
@Retention(RetentionPolicy.RUNTIME) //注解在哪个阶段执行
@Documented
public @interface OperLog {

     String operModul() default ""; // 操作模块

     String operType() default "";  // 操作类型

     String operDesc() default "";  // 操作说明

}

AOP常用的通知注解有 @before @AfterReturning @ Around 本代码最终使用@ Around方法，其中@before @AfterReturning都已经实现，部分注释了

/**
 * 操作日志
 */
@Aspect  //切面注解
@Component
@Slf4j
public class OpenLoggerConfig {

    /**
     * 设置操作日志切入点 记录操作日志 在注解的位置切入代码
     */
    @Pointcut("@annotation(com.cloud.user.config.OperLog)")
    public void operLogPointcut(){
    }

    /**
     * 设置操作异常切入点记录异常日志 扫描所有controller包下操作  可以改成扫描的包路径
     */
    @Pointcut("execution(* com.cloud.user.myUser.*.controller..*.*(..))")
    public void operExceptionLogPointcut(){
    }

    /**
     * 执行切点方法之前,执行该方法
     * @param joinPoint
     */
    //@Before(value = "operLogPointcut()||operExceptionLogPointcut()")
    public void saveBeforeOperLog(JoinPoint joinPoint){
        log.info("我进来了，我即将要操作！！！------Before  Before  Before---------------");
    }


    /**
     * 环绕通知,无论是切点方法 开始还是结束,都执行该方法  @Around 需要提供返回值 （小坑）
     * @param joinPoint
     */
    @Around(value = "operLogPointcut()||operExceptionLogPointcut()")
    public Object saveAroundOperLog(ProceedingJoinPoint joinPoint) {
        Object proceed=null;
        log.info("我进来了，我即将要操作！！！--------Around  Around   Around-------------");
        long startTime = System.currentTimeMillis();
        System.err.println("startTime = " + startTime);
        try {
             proceed = joinPoint.proceed();
        }catch (Throwable e){
            //异常处理
            this.saveExceptionOperLog(joinPoint,e);
            long endTime = System.currentTimeMillis();
            System.err.println("endTime = " + endTime);
            long  alltime=endTime-startTime;
            log.info("我执行完了，我即将要离开！！！--------Around  Around   Around----------本次花费时间为:"+alltime+"毫秒");
            return proceed;
        }
        //正常操作处理
        this.saveOperLog(joinPoint,proceed);

        long endTime = System.currentTimeMillis();
        System.err.println("endTime = " + endTime);
        long  alltime=endTime-startTime;
        log.info("我执行完了，我即将要离开！！！--------Around  Around   Around----------本次花费时间为:"+alltime+"毫秒");
        return proceed;

    }

    /**
         * 正常返回通知，拦截用户操作日志，连接点正常执行完成后执行， 如果连接点抛出异常，则不会执行
         *
         * @param joinPoint 切入点
         * @param keys      返回结果
         */
    //@AfterReturning(pointcut = "operLogPointcut()",returning = "keys")
    public void saveOperLog(JoinPoint joinPoint, Object keys){
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();

        // 从获取RequestAttributes中获取HttpServletRequest的信息
                 HttpServletRequest request = (HttpServletRequest) requestAttributes
                         .resolveReference(RequestAttributes.REFERENCE_REQUEST);

                 try {
                         // 从切面织入点处通过反射机制获取织入点处的方法
                         MethodSignature signature = (MethodSignature) joinPoint.getSignature();
                         // 获取切入点所在的方法
                         Method method = signature.getMethod();
                         // 获取操作
                         OperLog opLog = method.getAnnotation(OperLog.class);
                        String operModul = "";
                        String operType = "";
                        String operDesc = "";
                         if (opLog != null) {
                                  operModul = opLog.operModul();
                                  operType = opLog.operType();
                                  operDesc = opLog.operDesc();

                             }
                         // 获取请求的类名
                         String className = joinPoint.getTarget().getClass().getName();
                         // 获取请求的方法名
                         String methodName = method.getName();
                         methodName = className + "." + methodName;
                         // 请求的参数
                         Map<String, String> returnMap = converMap(request.getParameterMap());

                         log.info("请求的路径为："+request.getRequestURL()+"--------------");
                         log.info("请求的类方法为："+methodName+"具体描述:"+operModul+operType+operDesc+"--------------");
                         log.info("请求的参数为："+returnMap.toString()+"--------------");
                         if(keys==null){
                             log.info("请求方法返回结果为："+null+"--------------");
                             return;
                         }
                         log.info("请求方法返回结果为："+keys.toString()+"--------------");

                     } catch (Exception e) {
                         e.printStackTrace();
                     }
    }

    /**
     * 异常处理日志保存
     * @param joinPoint
     * @param error
     */
    //@AfterThrowing(pointcut = "operLogPointcut()",throwing = "error")
    public void saveExceptionOperLog(JoinPoint joinPoint, Throwable  error){
        // 获取RequestAttributes
        RequestAttributes requestAttributes = RequestContextHolder.getRequestAttributes();

        // 从获取RequestAttributes中获取HttpServletRequest的信息
        HttpServletRequest request = (HttpServletRequest) requestAttributes
                .resolveReference(RequestAttributes.REFERENCE_REQUEST);

        try {
            // 从切面织入点处通过反射机制获取织入点处的方法
            MethodSignature signature = (MethodSignature) joinPoint.getSignature();
            // 获取切入点所在的方法
            Method method = signature.getMethod();
            // 获取操作
            OperLog opLog = method.getAnnotation(OperLog.class);
            String operModul = "";
            String operType = "";
            String operDesc = "";
            if (opLog != null) {
                operModul = opLog.operModul();
                operType = opLog.operType();
                operDesc = opLog.operDesc();

            }
            // 获取请求的类名
            String className = joinPoint.getTarget().getClass().getName();
            // 获取请求的方法名
            String methodName = method.getName();
            methodName = className + "." + methodName;
            // 请求的参数
            Map<String, String> returnMap = converMap(request.getParameterMap());

            log.info("请求的路径为："+request.getRequestURL()+"--------------");
            log.info("请求的类方法为："+methodName+"具体描述:"+operModul+operType+operDesc+"--------------");
            log.info("请求的参数为："+returnMap.toString()+"--------------");

            log.info("异常名称："+error.getClass().getName()+"--------------");
            log.info("异常信息："+stackTraceToString(error.getClass().getName(), error.getMessage(), error.getStackTrace()));

        } catch (Exception e) {
            e.printStackTrace();
        }
    }



     /**
       * 转换request 请求参数
       *
       * @param paramMap request获取的参数数组
     */
    public Map<String, String> converMap(Map<String, String[]> paramMap) {
         Map<String, String> rtnMap = new HashMap<String, String>();
         for (String key : paramMap.keySet()) {
                 rtnMap.put(key, paramMap.get(key)[0]);
             }
         return rtnMap;
    }

    /**
           * 转换异常信息为字符串
           *
           * @param exceptionName    异常名称
           * @param exceptionMessage 异常信息
           * @param elements         堆栈信息
     */
     public String stackTraceToString(String exceptionName, String exceptionMessage, StackTraceElement[] elements) {
//             StringBuffer strbuff = new StringBuffer();
//             for (StackTraceElement stet : elements) {
//                     strbuff.append(stet + "\n");
//                 }
             //String message = exceptionName + ":" + exceptionMessage + "\n\t" + strbuff.toString();
             String message = exceptionName + ":" + exceptionMessage ;
             return message;
     }
}

随便构建一个测试方法，访问即可（如图）。

5、总结

1、过滤器依赖于Servlet容器 ，拦截器不依赖与servlet容器，是SpringMVC自带的。

2、拦截器是基于java的反射机制的，而过滤器是基于函数回调

3、优先级：过滤器 > 拦截器 > AOP ，同时 粒度（粗->细）过滤器- > 拦截器 -> AOP

4、过滤器可以改变用户请求的资源 例如修改用户请求路径 ，不能直接处理用户请求，返回数据。