Java Spring AOP

Spring AOP概述

在使用Spring框架的时候,经常需要和Spring的2大特性,IOC和AOP打交道。

「AOP这种设计理念常见的概念如下」

2021-09-28-08-53-51-605159.png

「AOP的主要应用场景如下」

2021-09-28-08-53-51-907150.png

「Spring AOP的实现主要经历了2代」

第一代:spring1.x版本,自己实现了AOP的功能 第二代:spring2.x版本,Spring集成了AspectJ的实现

Spring AOP一代

「当要基于现成的实现增加横切逻辑时,首先需要找到哪些地方增强,就用Pointcut来进行筛选吧」
先写一个Service方便后面的演示

  1. public interface EchoService {
  2. String echo(String message);
  3. }
  4. public class DefaultEchoService implements EchoService {
  5. @Override
  6. public String echo(String message) {
  7. return message;
  8. }
  9. }

Pointcut

Pointcut接口定义如下

  1. public interface Pointcut {
  2. // 通过类过滤
  3. ClassFilter getClassFilter();
  4. // 通过方法过滤
  5. MethodMatcher getMethodMatcher();
  6. Pointcut TRUE = TruePointcut.INSTANCE;
  7. }

「当想筛选出EchoService的echo方法时,就可以定义如下的Pointcut」

  1. public class EchoPointcut implements Pointcut {
  2. @Override
  3. public ClassFilter getClassFilter() {
  4. return new ClassFilter() {
  5. @Override
  6. public boolean matches(Class<?> clazz) {
  7. return EchoService.class.isAssignableFrom(clazz);
  8. }
  9. };
  10. }
  11. @Override
  12. public MethodMatcher getMethodMatcher() {
  13. return new MethodMatcher() {
  14. @Override
  15. public boolean matches(Method method, Class<?> targetClass) {
  16. return "echo".equals(method.getName()) &&
  17. method.getParameterTypes().length == 1 &&
  18. Objects.equals(String.class, method.getParameterTypes()[0]);
  19. }
  20. @Override
  21. public boolean isRuntime() {
  22. return false;
  23. }
  24. @Override
  25. public boolean matches(Method method, Class<?> targetClass, Object... args) {
  26. return false;
  27. }
  28. };
  29. }
  30. }

看起来还是很麻烦的,因此Spring内置了很多实现,一般情况下用内置的实现即可,不用自己定义,上面的筛选过程就可以改为如下

  1. // 方法名为 echo 会被拦截
  2. NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
  3. pointcut.setMappedName("echo");

Spring提供的部分Pointcut实现如下
2021-09-28-08-53-51-907150.png

Jointpoint

「通过Pointcut筛选出来的要增加横切逻辑的地方就是Jointpoint。」 在AOP理念中,很多地方可以增加横切逻辑,如方法执行,字段设置等。但是「Spring只支持方法执行这一种Joinpoint」,因为这种类型的Jointpoint基本上已经满足80%的场景了
Joinpoint类型中 「方法调用优于方法执行」
2021-09-28-08-53-52-532155.png
因为Spring中只支持方法执行这一种Joinpoint,所以可以从Joinpoint实现类中获取增强的方法信息
2021-09-28-08-53-52-810151.png

Advice

当筛选出Jointpoint时,就需要在这些Jointpoint上增加横切逻辑,这些横切逻辑被称为Advice
2021-09-28-08-53-53-138160.png
在Spring中实现横切逻辑的方式有两类

  1. 实现Advice接口
  2. 实现IntroductionInfo接口

实现Advice接口的方式最常用。实现IntroductionInfo接口的方式基本不会用,这里演示一下具体的用法,方便理解整个AOP API的设计理念
IntroductionInfo主要是通过给目标类实现特定接口来增加新功能」

  1. public interface SayName {
  2. String getName();
  3. }
  4. public class DefaultSayName implements SayName {
  5. @Override
  6. public String getName() {
  7. return "I am service";
  8. }
  9. }
  10. public static void main(String[] args) {
  11. SayName sayName = new DefaultSayName();
  12. EchoService echoService = new DefaultEchoService();
  13. // IntroductionInfo接口的内置实现
  14. DelegatingIntroductionInterceptor interceptor =
  15. new DelegatingIntroductionInterceptor(sayName);
  16. Advisor advisor = new DefaultIntroductionAdvisor(interceptor, SayName.class);
  17. ProxyFactory proxyFactory = new ProxyFactory(echoService);
  18. proxyFactory.addAdvisor(advisor);
  19. // hello world
  20. EchoService proxyService = (EchoService) proxyFactory.getProxy();
  21. System.out.println(proxyService.echo("hello world"));
  22. // I am service
  23. SayName proxySayName = (SayName) proxyFactory.getProxy();
  24. System.out.println(proxySayName.getName());
  25. }

可能对这个例子中的AdvisorProxyFactory比较陌生,不知道起了啥作用,后面会详细分析这2个类的作用
「实现Advice接口的方式,应该是Spring AOP一代中最常见的使用方式了」
「对HashMapput方法增加执行前的横切逻辑」, 打印放入HashMap的key和value的值

  1. public static void main(String[] args) {
  2. JdkRegexpMethodPointcut pointcut = new JdkRegexpMethodPointcut();
  3. pointcut.setPattern(".*put.*");
  4. DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
  5. advisor.setPointcut(pointcut);
  6. advisor.setAdvice(new MethodBeforeAdvice() {
  7. @Override
  8. public void before(Method method, Object[] args, Object target) throws Throwable {
  9. System.out.printf("当前存放的key为 %s,值为 %s", args[0], args[1]);
  10. }
  11. });
  12. ProxyFactory proxyFactory = new ProxyFactory(new HashMap());
  13. proxyFactory.addAdvisor(advisor);
  14. Map<String, String> proxyMap = (Map<String, String>) proxyFactory.getProxy();
  15. // 当前存放的key为 a,值为 a
  16. proxyMap.put("a", "a");
  17. }

Advisor

前面说过在AOP设计理念中,用Aspect来声明切面,每个Aspect可以包含多个PointcutAdvice
「在Spring AOP一代中,Aspect对应的实现为Advisor」。即AdvisorPointcutAdvice的容器,但是一个Advisor只能包含一个PointcutAdvice2021-09-28-08-53-53-454155.png
因为Advice的实现方式有两类,因此对应的Advisor也可以分为两类

织入

「在Spring中将Advice织入到Jointpoint的过程是通过动态代理来实现的」。当然织入的方式有很多种,不仅仅只有动态代理这一种实现
2021-09-28-08-53-53-758154.png
Spring用了jdk动态代理和cglib来实现动态代理。生成代理对象用了工厂模式。从api中就可以很清晰的看出来
2021-09-28-08-53-53-987153.png

「jdk动态代理」

  1. public class CostInvocationHandler implements InvocationHandler {
  2. private Object target;
  3. public CostInvocationHandler(Object target) {
  4. this.target = target;
  5. }
  6. @Override
  7. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  8. long startTime = System.currentTimeMillis();
  9. Object result = method.invoke(target, args);
  10. long cost = System.currentTimeMillis() - startTime;
  11. System.out.println("cost " + cost);
  12. return result;
  13. }
  14. }
  15. public static void main(String[] args) {
  16. ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
  17. Object proxy = Proxy.newProxyInstance(classLoader,
  18. new Class[]{EchoService.class},
  19. new CostInvocationHandler(new DefaultEchoService()));
  20. EchoService echoService = (EchoService) proxy;
  21. // cost 0
  22. // hello world
  23. System.out.println(echoService.echo("hello world"));
  24. }

「cglib」

  1. public static void main(String[] args) {
  2. Enhancer enhancer = new Enhancer();
  3. enhancer.setSuperclass(DefaultEchoService.class);
  4. enhancer.setInterfaces(new Class[] {EchoService.class});
  5. enhancer.setCallback(new MethodInterceptor() {
  6. @Override
  7. public Object intercept(Object source, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
  8. long startTime = System.currentTimeMillis();
  9. Object result = methodProxy.invokeSuper(source, args);
  10. long cost = System.currentTimeMillis() - startTime;
  11. System.out.println("cost " + cost);
  12. return result;
  13. }
  14. });
  15. EchoService echoService = (EchoService) enhancer.create();
  16. // cost 29
  17. // hello world
  18. System.out.println(echoService.echo("hello world"));
  19. }

Spring AOP的自动动态代理

上面一直通过API的形式来演示,当然也可以把这些对象放入Spring容器,让Spring来管理,并且对Spring容器中的Bean生成代理对象
上面的Demo可以改为如下形式,变化基本不大

「手动配置」

  1. public class ProxyConfig {
  2. // 创建代理对象
  3. @Bean
  4. public EchoService echoService() {
  5. return new DefaultEchoService();
  6. }
  7. // 创建advice
  8. @Bean
  9. public CostMethodInterceptor costInterceptor() {
  10. return new CostMethodInterceptor();
  11. }
  12. // 使用pointcut和advice创建advisor
  13. @Bean
  14. public Advisor advisor() {
  15. NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
  16. advisor.setMappedName("echo");
  17. advisor.setAdvice(costInterceptor());
  18. return advisor;
  19. }
  20. // 创建代理对象
  21. @Bean("echoProxy")
  22. public ProxyFactoryBean proxyFactoryBean(EchoService echoService) {
  23. ProxyFactoryBean proxyFactoryBean = new ProxyFactoryBean();
  24. proxyFactoryBean.setTarget(echoService);
  25. proxyFactoryBean.setInterceptorNames("advisor");
  26. return proxyFactoryBean;
  27. }
  28. }
  29. public static void main(String[] args) {
  30. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ProxyConfig.class);
  31. // 获取代理对象
  32. EchoService echoService = (EchoService) context.getBean("echoProxy");
  33. // cost 0
  34. // hello world
  35. System.out.println(echoService.echo("hello world"));
  36. }

「可以看到对每个生成的代理对象都要配置对应的ProxyFactoryBean,然后从容器中获取代理对象来使用」。当代理对象很少时还能应付,当代理对象很多时,那还不得累到吐血。有没有什么简单的办法呢?
Spring肯定也想到了这个问题,所以他提供了如下一个类DefaultAdvisorAutoProxyCreator来实现自动代理,将这个类放入Spring容器即可,如下所示

「自动配置」

  1. public class AutoProxyConfig {
  2. // 创建代理对象
  3. @Bean
  4. public EchoService echoService() {
  5. return new DefaultEchoService();
  6. }
  7. // 创建advice
  8. @Bean
  9. public CostMethodInterceptor costInterceptor() {
  10. return new CostMethodInterceptor();
  11. }
  12. // 使用pointcut和advice创建advisor
  13. @Bean
  14. public Advisor advisor() {
  15. NameMatchMethodPointcutAdvisor advisor = new NameMatchMethodPointcutAdvisor();
  16. advisor.setMappedName("echo");
  17. advisor.setAdvice(costInterceptor());
  18. return advisor;
  19. }
  20. @Bean
  21. public DefaultAdvisorAutoProxyCreator autoProxyCreator() {
  22. return new DefaultAdvisorAutoProxyCreator();
  23. }
  24. }
  25. public static void main(String[] args) {
  26. AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AutoProxyConfig.class);
  27. EchoService echoService = context.getBean(EchoService.class);
  28. // cost 0
  29. // hello world
  30. System.out.println(echoService.echo("hello world"));
  31. }

从容器中获取的对象直接就是被代理后的对象,非常方便。「Spring AOP提供了很多类来实现自动代理,但他们有一个共同的父类AbstractAutoProxyCreator,看来自动代理的秘密就在这个AbstractAutoProxyCreator类中」2021-09-28-08-53-54-228159.jpeg

Spring AOP自动动态代理的实现方式

如果让自己实现对象的自动代理,会怎么做呢?
当然是通过BeanPostProcessor来干预Bean的声明周期,聪明!Spring就是这么干的,来验证一下想法2021-09-28-08-53-54-507150.png
看这个类的继承关系,基本上就验证了。只要看看他重写了BeanPostProcessor的哪些方法即可?
AbstractAutoProxyCreator重写了如下2个重要的方法」postProcessBeforeInstantiation(Bean实例化前阶段执行) postProcessAfterInitialization(Bean初始化后阶段执行)
2021-09-28-08-53-54-870182.png

postProcessBeforeInstantiation(Bean实例化前阶段执行)」

2021-09-28-08-53-55-208167.png
当用户自定义了TargetSource的实现时,会从TargetSource中获取目标对象生成代理。但是一般情况下很少会自定义TargetSource的实现。所以这部分就不再分析了。直接看postProcessAfterInitialization

postProcessAfterInitialization(Bean初始化后阶段执行)」

2021-09-28-08-53-55-565154.png
如果没有经过代理的化就会进入wrapIfNecessary方法
2021-09-28-08-53-55-918195.png
思路很简单,就是根据Bean获取对应的Advisor,然后创建其代理对象,并返回。
2021-09-28-08-53-56-149161.png
「所以当面试官问Spring AOP和IOC是如何结合在一起的时候,是不是知道该如何回答了?」
在Bean生命周期的Bean初始化后阶段,如果这个Bean需要增加横切逻辑,则会在这个阶段生成对应的代理对象

Spring AOP二代(集成了AspectJ)

当Spring 2.0发布以后,Spring AOP增加了新的使用方式,Spring AOP集成了AspectJ。最常用的就是这个版本的Spring AOP
主要有如下变化

  1. 可以用POJO来定义Aspect和Adivce,并提供了一系列相应的注解,如@Aspect@Around等。而不用像1.x版本中实现相应的接口
  2. 支持aspectj中的pointcut的表达方式

2021-09-28-08-53-56-409186.png
演示一下2.0版本中aop的使用方式
定义切面

  1. @Aspect
  2. public class AspectDefine {
  3. @Pointcut("execution(* com.javashitang.proxy.EchoService.echo(..))")
  4. public void pointcutName() {}
  5. @Around("pointcutName()")
  6. public Object calCost(ProceedingJoinPoint joinPoint) throws Throwable {
  7. long startTime = System.currentTimeMillis();
  8. Object result = joinPoint.proceed();
  9. long cost = System.currentTimeMillis() - startTime;
  10. System.out.println("cost " + cost);
  11. return result;
  12. }
  13. @Before("pointcutName()")
  14. public void beforeMethod() {
  15. System.out.println("beforeMethod");
  16. }
  17. }

增加配置,注入实现类

  1. @EnableAspectJAutoProxy
  2. public class AspectJConfig {
  3. @Bean
  4. public EchoService echoService() {
  5. return new DefaultEchoService();
  6. }
  7. }
  8. public static void main(String[] args) {
  9. AnnotationConfigApplicationContext context =
  10. new AnnotationConfigApplicationContext(AspectJConfig.class, AspectDefine.class);
  11. EchoService echoService = context.getBean(EchoService.class);
  12. // beforeMethod
  13. // cost 0
  14. // hello world
  15. System.out.println(echoService.echo("hello world"));
  16. context.close();
  17. }

「虽然spring2.0之后spring aop集成了AspectJ,但实际上只是拿AspectJ的“皮大衣“用了一下,因为底层的实现和织入方式还是1.x原先的实现体系」

@EnableAspectJAutoProxy有啥用?

「当使用2.0版本的aop时,必须在配置类上加上@EnableAspectJAutoProxy注解,那么这个注解有啥作用呢?」

  1. @Target(ElementType.TYPE)
  2. @Retention(RetentionPolicy.RUNTIME)
  3. @Documented
  4. @Import(AspectJAutoProxyRegistrar.class)
  5. public @interface EnableAspectJAutoProxy {
  6. boolean proxyTargetClass() default false;
  7. boolean exposeProxy() default false;
  8. }

可以看到很重要的一句

  1. @Import(AspectJAutoProxyRegistrar.class)

通过@Import注入bean,「通过@Import注解注入Bean的方式有如下三种」

  1. 基于Configuration Class
  2. 基于ImportSelector接口
  3. 基于ImportBeanDefinitionRegistrar接口

2021-09-28-08-53-56-709152.png
这个代码主要做了2个事情

  1. 往容器中注入AnnotationAwareAspectJAutoProxyCreator
  2. @EnableAspectJAutoProxy注解中的proxyTargetClass或者exposeProxy属性为true的时候,将AnnotationAwareAspectJAutoProxyCreator中的proxyTargetClass或者exposeProxy属性改为true

proxyTargetClassexposeProxy保存在AnnotationAwareAspectJAutoProxyCreator类的父类ProxyConfig中,这个类存了一些配置,用来控制代理对象的生成过程」
proxyTargetClass:true使用CGLIB基于类创建代理;false使用java接口创建代理 exposeProxy:true将代理对象保存在AopContext中,否则不保存
第一个属性比较容易理解,那么第二个属性有啥作用呢?演示一下

  1. @Service
  2. public class SaveSevice {
  3. public void method1() {
  4. System.out.println("method1 executed");
  5. method2();
  6. }
  7. public void method2() {
  8. System.out.println("method2 executed");
  9. }
  10. }
  11. @Aspect
  12. public class AspectDefine {
  13. @Pointcut("execution(* com.javashitang.invalid.SaveSevice.method2(..))")
  14. public void pointcutName() {}
  15. @Around("pointcutName()")
  16. public Object calCost(ProceedingJoinPoint joinPoint) throws Throwable {
  17. System.out.println("开启事务");
  18. return joinPoint.proceed();
  19. }
  20. }
  21. @EnableAspectJAutoProxy
  22. public class InvalidDemo {
  23. public static void main(String[] args) {
  24. AnnotationConfigApplicationContext context =
  25. new AnnotationConfigApplicationContext(SaveSevice.class,
  26. AspectDefine.class, InvalidDemo.class);
  27. SaveSevice saveSevice = context.getBean(SaveSevice.class);
  28. saveSevice.method1();
  29. System.out.println("--");
  30. saveSevice.method2();
  31. }
  32. }

结果为

  1. method1 executed
  2. method2 executed
  3. --
  4. 开启事务
  5. method2 executed

「可以看到通过method1调用method2时,aop没有生效。直接调用method2时,aop才会生效。事务方法自调用失效就是因为这个原因,因为调用的不是代理对象的方法」
解决方法有很多种,例如重新从ApplicationContext中取一下代理对象,然后调用代理对象的方法。另一种就是通过AopContext获取代理对象,实现原理就是当方法调用时会将代理对象放到ThreadLocal

  1. @Service
  2. public class SaveSevice {
  3. public void method1() {
  4. System.out.println("method1 executed");
  5. ((SaveSevice) AopContext.currentProxy()).method2();
  6. }
  7. public void method2() {
  8. System.out.println("method2 executed");
  9. }
  10. }

exposeProxy属性改为true

  1. @EnableAspectJAutoProxy(exposeProxy = true)
  1. method1 executed
  2. 开启事务
  3. method2 executed
  4. --
  5. 开启事务
  6. method2 executed

可以看到aop成功生效。「当使用@Transactional注解,分布式事务框架时一定要注意子调用这个问题,不然很容易造成事务失效」
往容器中注入AnnotationAwareAspectJAutoProxyCreator,那么这个类有啥作用呢?2021-09-28-08-53-56-982151.png
看这继承关系是不是和上面分析的DefaultAdvisorAutoProxyCreator类很相似,这不就是为了开启自动代理吗?

切点表达式

「Spring AOP用AspectJExpressionPointcut桥接了Aspect的筛选能力」。其实Aspect有很多种类型的切点表达式,但是Spring AOP只支持如下10种,因为Aspect支持很多种类型的JoinPoint,但是Spring AOP只支持方法执行这一种JoinPoint,所以其余的表达式就没有必要了。
2021-09-28-08-53-57-482155.png
因为AspectJ提供的表达式在工作中经常被使用,结合Demo演示一下具体的用法

表达式类型 解释
execution 匹配方法表达式,首选方式
within 限定类型
this 代理对象是指定类型 ,所有方法都会被拦截
target 目标对象是指定类型,所有方法都会被拦截
args 匹配方法中的参数
@target 目标对象有指定的注解,所有方法都会被拦截
@args 方法参数所属类型上有指定注解
@within 调用对象上有指定的注解,所有方法都会被拦截
@annotation 有指定注解的方法

execution

匹配方法表达式,首选方式

  1. execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)
  2. throws-pattern?)

拦截Performance类的perform方法的切点表达式如
2021-09-28-08-53-57-783164.png
放几个官方的Demo

  1. // The execution of any public method:
  2. execution(public * *(..))
  3. // The execution of any method with a name that begins with set
  4. execution(* set*(..))
  5. // The execution of any method defined by the AccountService interface
  6. execution(* com.xyz.service.AccountService.*(..))
  7. // The execution of any method defined in the service package:
  8. execution(* com.xyz.service.*.*(..))

within」限定类型

  1. // 拦截service包中任意类的任意方法
  2. within(com.xyz.service.*)
  3. // 拦截service包及子包中任意类的任意方法
  4. within(com.xyz.service..*)

this

代理对象是指定类型,所有方法都会被拦截
举个例子说明一下

  1. @Configuration
  2. @EnableAspectJAutoProxy
  3. public class ThisDemo {
  4. public static void main(String[] args) {
  5. AnnotationConfigApplicationContext context =
  6. new AnnotationConfigApplicationContext(ThisDemo.class, AspectDefine.class);
  7. Name name = context.getBean(Name.class);
  8. name.getName();
  9. System.out.println(name instanceof Student);
  10. }
  11. @Aspect
  12. public class AspectDefine {
  13. @Before("this(com.javashitang.aspectjPointcut.thisDemo.ThisDemo.Student)")
  14. public void before() {
  15. System.out.println("before");
  16. }
  17. }
  18. @Bean
  19. public Student student() {
  20. return new Student();
  21. }
  22. public class Student implements Name {
  23. @Override
  24. public String getName() {
  25. return null;
  26. }
  27. }
  28. public interface Name {
  29. String getName();
  30. }
  31. }

输出为

  1. false

有接口时会使用jdk动态代理,因此代理对象为Proxy,不会拦截
当设置为jdk动态代理为,代理对象为Student,正常拦截
将注解改为如下形式 @EnableAspectJAutoProxy(proxyTargetClass = true)
输出为

  1. before
  2. true

「target」目标对象是指定类型,所有方法都会被拦截

  1. // 目标对象为AccountService类型的会被代理
  2. target(com.xyz.service.AccountService)

this 和 target 的不同点「this作用于代理对象,target作用于目标对象」

args」匹配方法中的参数

  1. // 匹配只有一个参数,且类型为com.ms.aop.args.demo1.UserModel
  2. @Pointcut("args(com.ms.aop.args.demo1.UserModel)")
  3. // 匹配多个参数
  4. args(type1,type2,typeN)
  5. // 匹配第一个参数类型为com.ms.aop.args.demo1.UserModel的所有方法, .. 表示任意个参数
  6. @Pointcut("args(com.ms.aop.args.demo1.UserModel,..)")

@target」目标对象有指定的注解,所有方法都会被拦截

  1. // 目标对象中包含com.ms.aop.jtarget.Annotation1注解,调用该目标对象的任意方法都会被拦截
  2. @target(com.ms.aop.jtarget.Annotation1)

@args」方法参数所属类型上有指定注解

  1. // 匹配1个参数,且第1个参数所属的类中有Anno1注解
  2. @args(com.ms.aop.jargs.demo1.Anno1)
  3. // 匹配多个参数,且多个参数所属的类型上都有指定的注解
  4. @args(com.ms.aop.jargs.demo1.Anno1,com.ms.aop.jargs.demo1.Anno2)
  5. // 匹配多个参数,且第一个参数所属的类中有Anno1注解
  6. @args(com.ms.aop.jargs.demo2.Anno1,…)

@within」调用对象上有指定的注解,所有方法都会被拦截

  1. // 声明有com.ms.aop.jwithin.Annotation1注解的类中的所有方法都会被拦截
  2. @within(com.ms.aop.jwithin.Annotation1)

@target@within 的不同点」@target关注的是被调用的对象,@within关注的是调用的对象
@annotation」有指定注解的方法

  1. // 被调用方法上有Annotation1注解
  2. @annotation(com.ms.aop.jannotation.demo2.Annotation1)

Adivce之间的顺序关系

一个方法被一个aspect类拦截时的执行顺序如下
@Around->@Before->方法执行->@Around->@After->@AfterReturning/@AfterThrowing
当方法正常结束时,执行@AfterReturning。方法异常结束时,执行@AfterThrowing。两者不会同时执行哈2021-09-28-08-53-58-040157.png
一个方法被多个aspect类拦截时的执行顺序如下
2021-09-28-08-53-58-400152.png
「多个aspect的执行顺序可以通过@Order注解或者实现Oreder接口来控制」
Adivce的顺序一定要梳理清楚,不然有时候产生的很多魔幻行为都不知道怎么发生的」