SpringBoot-AOP源码梳理

1. @EnableAspectJAutoProxy 注解做了什么？

在springboot中，@EnableAspectJAutoProxy 注解开启AOP , 在这个注解里面，通过@Import 给容器中导入AspectJAutoProxyRegistrar 对象.

@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
    
    ...}

AspectJAutoProxyRegistrar 实现了ImportBeanDefinitionRegistrar接口，通过这个接口可以向容器中增加Bean的定义。

class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
    
    
	@Override
	public void registerBeanDefinitions(
			AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
    
    
	
		AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);

		AnnotationAttributes enableAspectJAutoProxy =
				AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
		if (enableAspectJAutoProxy != null) {
    
    
			if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
    
    
				AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
			}
			if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
    
    
				AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
			}
		}
	}
}

AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry); 这一句往里走，最后创建了一个AnnotationAwareAspectJAutoProxyCreator 对象的Bean定义，加到注册器中，key为org.springframework.aop.config.internalAutoProxyCreator.

public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry, 	@Nullable Object source) {
    
    
  return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}

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")) {
    
    
    ...
  } 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;
  }
}

2. 什么时候注册1中的AnnotationAwareAspectJAutoProxyCreator对象的定义？

在AspectJAutoProxyRegistrar.registerBeanDefinitions() 方法打断点调试，查看调用链路
在这里插入图片描述
大致流程是

spring容器启动阶段的 AbstractApplicationContext.refresh()

invokeBeanFactoryPostProcessors(beanFactory) // 调用工厂的后置处理器, 增加即将加入容器中Bean的定义

this**.**reader.loadBeanDefinitions(configClasses); // 加载所有配置类, 有@Configration注解的类

loadBeanDefinitionsFromRegistrars(configClass.getImportBeanDefinitionRegistrars()); // 把配置类中import引入的注册器类加载进来

AspectJAutoProxyRegistrar.registerBeanDefinitions() // 进入到aop的注册bean定义的方法。

3. 什么时候创建1中的AnnotationAwareAspectJAutoProxyCreator对象？

在这里插入图片描述
通过AnnotationAwareAspectJAutoProxyCreator 类的继承关系，可以看到它实现了BeanPostProcessor. 在spring容器的启动过程中 AbstractApplicationContext.refresh() 有专门负责加载所有实现BeanPostProcessor接口的方法

registerBeanPostProcessors(beanFactory); // 加载所有实现BeanPostProcessor接口的方法
它里面的内容包括如下：

// 获取所有实现了BeanPostProcessor接口的bean的名称
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); 
...
  // 逐个创建Bean
  for (String ppName : postProcessorNames) {
    
    
    if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
    
    
      // BeanFatory.getBean方法获取到的就是已经创建好的Bean了
      BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
      priorityOrderedPostProcessors.add(pp);
      if (pp instanceof MergedBeanDefinitionPostProcessor) {
    
    
        internalPostProcessors.add(pp);
      }
    }
    else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
    
    
      orderedPostProcessorNames.add(ppName);
    }
    else {
    
    
      nonOrderedPostProcessorNames.add(ppName);
    }
  }
...
  // 把创建好的bean加到容器中
  registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

4. 加到容器中的AnnotationAwareAspectJAutoProxyCreator 怎么生效呢？

AOP的本质是代理，那么就会有创建Bean的时候，不会使用原本类型指定的对象，而是创建一个增强的对象。那么我们就从创建bean的过程中寻找。我们知道spring 容器启动的过程中，会先加载 BeanPostProcessor 等类型的bean，像我们代码中自己定义的切面等其他业务相关bean，都是之后加载的，从spring容器启动过程的refresh()方法的代码顺序也可以看出来，这一点在这里也不重要，我只是提一下。

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
...
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

既然创建的对象是代理对象，那么直接在AbstractAutowireCapableBeanFactory 类的createBean 方法里面打断点，并且给断电加上Condition, 只在创建我们定义的需要被切的对象的时候断住，比如我写了一个Say这个类，那么我加的条件就是beanName.equals(“say”). 一步步的调试，发现走到applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName) -> wrapIfNecessary(bean, beanName, cacheKey) 方法中的时候，有这么一段代码

// Create proxy if we have advice. 
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
if (specificInterceptors != DO_NOT_PROXY) {
    
    
  this.advisedBeans.put(cacheKey, Boolean.TRUE);
  Object proxy = createProxy(
    bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
  this.proxyTypes.put(cacheKey, proxy.getClass());
  return proxy;
}

这个方法是在 AbstractAutoProxyCreator 的注释也说的很清楚了，如果有通知就创建代理。通过切点表达式和类的关系，就能找到我们定义的通知方法，被封装为Advisor对象。代理创建完成后，可以看到通知方法作为拦截器链添加到了道理对象中。其中的拦截器链已经根据Before, After等注解信息排好了顺序，排序是使用 ReflectiveAspectJAdvisorFactory 类的METHOD_COMPARATOR 方法实现了，里面已经定义好了各个注解的顺序。
在这里插入图片描述
至此，需要增强的对象创建完成，调用的时候，进入CglibAopProxy 的 intercept 方法，因为我这里是对类进行的增强，所以spring自动的选则了使用cglib 代理。

先获取所有的增强方法组成的拦截器链

List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);

把代理对象（Cglib增强后的对象），目标对象（Say），方法，参数，连接器链等信息封装为一个CglibMethodInvocation 对象，并执行该对象的.proceed() 方法。

public Object proceed() throws Throwable {
    
    
  //	We start with an index of -1 and increment early.
  if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
    
    
    return invokeJoinpoint();
  }

  Object interceptorOrInterceptionAdvice =
    this.interceptorsAndDynamicMethodMatchers.get(++this.currentInterceptorIndex);
  if (interceptorOrInterceptionAdvice instanceof InterceptorAndDynamicMethodMatcher) {
    
    
    // Evaluate dynamic method matcher here: static part will already have
    // been evaluated and found to match.
    InterceptorAndDynamicMethodMatcher dm =
      (InterceptorAndDynamicMethodMatcher) interceptorOrInterceptionAdvice;
    Class<?> targetClass = (this.targetClass != null ? this.targetClass : this.method.getDeclaringClass());
    if (dm.methodMatcher.matches(this.method, targetClass, this.arguments)) {
    
    
      return dm.interceptor.invoke(this);
    }
    else {
    
    
      // Dynamic matching failed.
      // Skip this interceptor and invoke the next in the chain.
      return proceed();
    }
  }
  else {
    
    
    // It's an interceptor, so we just invoke it: The pointcut will have
    // been evaluated statically before this object was constructed.
    return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);
  }
}

调试可以看到链式的调用，逐个拦截器不断的调用 mi.proceed(); 逐渐深入到最后一个拦截器MethodBeforeAdviceInterceptor 的时候，可以看到执行了前置通知的方法

@Override
public Object invoke(MethodInvocation mi) throws Throwable {
    
    
   this.advice.before(mi.getMethod(), mi.getArguments(), mi.getThis());
   return mi.proceed();
}

前置通知执行完以后，mo.proceed()方法中满足了执行方法本体的条件，被增强的方法本体执行。

//  We start with an index of -1 and increment early.
if (this.currentInterceptorIndex == this.interceptorsAndDynamicMethodMatchers.size() - 1) {
    
    
   return invokeJoinpoint();
}

执行完后线程栈退回到上一层的拦截器，是AspectJAfterAdvice, 因为是在finally 块中的，所以必然执行。

public Object invoke(MethodInvocation mi) throws Throwable {
    
    
   try {
    
    
      return mi.proceed();
   }
   finally {
    
    
      invokeAdviceMethod(getJoinPointMatch(), null, null);
   }
}

结束后线程退回到AfterReturningAdviceInterceptor 拦截器，到这里为止所有的拦截器中都没有捕获异常，所以如果前面有异常的时候，后置拦截器的内容就不执行了。

public Object invoke(MethodInvocation mi) throws Throwable {
    
    
   Object retVal = mi.proceed();
   this.advice.afterReturning(retVal, mi.getMethod(), mi.getArguments(), mi.getThis());
   return retVal;
}

之后回到AspectJAfterThrowingAdvice 拦截器，这里是在catch 块中，没有异常就不执行。

public Object invoke(MethodInvocation mi) throws Throwable {
    
    
   try {
    
    
      return mi.proceed();
   }
   catch (Throwable ex) {
    
    
      if (shouldInvokeOnThrowing(ex)) {
    
    
         invokeAdviceMethod(getJoinPointMatch(), null, ex);
      }
      throw ex;
   }
}

5. 看的时候一定要写个demo，一遍调试一遍看，光读文字看不懂的。我的demo如下

/**
 * Author:   susq
 * Date:     2019-08-04 12:06
 */
public class Say {
    
    

    public void sayHello() {
    
    
        log.info("Say -- sayHello ： hello !");
    }
}

@Aspect
public class SayAspect {
    
    

    @Pointcut("execution(public * com.su.demo.aop.Say.sayHello(..))")
    public void sayPointCut() {
    
    }

    @After("sayPointCut()")
    public void afterSay() {
    
    
        System.out.println("=====afterSay=====");
    }

    @AfterThrowing("sayPointCut()")
    public void afterThrow() {
    
    
        System.out.println("=====afterThrow=====");
    }

    @Before("sayPointCut()")
    public void beforeSay() {
    
    
        System.out.println("=====beforeSay=====");
    }

    @AfterReturning("sayPointCut()")
    public void afterReturn() {
    
    
        System.out.println("=====afterReturn=====");
    }

}

@EnableAspectJAutoProxy
@Configuration
public class SayConfig {
    
    

    @Bean
    public Say say() {
    
    
        return new Say();
    }

    @Bean
    public SayAspect sayAspect() {
    
    
        return new SayAspect();
    }
}

public class AppTest {
    
    

    public static void main(String[] args) {
    
    
        AnnotationConfigApplicationContext configApplicationContext = new AnnotationConfigApplicationContext(SayConfig.class);
        Say say = configApplicationContext.getBean(Say.class);
        say.sayHello();
    }
}