简介
说明
本文介绍Spring中的AOP的原理。
版本
本文的版本：springboot：2.3.0.RELEASE；Spring：5.2.6.RELEASE。
Spring AOP本质是用的代理模式，其基于BeanPostProcessor实现，从而能够与IOC结合起来。
AOP的核心类的分类
advisorCreator，继承 spring ioc的扩展接口 BeanPostProcessor，主要用来扫描获取 advisor。
advisor：通知者，封装了spring aop中的切点和通知。 就是我们常用的@Aspect 注解标记的类。
advice： 通知，也就是aop中增强的方法。
AnnotationAwareAspectJAutoProxyCreator
实现了Order接口，所以先于普通的BeanPostProcessor注册，并对普通BeanPostProcessor也能起作用。
实现了InstantiationAwareBeanPostProcessor接口，所以会在Bean被创建之前被调用。
Spring Aop主要是通过AbstractAutoProxyCreator实现的BeanPostProcessor、InstantiationAwareBeanPostProcessor以及SmartInstantiationAwareBeanPostProcessor接口里面的后置处理器方法，来介入到Spring IOC容器的Bean的实例化以及初始化的过程中对Bean进行AOP的处理的。所以AbstractAutoProxyCreator类实现的容器级别的后置处理器方法是介入分析的点。
总览
AbstractAutoProxyCreator：Spring 为Spring AOP 模块暴露的可扩展抽象类，也是 AOP 中最核心的抽象类。
BeanNameAutoProxyCreator：根据指定名称创建代理对象（阿里连接池框架druid也基于此类做了扩展）。通过设置 advisor，可以对指定的 beanName 进行代理。支持模糊匹配。
AbstractAdvisorAutoProxyCreator：功能比较强大，默认扫描所有Advisor的实现类。相对于根据Bean名称匹配，该类更加灵活。动态的匹配每一个类，判断是否可以被代理，并寻找合适的增强类，以及生成代理类。
DefaultAdvisorAutoProxyCreator：AbstractAdvisorAutoProxyCreator的默认实现类。可以单独使用，在框架中使用AOP，尽量不要手动创建此对象。
AspectJAwareAdvisorAutoProxyCreator：Aspectj的实现方式，也是Spring Aop中最常用的实现方式，如果用注解方式，则用其子类AnnotationAwareAspectJAutoProxyCreator。
AnnotationAwareAspectJAutoProxyCreator：目前最常用的AOP使用方式。spring aop 开启注解方式之后，该类会扫描所有@Aspect()注释的类，生成对应的advisor。目前SpringBoot框架中默认支持的方式，自动配置。本文我们就分析此类。
简要流程
开启AOP功能
AopAutoConfiguration实现Aop的自动装配，配置好依赖就能直接使用。此时有@EnableAspectJAutoProxy,开启AspectJ的代理功能。
AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar，实现registerBeanDefinitions方法
registerBeanDefinitions方法：向容器中注册bean：org.springframework.aop.config.internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
创建代理类对象
AnnotationAwareAspectJAutoProxyCreator实现生命周期监听，后置处理AspectJ切入的类，查找缓存所有的Advisors，创建代理类对象。
- 解析和加载横切逻辑：AbstractAutoProxyCreator#postProcessBeforeInstantiation方法，在Bean实例化之前被调用。
- 创建代理类：AopProxy创建代理类，代理类里面会插入Advisor注解的方法中的代码,并返回代理对象
- 将横切逻辑织入目标Bean：AbstractAutoProxyCreator#postProcessAfterInitialization方法，在Bean实例化之后被调用。
DefaultAopProxyFactory提供代理策略，接口走JDK代理，类走Cglib代理。SpringBoot默认走Cglib代理。
执行目标方法
代理对象中的proxyFactory包含增强器和目标对象。
目标方法执行=> CglibAopProxy.intercept()=> 遍历所有的增强器，将其转为Interceptor，利用MethodInterceptor机制生成拦截器链，
如果有拦截器链，把需要执行的目标对象，目标方法，拦截器链等信息传入创建一个 CglibMethodInvocation 对象，
调用mi.proceed()，链式获取每一个拦截器，拦截器执行invoke方法，每一个拦截器等待下一个拦截器执行完成返回以后再来执行；
拦截器链的机制，保证通知方法与目标方法的执行顺序
1.启用AOP
简介
spring-boot-starter-aop如何做到自动配置的？
要使用AOP，首先要引入包。如果引入的是spring-aop包，则需要使用@EnableAspectJAutoProxy开启aop功能；如果引入的是spring-boot-starter-aop，则AOP就直接可以用了，无需加注解之类的开启它。
实际上，spring-boot-starter-aop是自动用了@EnableAspectJAutoProxy，所以我们还是从@EnableAspectJAutoProxy开始。
@EnableAspectJAutoProxy
EnableAspectJAutoProxy注解类上用了： @Import({AspectJAutoProxyRegistrar.class})
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy {
boolean proxyTargetClass() default false;
boolean exposeProxy() default false;
}- proxyTargetClass 指定是否使用CGLIB的方式创建实现接口的目标对象的代理。缺省值为true，使用CGLIB方式创建对象的代理。
- exposeProxy 标记代理对象是否应该被aop框架通过AopContext以ThreadLocal的形式暴露出去。当一个代理对象需要调用它自己的另外一个代理方法时，这个属性将非常有用。默认是是false，以避免不必要的拦截。
AspectJAutoProxyRegistrar
总结
AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar，实现registerBeanDefinitions方法
向容器中注册bean：org.springframework.aop.config.internalAutoProxyCreator=AnnotationAwareAspectJAutoProxyCreator
注册AnnotationAwareAspectJAutoProxyCreator
追踪：AspectJAutoProxyRegistrar#registerBeanDefinitions //从名字就可以看出来，它是注册BeanDefinition用的。
registerBeanDefinitions //AspectJAutoProxyRegistrar
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); //AspectJAutoProxyRegistrar.java
registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry, (Object)null); //AopConfigUtils.class
registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source); //AopConfigUtils.class
AopConfigUtils#registerOrEscalateApcAsRequired
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry, @Nullable Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
if (registry.containsBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator")) {
BeanDefinition apcDefinition = registry.getBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator");
if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
int requiredPriority = findPriorityForClass(cls);
if (currentPriority < requiredPriority) {
apcDefinition.setBeanClassName(cls.getName());
}
}
return null;
} else {
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", -2147483648);
beanDefinition.setRole(2);
registry.registerBeanDefinition("org.springframework.aop.config.internalAutoProxyCreator", beanDefinition);
return beanDefinition;
}
}开始的时候AutoProxyCreator类不存在,RootBeanDefinition初始化AnnotationAwareAspectJAutoProxyCreator类，注册类到IOC容器。
创建AnnotationAwareAspectJAutoProxyCreator
相关网址
refresh()、BeanPostProcessor
总结
AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口与Ordered接口（值为32位int的最大值），它在registerBeanPostProcessors()中处理，最终被实例化、设置属性、初始化。
分析
在上边“重要的类”可以得出：AnnotationAwareAspectJAutoProxyCreator实现了BeanPostProcessor接口与Ordered接口（值为32位int的最大值），那它会在registerBeanPostProcessors()中处理：
AbstractApplicationContext#refresh()
registerBeanPostProcessors(beanFactory) //AbstractApplicationContext
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
BeanPostProcessor pp = (BeanPostProcessor)beanFactory.getBean(ppName, BeanPostProcessor.class);
getBean(String name, Class<T> requiredType) //AbstractBeanFactory
doGetBean(name, requiredType, null, false) //AbstractBeanFactory
createBean(beanName, mbd, args); //AbstractAutowireCapableBeanFactory
doCreateBean(beanName, mbdToUse, args); //AbstractAutowireCapableBeanFactory
AbstractAutowireCapableBeanFactory#doCreateBean(beanName, mbdToUse, args); 主要做了如下几件事：
创建bean ：createBeanInstance(beanName, mbd, args)
给bean中的属性赋值：populateBean(beanName, mbd, instanceWrapper)
初始化bean：initializeBean(beanName, exposedObject, mbd)
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
// 实例化bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
// 允许post-processors来修改合并的bean定义
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
} catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
// 初始化bean
Object exposedObject = bean;
try {
populateBean(beanName, mbd, instanceWrapper);
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
} else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
} catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}2.生成代理对象
3.执行目标方法
其他网址
Spring5AOP——AbstractAutoProxyCreator横切逻辑织入目标Bean中 | 码农家园
最简 Spring AOP 源码分析 - 云+社区 - 腾讯云
AOP系列（三）SpringBoot中 AOP实现原理
