Spring AOP实现源码分析（二）

Spring AOP的实现可以分为三大部分
1. 注册AOP功能具体实现类

2. 普通Bean实例化时AOP的切入

3. AOP切入具体流程

 

2. 普通Bean实例化时AOP的切入

ApplicationContext主流程会保证先完成BeanPostProcessor的注册实例化，这样可以保证普通bean实例化时，所有的 BeanPostProcessor 已经实例化了

 

public void refresh() throws BeansException, IllegalStateException {
  ......
  // Register bean processors that intercept bean creation.
  // 完成所有 BeanPostProcessor 实例化
  registerBeanPostProcessors(beanFactory);
  ......
  // Instantiate all remaining (non-lazy-init) singletons.
  // 实例化所有的普通单例bean
  finishBeanFactoryInitialization(beanFactory);
  // Last step: publish corresponding event.
  finishRefresh();
}

 

实例化bean的操作，流程会调用createBean()，

AOP实现类，有两套几乎同名的函数，注意区分就明白了

 

// 这一对是在调用createBean之前使用,Instantiation的意思是实例化
postProcessBeforeInstantiation
postProcessAfterInstantiation

// 这一对是在createBean中已经创建了bean之后使用，Initialization的意思是初始化
postProcessBeforeInitialization
postProcessAfterInitialization

 

protected Object createBean(){
    ......
    try {
        // 真正的bean实例化之前调用，如果BeanPostProcessor创建bean，则跳过后面的doCreateBean, 直接返回
        // 这个会调用上面的Instantiation系列，最终返回null，进入 doCreateBean
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        if (bean != null) {
             return bean;
        }
    }
    // 真正的bean实例化后调用 BeanPostProcessor的方法再次改变bean
    Object beanInstance = doCreateBean(beanName, mbd, args);
    ......
}

protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    ......
    // 执行 beanPostProcessor.postProcessorBeforeInstantiation()
    // 注意此方法的名字BeforeInstantiation
    bean = applyBeanPostProcessorBeforeInstantiation(mbd.getBeanClass(), beanName);
    // 只有上一个方法返回的bean不是null，才进行下一步
    if(bean !=null){
        // 执行 beanPostProcessor.postProcessorAfterInstantiation()
        bean = applyBeanPostProcessorBeforeInstantiation(bean, beanName);
    }
}

 

普通bean的aop生效，是使用了Initialization系列方法，跟踪doCreateBean(beanName, mbd, args)

 

protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
......				
  if (mbd.isSingleton()) {
    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
	@Override
	public Object getObject() throws BeansException {
	try {
          // 开始创建bean的流程
	  return createBean(beanName, mbd, args);
	}
     }
......
}

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
......
  Object beanInstance = doCreateBean(beanName, mbdToUse, args);
......
}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {
......
try {
  populateBean(beanName, mbd, instanceWrapper);
  if (exposedObject != null) {
    // bean之前已经实例化了，这里面进行最后的初始化init,aop介入
    exposedObject = initializeBean(beanName, exposedObject, mbd);
  }
}
......
}

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
......
  if (mbd == null || !mbd.isSynthetic()) {
    // 普通bean执行统一的post处理，aop就是在里面实现的
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  }
  return wrappedBean;
......
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException {
  Object result = existingBean;
  for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
    // 调用AOP的真正实现方法入口
    result = beanProcessor.postProcessAfterInitialization(result, beanName);
    if (result == null) {
      return result;
    }
  }
  return result;
}