AOP流程及原理

目录

一、AOP结构介绍

• @Pointcut

• 通知

• 原理

• 连接点

• 拦截器

二、Bean介入点

• EnableAspectJAutoProxy

• AspectJAutoProxyRegistrar

• AnnotationAwareAspectJAutoProxyCreator

• AbstractAutoProxyCreator

  • 实例前执行

  • 初始化后执行

  • 循环依赖会调用

• 总结

三、处理切面

• 获取所有切面其下通知方法

  • 获取切面

  • 获取切面下的通知方法

  • 通知方法的封装

• 通知方法与Bean匹配

• 总结

四、创建代理对象

五、代理执行方法

六、总结

一、AOP结构介绍

我们先看个简单的AOP例子：

结果：

我们来细数一下有哪些要素 ？

• @Aspect：切面类，告诉Spring我这个类是个切面，里面有特殊处理方法

• @Pointcut：切点，告诉Spring我要针对那些业务方法进行增强

• @Before、@Around、@AfterReturning、@After、@AfterThrowing：通知，告诉Spring针对后要做什么处理

要素就这些吧，@Aspect就不说了就是个标识，主要是切点和处理方法吧

@Pointcut

这个注解值的格式是：表达标签 (表达式格式)，用白话说就是用了一种表达式来代表我要针对什么来进行特殊处理

• execution：用于匹配方法执行的连接点

• within：用于匹配指定类型内的方法执行

• this：用于匹配当前AOP代理对象类型的执行方法；注意是AOP代理对象的类型匹配，这样就可能包括引入接口也类型匹配

• target：用于匹配当前目标对象类型的执行方法；注意是目标对象的类型匹配，这样就不包括引入接口也类型匹配

• args：用于匹配当前执行的方法传入的参数为指定类型的执行方法

• @within：用于匹配所以持有指定注解类型内的方法

• @target：用于匹配当前目标对象类型的执行方法，其中目标对象持有指定的注解

• @args：用于匹配当前执行的方法传入的参数持有指定注解的执行

• @annotation：用于匹配当前执行方法持有指定注解的方法

• bean：Spring AOP扩展的，AspectJ没有对于指示符，用于匹配特定名称的Bean对象的执行方法

通知

我们上述看到了有五种通知注解，分别表示如下，表示有五种特殊处理方式：

• @Before： 前置通知，在目标方法执行前执行

• @Around： 环绕通知，可以在目标方法前、后进行处理，还可以修改目标方法返回值

• @AfterReturning： 后置通知，在目标方法后执行（发生异常便不会执行）

• @After： 最终通知，不管异常还是正常一定都会执行

• @AfterThrowing：异常通知，在目标方法发生异常后执行

原理

一提起AOP可能第一反应就是动态代理，但是真的就只有动态代理这么简单吗？我们看一个动态代理的例子（以JDK动态代理为例）：

这乍一看好像就是这个道理啊，好像全满足了呀，真满足吗？环绕通知要怎么做？通知有多个，有多个处理方法怎么做？总不可能一直往这里面塞吧，还有环绕通知需要在invoke方法外面再套一层吧，有多个的话无限套娃？

那要怎么做？注意看这是不是都是串行执行的，串行执行的拦截处理方法是什么？拦截器链！！

流程如下图所示：

注意看所有通知都是多个：

• 无环绕，无异常的情况下：所有前置通知 --> 目标方法 --> 所有后置通知 --> 所有最终通知 --> 返回

• 无环绕，有异常的情况下：所有前置通知 --> 目标方法 --> 所有异常通知 --> 所有最终通知 --> 返回（这里注意前置、目标、后置任何一个异常都会到异常通知）

• 有环绕的情况下：先执行环绕前置 --> 再执行链条 --> 然后环绕后置（如下图）

多个环绕会怎样？注意环绕通知本身就是链条的里面的，只不过在最前面执行，多个环绕就会像这样：

好了重点来了，我们知道原理了动态代理+拦截器链，我们需要知道Spring怎么帮我们组装的？

• 动态代理很简单就两种方式：JDK 和 Cglib

• 拦截器链：是不是需要把上述切面里面的方法全提取出来封装好，然后最后组装成链条

• 连接点：拦截器通过什么连接到一起？需要相同的连接点吧，所谓连接点是指那些被拦截到的方法

连接点

在Spring里面连接点是Joinpoint这个接口：

如上图可见就两个实现类：

• ReflectiveMethodInvocation：提供给JDK动态代理方式使用

• CglibMethodInvocation：提供给Cglib动态代理方式使用

二、拦截器

既然知道是拦截器链了，那每个通知方法应该都有对应的拦截器，我们去看看（只看invoke方法哈）：

1、前置通知拦截器 MethodBeforeAdviceInterceptor：

2、后置通知拦截器AfterReturningAdviceInterceptor：

3、异常通知拦截器ThrowsAdviceInterceptor ：

4、最终通知AspectJAfterAdvice ：

5、环绕通知AspectJAroundAdvice ：

以上就是关于通知链条里面所有最后会执行的方法，可以看到共同点就是invoke方法的传参MethodInvocation ，这不就是我们之前说的连接点嘛，

当然还有很多内置的其他拦截器，但这都跟我们AOP拦截器没关系

以上基础概念相信大家都懂了，接下来我们看看Spring是怎么代理一个Bean的，是怎么为这个Bean组装这些拦截器的

三、Bean介入点

这AOP代理到底是在Bean生成流程中哪个地方介入进来为我们生成代理对象的 ？

从AOP配置加载点一看便知，开启AOP的配置注解是 @EnableAspectJAutoProxy（现在已经默认开启了，不需要加注解也行，配置类是AopAutoConfiguration）

1、EnableAspectJAutoProxy

@EnableAspectJAutoProxy注解内部导入了一个类AspectJAutoProxyRegistrar

2、AspectJAutoProxyRegistrar

这个类实现了ImportBeanDefinitionRegistrar接口，这个接口之前说过了，可以注册bean的定义信息BeanDefination，所以我们要看看注册的这个是什么？干了什么？

沿着那个方法一路往下，发现注册了AnnotationAwareAspectJAutoProxyCreator

3、AnnotationAwareAspectJAutoProxyCreator

这个类可谓是最重要的类了，从下方的类图上看，它实现了很多接口，还有我们非常熟悉的后置处理器，在这里面主要实现了4个方法:

• setBeanFactory：实例化后，初始化前调用

• getEarlyBeanReference：和三级缓存有关，存在循环依赖里面会调用

• postProcessBeforeInstantiation：实例化前执行

• postProcessAfterInitialization：初始化后执行

别看有4个方法，其实下面三个方法内部都会调用一样的方法，只是需要注意在Bean生成流程中的介入点

4、AbstractAutoProxyCreator

在目标对象创建之前，执行 AbstractAutowireCapableBeanFactory#Object bean = resolveBeforeInstantiation(beanName, mbdToUse) --> applyBeanPostProcessorsBeforeInstantiation(targetType, beanName) ---> Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName)，主要是判断代理目标对象是否已经存在，存在了且需要代理就走getAdvicesAndAdvisorsForBean方法，然后调用createProxy()方法创建代理对象

5、目标对象创建完且初始化后执行

目标对象创建完且初始化后执行，AbstractAutowireCapableBeanFactory#initializeBean --> wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)

--> result = beanProcessor.postProcessAfterInitialization(result, beanName)，会调用wrapIfNecessary()方法

wrapIfNecessary()方法也会调用 getAdvicesAndAdvisorsForBean方法来获取对应的通知处理，如果没获取到通知处理方法说明不需要代理，获取到了就要创建代理对象了createProxy()

注意： 这里的通知处理就是切面里面的通知方法，getAdvicesAndAdvisorsForBean就是获取所有的切面类里面的切点与Bean来匹配，匹配上了说明这个Bean要被代理，同时会封装匹配的切点对应的所有通知返回

6、循环依赖会调用

getEarlyBeanReference，三级缓存，存在循环依赖则会调用,这里put进去代表已经生成代理了，所以后续初始化后调用的时候会get判断一次，也会调用wrapIfNecessary()方法

7、总结

所以会在Bean实例化前、循环依赖、初始化后介入处理，当然只会处理一次，最终都会调用getAdvicesAndAdvisorsForBean方法来对Bean进行切点匹配，匹配上了就调用createProxy方法生成代理对象然后返回

四、处理切面

AbstractAdvisorAutoProxyCreator.getAdvicesAndAdvisorsForBean()作用：

会先获取所有的切面其下的通知方法(@Before、@Around、@AfterReturning、@After等)，然后根据切点表达式去和这个Bean对象匹配， 将匹配成功的通知方法返回，

这就说明该Bean需要被代理，匹配成功的通知方法排序后就是需要执行的方法调用链

1、获取所有切面其下通知方法

使用了模板方法模式，获取切面，AnnotationAwareAspectJAutoProxyCreator.findCandidateAdvisors 有个父类的方法是获取一些实现了Advisor接口的Bean，我们重点关注被@Aspect注解标识的Bean的处理

BeanFactoryAspectJAdvisorsBuilder.buildAspectJAdvisors

会遍历所有的Bean找到其中被注解@Aspect标识的，然后去处理其下的切点和通知方法

2、获取@Aspect切面下的通知方法

ReflectiveAspectJAdvisorFactory.getAdvisors

遍历切面下的所有方法，去找方法上是否有相应的注解，如果有则需要封装处理

ReflectiveAspectJAdvisorFactory.getAdvisor

遍历我需要的注解，在方法上找注解是否存在，存在的就需要封装处理

3、通知方法的封装

InstantiationModelAwarePointcutAdvisorImpl

这个在构造里面就会对通知方法进行处理封装

  public Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut,
  			MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName) {

  		Class<?> candidateAspectClass = aspectInstanceFactory.getAspectMetadata().getAspectClass();
  		validate(candidateAspectClass);

  		AspectJAnnotation<?> aspectJAnnotation =
  				AbstractAspectJAdvisorFactory.findAspectJAnnotationOnMethod(candidateAdviceMethod);
  		if (aspectJAnnotation == null) {
  			return null;
  		}

  		// If we get here, we know we have an AspectJ method.
  		// Check that it's an AspectJ-annotated class
  		if (!isAspect(candidateAspectClass)) {
  			throw new AopConfigException("Advice must be declared inside an aspect type: " +
  					"Offending method '" + candidateAdviceMethod + "' in class [" +
  					candidateAspectClass.getName() + "]");
  		}

  		if (logger.isDebugEnabled()) {
  			logger.debug("Found AspectJ method: " + candidateAdviceMethod);
  		}

  		AbstractAspectJAdvice springAdvice;

  		switch (aspectJAnnotation.getAnnotationType()) {
  			case AtBefore:
  				springAdvice = new AspectJMethodBeforeAdvice(
  						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  				break;
  			case AtAfter:
  				springAdvice = new AspectJAfterAdvice(
  						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  				break;
  			case AtAfterReturning:
  				springAdvice = new AspectJAfterReturningAdvice(
  						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  				AfterReturning afterReturningAnnotation = (AfterReturning) aspectJAnnotation.getAnnotation();
  				if (StringUtils.hasText(afterReturningAnnotation.returning())) {
  					springAdvice.setReturningName(afterReturningAnnotation.returning());
  				}
  				break;
  			case AtAfterThrowing:
  				springAdvice = new AspectJAfterThrowingAdvice(
  						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  				AfterThrowing afterThrowingAnnotation = (AfterThrowing) aspectJAnnotation.getAnnotation();
  				if (StringUtils.hasText(afterThrowingAnnotation.throwing())) {
  					springAdvice.setThrowingName(afterThrowingAnnotation.throwing());
  				}
  				break;
  			case AtAround:
  				springAdvice = new AspectJAroundAdvice(
  						candidateAdviceMethod, expressionPointcut, aspectInstanceFactory);
  				break;
  			case AtPointcut:
  				if (logger.isDebugEnabled()) {
  					logger.debug("Processing pointcut '" + candidateAdviceMethod.getName() + "'");
  				}
  				return null;
  			default:
  				throw new UnsupportedOperationException(
  						"Unsupported advice type on method: " + candidateAdviceMethod);
  		}

  		// Now to configure the advice...
  		springAdvice.setAspectName(aspectName);
  		springAdvice.setDeclarationOrder(declarationOrder);
  		String[] argNames = this.parameterNameDiscoverer.getParameterNames(candidateAdviceMethod);
  		if (argNames != null) {
  			springAdvice.setArgumentNamesFromStringArray(argNames);
  		}
  		springAdvice.calculateArgumentBindings();
  		return springAdvice;
  }

4、通知方法与 Bean匹配

AbstractAdvisorAutoProxyCreator.findAdvisorsThatCanApply

5、总结

所以这一步会找到所有的切面，遍历其下的所有切点和通知方法，然后根据切点中的表达式去与Bean对象匹配，获取所有匹配成功的通知方法，将这些通知方法排序后就是最后的方法执行链，

同时也说明该Bean需要被代理，所以需要创建代理对象

五、创建代理对象

AbstractAutoProxyCreator.createProxy

这里实际就是在创建代理对象前填充一下必要信息，然后创建代理对象，默认是采用JDK动态代理，如果被代理的目标对象不是接口，则会采用Cglib动态代理

• CglibAopProxy：Cglib动态代理逻辑类

• JdkDynamicAopProxy：Jdk动态代理逻辑类（我们以这个为例）

JdkDynamicAopProxy.getProxy

这一步很简单就是直接创建代理对象，处理类是this，说明该类本身就是处理类

六、代理执行方法

我们以JDK动态代理为例，最终代理对象在执行方法的时候就会调用该方法：

JdkDynamicAopProxy.invoke

六、总结

1、AOP代理对象的生成机会是在Bean实例化前、初始化后这两个位置判断生成的（以初始化后为主，其他阶段属于特殊阶段）

2、通过获取所有的切面下的通知方法以切点表达式来与Bean匹配，来判断该Bean是否需要被代理，同时准备好了与该Bean相关的所有增强方法

3、AOP默认采用JDK动态代理的方式，如果被代理目标对象不是接口，则会采用Cglib的代理方法

4、AOP的底层原理虽然是动态代理，但是我觉得最重要的还是执行的方法调用链非常巧妙

5、在逻辑实现上：每种通知在调用链上执行的方式及其执行顺序决定了其扮演的角色

6、每个通知最后执行类在前面已经给出，可直接查看学习

最后附上个执行结构图