spring之我见 - Spring AOP实现原理(下)

预备材料

这一篇需要先把我本地的demo应用代码放出来。然后上篇 spring之我见 - Spring AOP实现原理(上) 说到, 我们已经准备好了各种食材，这一篇真正开始看看 AOP 是怎么代理某个对象的.

@Aspect
@Component
public class TestAspectJ {

    @Pointcut("execution(* com.example.demo.service.TestService.test())")
    public void testPointcut() {
    }

    @Before("testPointcut()")
    public void before() {
        System.out.println("i am coming");
    }

    @After("testPointcut()")
    public void after() {
        System.out.println("i will opt out");
    }
}


public interface TestInterface {

    void test();
}


@Service
public class TestService implements TestInterface {

    @Override
    public void test() {
        System.out.println("i am here~");
    }
}

AnnotationAwareAspectJAutoProxyCreator

TestAspectJ 是一个 @Aspect 修饰的类, 类里面被代理的对象，增强的逻辑都一目了然. 在上篇文章也说过, AnnotationAwareAspectJAutoProxyCreator 会负责找出所有被 @Aspect 修饰的类, 分析出切面, 再跟现有 Spring IOC 的对象一一做匹配, 符合的就开始代理对象. 整个大流程就是这样, 我们还是先从 BeanPostProcessor 说起.

BeanPostProcessor

大名鼎鼎的 BeanPostProcessor 大家应该不会陌生, Spring IOC 处理创建对象的时候都会经过 BeanPostProcessor，Spring允许通过 BeanPostProcessor 机制修改新创建的对象.

AnnotationAwareAspectJAutoProxyCreator 实现了 BeanPostProcessor 和 InstantiationAwareBeanPostProcessor 接口, 里面重要的方法要列一下(按执行顺序排列).

• postProcessBeforeInstantiation - InstantiationAwareBeanPostProcessor 定义的方法. 触发时机在 对象实例化前调用,AnnotationAwareAspectJAutoProxyCreator 利用这个方法，在这里查找所有的 @Aspect 修饰的类.
  • postProcessAfterInitialization - 这里会多出一个小分支，就是如果 postProcessBeforeInstantiation 返回值不为空的话，说明这时候已经有一个 会直接执行 postProcessAfterInitialization，下面的流程就不会再走了. 一般不会走这个分支.
• postProcessAfterInstantiation - InstantiationAwareBeanPostProcessor 定义的方法，触发时机在目标对象实例化之后调用，这个时候对象已经被实例化，但属性还未被设置。如果该方法返回false，会忽略属性值的设置；如果返回true，会按照正常流程设置属性值
• postProcessBeforeInitialization - BeanPostProcessor 定义的方法, 触发时机在目标对象实例化之后，且属性已经设置，你可以随意修改这个对象。
• postProcessAfterInitialization - BeanPostProcessor 定义的方法, 触发时机和作用跟postProcessBeforeInitialization一模一样，只是在 postProcessBeforeInitialization 之后调用.

postProcessBeforeInstantiation

上面如果对这个不熟悉的可能会晕乎乎的，没办法，Spring 对类的取名就很长很长~ 而且 Instantiation 和 Initialization 两个单词容易混淆. 上面的总结也提到了, AnnotationAwareAspectJAutoProxyCreator 利用 postProcessBeforeInstantiation 方法，查找所有的 @Aspect 修饰的类.下面就是具体查找的代码.

当创建整个 Spring应用 第一个对象时， 会走 createBean 方法, 然后经过AnnotationAwareAspectJAutoProxyCreator 的 postProcessBeforeInstantiation 方法的时候，开始找所有的 @Aspect 修饰的对象，下面是调用链.

- org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#resolveBeforeInstantiation
	- org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessBeforeInstantiation
		- org.springframework.aop.aspectj.autoproxy.AspectJAwareAdvisorAutoProxyCreator#shouldSkip
			- org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator#findCandidateAdvisors


//当走到 `findCandidateAdvisors` 时，首先找到所有的 `beanNames` ，然后开始循环遍历. `TestAspectJ` 也是其中之一
String[] beanNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
							this.beanFactory, Object.class, true, false);


//判断这个类是不是有 `@Aspect` 修饰，这时候判断的 beanType 如果是 `TestAspectJ` ，那么就会返回 true
this.advisorFactory.isAspect(beanType)


//确定是 `@Aspect` 对象后，会加入缓存，因为 `findCandidateAdvisors` 后续还会用到，所以第一次已经找到后，后续就直接从缓存中获取，提升效率. 
aspectNames.add(beanName);
this.aspectBeanNames = aspectNames;


//将 `@Aspect` 对象转换为 `Advisor` 对象(Base interface holding AOP advice (action to take at a joinpoint))，因为后续 AOP 逻辑依靠的是 `Advisor`.
MetadataAwareAspectInstanceFactory factory = new BeanFactoryAspectInstanceFactory(this.beanFactory, beanName);
List<Advisor> classAdvisors = this.advisorFactory.getAdvisors(factory);

//同样的，Advisor对象也会被缓存起来, 以备后用.
this.advisorsCache.put(beanName, classAdvisors);

看到这里，其实在 Spring IOC 阶段， 每个对象执行 postProcessBeforeInstantiation 的时候,再准确的说是 findCandidateAdvisors 方法, 会从 beanFactory 找所有符合的 AOP advice. 这时可能会问，spring 管理的对象那么多，每个都执行一遍是不是太慢了？所以Spring的设计是只有第一次会完整执行逻辑, 随后获取的都是缓存.

postProcessAfterInitialization

拿到了所有的 AOP advice，那就要用起来. 在每个对象创建的过程中, 当执行到AnnotationAwareAspectJAutoProxyCreator 的 postProcessAfterInitialization 时, 就会开始真正代理这个对象.

- org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization
	- org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#wrapIfNecessary
		- org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#getAdvicesAndAdvisorsForBean
			- org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findEligibleAdvisors
				- org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator#findCandidateAdvisors

上面的调用链有没有发现熟悉的方法？ 没错， findCandidateAdvisors方法又出现了, 具体来说我们先从 findEligibleAdvisors 方法看起.

	protected List<Advisor> findEligibleAdvisors(Class<?> beanClass, String beanName) {
		//直接从缓存 找到所有的 `AOP advice`
		List<Advisor> candidateAdvisors = findCandidateAdvisors();
		//再看看这个对象能不能跟 candidateAdvisors 匹配上
		List<Advisor> eligibleAdvisors = findAdvisorsThatCanApply(candidateAdvisors, beanClass, beanName);
		extendAdvisors(eligibleAdvisors);
		if (!eligibleAdvisors.isEmpty()) {
			eligibleAdvisors = sortAdvisors(eligibleAdvisors);
		}
		//返回能跟这个对象匹配上的 `AOP advice`
		return eligibleAdvisors;
	}

findEligibleAdvisors 作用就是 筛选出能与当前对象匹配的 AOP advice . 从下图可知,能与TestService 匹配的 advice 正好就是 TestAspectJ 类所写的内容.

createProxy

到这一步，AOP 已经到了创建代理对象的步骤:

1. 新建 ProxyFactory 对象，对象包含了 Advisors 和 待代理的对象 等必要的信息.
2. createAopProxy 方法确定代理的模式,jdk 动态代理 or cglib.
   • 之前设置了 spring.aop.proxy-target-class=false ，所以这里会做判断选择 JdkDynamicAopProxy.
3. JdkDynamicAopProxy的getProxy方法会调用 Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this);.到这里是不是逻辑就很清楚了，Proxy.newProxyInstance做了什么直接看我另一篇博客 从代理模式再出发！Proxy.newProxyInstance的秘密

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
		if (!NativeDetector.inNativeImage() &&
				(config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config))) {
			Class<?> targetClass = config.getTargetClass();
			if (targetClass == null) {
				throw new AopConfigException("TargetSource cannot determine target class: " +
						"Either an interface or a target is required for proxy creation.");
			}
			if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
				return new JdkDynamicAopProxy(config);
			}
			return new ObjenesisCglibAopProxy(config);
		}
		else {
			return new JdkDynamicAopProxy(config);
		}
	}