spring的过滤器,拦截器,aop,advice等执行顺序

最新推荐文章于 2024-05-05 00:05:37 发布
最新推荐文章于 2024-05-05 00:05:37 发布
阅读量1.4k 收藏 7
点赞数 3
分类专栏： spring 文章标签： spring java springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41132384/article/details/129090953
版权 
有时候这几个技术都用的话会对业务造成影响;

名词解释

  • 过滤器; public class LoginFilter implements Filter
  • 拦截器; public class MyInterceptor implements HandlerInterceptor
  • aop; 切面编程. @Aspect实现
  • advice; @ControllerAdvice实现. 用于全局异常. 或者修改requestBody和 responseBody的值

springboot版本

本次是springboot 2.5.1版本.
不排除其他版本变动的可能性

省流版

结论

  • 粗略看
    在这里插入图片描述
  • 细看; 里面还有aop中 @Around, @AfterThrowing等的执行顺序
    在这里插入图片描述

具体代码

controller


package com.example.boottest.controller;

import com.example.boottest.domain.StudentDomain;
import com.example.boottest.exec.order.LogAction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


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

    /**
     *
     */
    @PostMapping("/LogAction")
    @LogAction
    public String methodDo(@RequestBody StudentDomain studentDomain) {
        log.info("真正的方法执行");
        //int ii = 1/0;

        return "1111";
    }

}

domain

package com.example.boottest.domain;

import lombok.Data;

/**
 * @author: riyueming
 * @date: 2023/2/17
 * @description:
 */
@Data
public class StudentDomain {
    String name;
}

过滤器


package com.example.boottest.exec.order;

import lombok.extern.slf4j.Slf4j;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import java.io.IOException;

/**
 * 登录过滤器
 *
 */

@Component
@Slf4j
@Order(9)
public class LoginFilter implements Filter {

    /**
     * 用户登录filter
     *
     * @param request
     * @param response
     * @param filterChain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        log.info("filter--------doFilter前");
        filterChain.doFilter(request, response);
        log.info("filter--------doFilter后");
    }



    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //TODO
    }

    @Override
    public void destroy() {
        //TODO
    }

}

拦截器


package com.example.boottest.exec.order;

import lombok.extern.slf4j.Slf4j;
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
@Slf4j
public class MyInterceptor implements HandlerInterceptor {// 实现HandlerInterceptor接口
	/**
	 * 访问控制器方法前执行
	 */
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		log.info("Interceptor-----preHandle");
		return true;
	}

	/**
	 * 访问控制器方法后执行
	 */
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {

		log.info("Interceptor-----postHandle");
	}

	/**
	 * postHandle方法执行完成后执行，一般用于释放资源
	 */
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		log.info("Interceptor-----afterCompletion");

	}
}











// 配置类

package com.example.boottest.exec.order;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * Web配置类
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {

	@Resource
	MyInterceptor myInterceptor;
	/**
	 * 添加Web项目的拦截器
	 */
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// 对所有访问路径，都通过MyInterceptor类型的拦截器进行拦截
		registry.addInterceptor(myInterceptor).addPathPatterns("/**")
		.excludePathPatterns("/", "/login", "/index.html", "/user/login", "/css/**", "/images/**", "/js/**", "/fonts/**");
		 //放行登录页，登陆操作，静态资源
	}
}

aop切面

//注解 
package com.example.boottest.exec.order;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author: siyu
 * @date: 2021/5/24
 * @description: 用于记录操作日志
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LogAction {

    String operation() default "";
}





//切面

package com.example.boottest.exec.order;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;


/**
 * @author: riyueming
 * @date: 2021/5/25
 * @description: 系统操作日志切面
 */
@Aspect
@Component
@Slf4j
public class LogAspect {


    @Pointcut("@annotation(LogAction)")
    public void pointcut() {
    }


    @Before(value = "pointcut()")
    public void before(JoinPoint joinPoint) {
        log.info("aop----before");
    }


    @Around("pointcut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        log.info("aop----around--前");
        Object proceed = point.proceed();
        log.info("aop----around--后");
        return proceed;
    }

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(logAction)", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, LogAction logAction, Object jsonResult) {
        log.info("aop----AfterReturning");
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param e         异常
     */
    @AfterThrowing(pointcut = "@annotation(logAction)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, LogAction logAction, Exception e) {
        log.info("aop----AfterThrowing");
    }


    @After(value = "@annotation(logAction)")
    public void after(JoinPoint joinPoint, LogAction logAction) {
        log.info("aop----after");
    }



}

advice

  • 全局异常拦截
package com.example.boottest.exec.order;

import com.example.boottest.common.ResultJson;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 控制器相关处理
 *
 * @author hushi
 */
@ControllerAdvice
@Slf4j
public class ControllerAdviceWrap {


    @Autowired
    public ControllerAdviceWrap() {
    }



    /**
     * 全局异常处理
     *
     * @param cause 错误对象
     * @return
     */
    @ResponseBody
    @ExceptionHandler(Exception.class)
    ResultJson resolveException(Exception cause) {

        log.info("ControllerAdvice--------ExceptionHandler");

        log.error(cause.getMessage(), cause);

        return ResultJson.buildFail(cause);
    }
}
  • requestBody 读取前拦截

package com.example.boottest.exec.order;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdviceAdapter;

import java.io.IOException;
import java.lang.reflect.Type;

@Slf4j
@ControllerAdvice
public class DecryptRequestBodyAdvice extends RequestBodyAdviceAdapter {


    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @SneakyThrows
    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<?
            extends HttpMessageConverter<?>> converterType) throws IOException {

        //必须是@RequestBody 才能进来
        log.info("ControllerAdvice------RequestBodyAdvice");

        return inputMessage;
    }
}
  • responseBody 返回前拦截
package com.example.boottest.exec.order;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

@Slf4j
@ControllerAdvice
public class EncryptResponseBodyAdvice implements ResponseBodyAdvice<Object> {



    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @SneakyThrows
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
                                  Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {

        log.info("ControllerAdvice------ResponseBodyAdvice");

        return body;
    }

}

启动类

别忘了加上@EnableAspectJAutoProxy 开启aop


package com.example.boottest;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.scheduling.annotation.EnableAsync;

import java.io.IOException;

@SpringBootApplication
@EnableAsync
@EnableAspectJAutoProxy
public class BootTestApplication {
    public static void main(String[] args) throws IOException {
        SpringApplication.run(BootTestApplication.class, args);
    }

}

运行结果展示

  • 请求
    在这里插入图片描述

  • 后端打印

成功时:

在这里插入图片描述

异常时:
注意异常是在 真正的方法执行 时出现的. 但是是在ControllerAdvice--------ExceptionHandler才打印出来
在这里插入图片描述
在这里插入图片描述

从而证实了前面的结论;

本文如对你有用,请点个赞, 谢谢

Maven_su
关注
  • 3
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring aop 拦截业务方法，实现权限控制示例
08-31
这个示例展示了如何结合Spring AOP、`ThreadLocal`和过滤器实现权限控制。需要注意的是，实际应用中权限控制可能更复杂，需要考虑角色、资源、操作等多个维度，并且通常会结合如Spring Security等专门的安全框架来...
aop权限管理实例
04-02
总的来说，这个AOP权限管理实例展示了如何利用Spring的AOP特性，结合过滤器和工具类，实现细粒度的权限控制，以及在不侵入业务逻辑的前提下，实现权限验证的统一处理。这样的设计模式有助于提高代码的可维护性和可...
关于filter/springinterceptor/aop的拦截顺序
w8y56f的专栏
03-21 3415
背景 关于filter/springinterceptor/aop的加载顺序。filter指继承javax.servlet.Filter的；springinterceptor是spring里的拦截器，实现HandlerInterceptor的；aop是指@Aspect注解的类 这三种都可以拦截对controller方法进行拦截。那拦截顺序是怎么样的? 结论 顺序是分级的，filter/spring...
过滤器，拦截器，SpringAop执行顺序详解（基于Springboot2.0）
X_X_K的博客
07-11 1693
结论：能看懂就不用往下翻了，不过点个赞还是很nice的 ====doFilter==== ====preHandle==== =====around02 start==== ====before02===== =====around01 start==== ====before01===== ====method run==== =====around01 end====1 =====afte...
过滤器、拦截器、aop的先后顺序和作用范围&拦截器preHandle(),postHandle(),afterComplation()方法执行顺序
最新发布
qq_43842093的博客
05-05 1154
在Spring框架中，过滤器（Filter）、拦截器（Interceptor）和面向切面编程（AOP）都是用于处理请求和处理流程的组件，但它们的作用范围和触发时机有所不同。下面我会解释这三者的先后顺序和作用范围。执行顺序：请注意，这个顺序可能因具体的配置和使用的技术而有所不同。在实际应用中，建议根据项目的具体需求来合理配置和使用这些组件。拦截器执行流程图：实现拦截器需要实现这个接口，这个 接口中有三个默认方法，这三个方法的执行顺序：我们实现接口然后重写这三个方法，就会在对应的时机被自动执行。这里就是调用处理
【Spring Boot入门】AOP基础及Advice的执行顺序
野生大头鱼
08-01 2292
本文主要分为两个部分，首先介绍AOP的基础，包括为什么要使用AOP以及AOP中的基本概念，然后讲解AOP中各类Advice的执行顺序并给出简单示例。 一、AOP基础 1、为什么要使用AOP AOP（Aspect Oriented Programming，面向切面编程），是Spring框架中的一个重要概念，那么面向切面编程有什么好处呢。 如下图所示,我们传统的编程方式是垂直化的编程，...
@ExceptionHandler的执行顺序以及@ExceptionHandler源码分析
weixin_42000891的博客
04-18 1627
@ExceptionHandler的执行顺序以及@ExceptionHandler源码分析,了解@ExceptionHandler注解的方法，加载和匹配异常处理方法的原理dubbo调用时，会对抛出的异常进行一次过滤器封装处理可以通过重写dubbo的ExceptionFilter和改变业务异常包ServiceExcepiton的方式来达到我们返回自定义异常信息给dubbo调用端的目的。
浅谈Spring的两种事务定义方式
08-29
事务管理器可以使用DataSourceTransactionManager，事务通知可以使用tx:advice，AOP配置可以使用aop:config。 在事务通知中，我们可以定义方法的过滤规则，例如所有方法都使用事务，或者定义所有get开头的方法都是...
spring security 参考手册中文版
02-01
25.1 AOP联盟（MethodInvocation）安全拦截器 197 25.1.1显式MethodSecurityInterceptor配置 197 25.2 AspectJ（JoinPoint）安全拦截器 198 26.基于表达式的访问控制 200 26.1概述 200 26.1.1通用内置表达式 201 ...
Spring中文帮助文档
08-05
13.4.3. 拦截器（HandlerInterceptor） 13.5. 视图与视图解析 13.5.1. 视图解析器（ViewResolver） 13.5.2. 视图解析链 13.5.3. 重定向（Rediret）到另一个视图 13.6. 本地化解析器 13.6.1. ...
SpringBoot--过滤器/拦截器/AOP--区别/使用/顺序
IT利刃出鞘的博客
11-18 7786
本文介绍SpringMVC（SpringBoot）中的过滤器、拦截器、AOP的区别及其用法。 如果监听器、过滤器、拦截器、AOP都存在，则它们的执行顺序为：监听器 => 过滤器=> 拦截器=> AOP。
filter、interceptor、controllerAdvice、aspect执行顺序
u014365523的博客
12-18 5587
执行顺序
Spring解密之HandlerInterceptor、HandlerMethodArgumentResolver、ResponseBodyAdvice执行顺序
lw_yang的博客
10-17 4684
概述 HandlerInterceptor用于拦截请求进行预处理和后处理，一般用于一下场景： 日志记录，可以记录请求信息的日志，以便进行信息监控、信息统计、计算PV（Page View）等等。 权限检查：如登陆检测，进入处理器检测是否登陆，如果没有直接返回到登陆页面。 性能监控：有时候系统在某段时间莫名其妙的慢，可以通过拦截器在进入处理器之前记录开始时间，在处理完后记录结束时间，从而得...
Springboot拦截器和过滤器的使用
山前山后各有哀愁 有风无风都不自由
06-26 1069
在Spring Boot中，你可以使用拦截器（Interceptor）和过滤器（Filter）来对请求进行拦截和处理。虽然它们的目标相似，但在实现和使用上存在一些区别。
Spring关于AOP中关于advice的执行顺序
迷雾总会解
03-02 664
AOP的核心概念      要完全理解Spring AOP首先要理解AOP的核心概念和术语，这些术语并不是Spring指定的，而且很不幸，这些术语并不能直观理解，但是，如果Spring使用自己的术语，那将更加令人困惑。       Aspect：切面，由一系列切点、增强和引入组成的模块对象，可...
SpringMVC系列第18篇：强大的RequestBodyAdvice解密
路人甲Java
10-05 6636
文末可以领取所有系列高清 pdf。大家好，我是路人，这是 SpringMVC 系列第 18 篇。1、前言在实际项目中，有时候我们需要在请求之前或之后做一些操作，比如：对参数进行解密，对所有...
Spring Filter+Advice实现统一响应以及全局异常处理
热门推荐
何忆清风
01-10 5万+
springmvc + filter + Advice实现统一结果、统一异常处理
spring拦截器和过滤器aop
07-27
Spring拦截器、过滤器和AOP是Spring框架中常用的三种技术，用于实现对请求的处理和控制。它们的作用和使用方式有一些不同，我会分别对它们进行简单解释。 1. 过滤器（Filter）： 过滤器是Java Servlet规范提供的一...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值