六. 容器的创建流程（关联Aspect部分）

本篇文章只是简单的关联 Aspect 部分内容。
做一个独立出来的容器创建步骤中的 Aspect 部分。为了不让AOP 过于冗余。做一个简单的抽离。
整理的比较乱：有时间的时候在整理下用词吧。 TODO

话不多说，直接进入正文吧。

下面说下容器创建流程中的 Aspect 部分。

1. 流程

1.1 通过配置类，创建 IOC 容器

 // 创建 IOC 容器
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfigOfAOP.class);

1.2 注册配置类，调用 refresh() 刷新容器

public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
        this();
        register(annotatedClasses);
        refresh();
}

1.3 注册 bean 的后置处理器: BeanPostProcessors

实现步骤：

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

其实只是定义还没有创建。定义信息（BeanDefinitions）

// 通过注解获取所有的后置处理器
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);

// 创建注册 beanPostProcessor
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);

registerBeanPostProcessors(beanFactory, orderedPostProcessors);


// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);

-->
  
beanFactory.addBeanPostProcessor(postProcessor);

1.3.1 获取所有后置处理器

六. 容器的创建流程（关联Aspect部分）

1.3.2 按照排序规则，依次创建注册 BeanPostProcessor

给容器中添加创建BeanPostProcessor对象

1）、优先注册实现了PriorityOrdered接口的BeanPostProcessor；
2）、再给容器中注册实现了Ordered接口的BeanPostProcessor；
3）、注册没实现优先级接口的BeanPostProcessor；

// First, register the BeanPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);

// Next, register the BeanPostProcessors that implement Ordered.
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  orderedPostProcessors.add(pp);
  if (pp instanceof MergedBeanDefinitionPostProcessor) {
    internalPostProcessors.add(pp);
  }
}
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);

// Now, register all regular BeanPostProcessors.
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
  BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
  nonOrderedPostProcessors.add(pp);
  if (pp instanceof MergedBeanDefinitionPostProcessor) {
    internalPostProcessors.add(pp);
  }
}
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);

// Finally, re-register all internal BeanPostProcessors.
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);

这里面创建 BeanPostProcessor 的方法 getBean 单独拎出来放到下面统一说。

1.3.3 添加到 beanFactory

beanFactory.addBeanPostProcessor(postProcessor);

注册到 beanFactory 中

以上是创建和注册AnnotationAwareAspectJAutoProxyCreator的过程

AnnotationAwareAspectJAutoProxyCreator => InstantiationAwareBeanPostProcessor

1.4 注册其他的bean

比如业务逻辑 (MathCalculator 对应的组件) 和切面组件（LogAspect 对应的组件）

步骤： finishBeanFactoryInitialization(beanFactory);

// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();

getBean(beanName);

遍历容器中的所有 bean，依次创建对象 getBean(beanName);

六. 容器的创建流程（关联Aspect部分）
在创建bean 的时候，这里会有所不同

1） AnnotationAwareAspectJAutoProxyCreator在所有bean创建之前会有一个拦截，InstantiationAwareBeanPostProcessor，会调用postProcessBeforeInstantiation()

2) 先从缓存中获取当前bean，如果能获取到，说明bean是之前被创建过的，直接使用，

否则再创建；只要创建好的Bean都会被缓存起来

因为最后获取所有 bean 的创建。而有些已经在前面的步骤先行创建好了。只需要从缓存中获取就好。

// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);

为空再去创建 bean
return createBean(beanName, mbd, args);

a. AnnotationAwareAspectJAutoProxyCreator 在 createBean（）之前拦截

所谓的拦截，就是一段代码提前执行。

所在类： org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java

try {
   // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
   Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
   if (bean != null) {
      return bean;
   }
}

AnnotationAwareAspectJAutoProxyCreator 会在任何bean创建之前先尝试返回bean的实例【BeanPostProcessor是在Bean对象创建完成初始化前后调用的】

执行的方法

@Nullable
protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
  Object bean = null;
  if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
    // Make sure bean class is actually resolved at this point.
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      Class<?> targetType = determineTargetType(beanName, mbd);
      if (targetType != null) {
        // 切面的部分 ++ 
        bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
        if (bean != null) {
          bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
        }
      }
    }
    mbd.beforeInstantiationResolved = (bean != null);
  }
  return bean;
}

其中 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);

和 bean = applyBeanPostProcessorsAfterInitialization(bean, beanName); 为重要的功能。

只针对： InstantiationAwareBeanPostProcessor 的后置处理器

@Nullable
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
                if (result != null) {
                    return result;
                }
            }
        }
        return null;
    }

解析BeforeInstantiation

希望后置处理器在此能返回一个代理对象；如果能返回代理对象就使用，如果不能就继续

这部分放到切面的部分来说。等待补充 TODO

2. 获取创建bean的过程: BeanPostProcessor

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

doCreateBean 的实现步骤

也就是创建 BeanPostProcessor 的过程。同样的也是创建 bean 的过程

这个时候 bean 只是有一个name 什么都没有。

对应的创建类： org/springframework/beans/factory/support/AbstractBeanFactory.java

六. 容器的创建流程（关联Aspect部分）

具体流程步骤的类： org/springframework/beans/factory/support/AbstractAutowireCapableBeanFactory.java

2.1 创建 bean 的实例

源码如下：

if (instanceWrapper == null) {
  instanceWrapper = createBeanInstance(beanName, mbd, args);
}

里面的方法不再过多介绍 最后通过类的无参够着函数 实例化类
// No special handling: simply use no-arg constructor.
return instantiateBean(beanName, mbd);

2.2 设置 bean 的属性

源码如下：

populateBean(beanName, mbd, instanceWrapper);

里面的细节不再过多解释，通过反射。为里面类的属性赋值

2.3 初始化 bean

源码如下：

exposedObject = initializeBean(beanName, exposedObject, mbd);

初始化 bean 的时候可以做很多工作。

六. 容器的创建流程（关联Aspect部分）

作为和 https://segmentfault.com/a/1190000021554606 的对比。

本文主要增加了 Aware 部分。

invokeAwareMethods(beanName, bean);

所以初始化 bean 的步骤如下

1）invokeAwareMethods()：处理Aware接口的方法回调
2）applyBeanPostProcessorsBeforeInitialization()：
应用后置处理器的postProcessBeforeInitialization()
3）invokeInitMethods()；执行自定义的初始化方法
4）applyBeanPostProcessorsAfterInitialization()；执行后置处理器的postProcessAfterInitialization()；