AOP 代理对象的创建发生在 bean 初始化后。
    代理创建器实现了 BeanPostProcessor 接口，并在 bean 初始化的后置处理过程中向 bean 中加入增强。
    如下类图所示： AOP增强入口位置 - 图1 首先我们增加一个 AOP. 参考 spring - aop.

    1. <beans xmlns="http://www.springframework.org/schema/beans"
    2.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    3.        xmlns:aop="http://www.springframework.org/schema/aop"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.         https://www.springframework.org/schema/beans/spring-beans.xsd
    6.         http://www.springframework.org/schema/aop
    7.         https://www.springframework.org/schema/aop/spring-aop.xsd">
    8.     <!-- 基于aspectj 注解 -->
    9.     <aop:aspectj-autoproxy proxy-target-class="true"/>
    10.     <!-- 接口 -->
    11.     <bean id="userService" class="cn.lichenghao.aop.jdk.service.impl.UserServiceImpl"></bean>
    12.     <!-- 通知类 -->
    13.     <bean id="aopLogger" class="cn.lichenghao.aop.AopLogger2"></bean>
    14. </beans>

    XML 定义 AOP 配置完毕后，启动容器会将对应的配置解析成 BeanDefinition 。
    具体见：4. 解析 XML 文档 - doRegisterBeanDefinitions 自定义标签解析。
    从 bean 初始化的后置处理器开始：

    1. protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
    2.     // 调用Aware相关方法
    4.     // 执行前置处理器。包括Aware相关扩展接口
    6.     // 执行自定义init方法
    8.     // 执行后置处理器
    9.     if (mbd == null || !mbd.isSynthetic()) {
    10.         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    11.     }
    12.     return wrappedBean;
    13. }

    进入后置处理方法
    org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization

    1. @Override
    2. public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    3.         throws BeansException {
    5.     Object result = existingBean;
    6.     for (BeanPostProcessor processor : getBeanPostProcessors()) {
    7.         Object current = processor.postProcessAfterInitialization(result, beanName);
    8.         if (current == null) {
    9.             return result;
    10.         }
    11.         result = current;
    12.     }
    13.     return result;
    14. }

    进入 AOP 后置处理器 AbstractAutoProxyCreator 实现 BeanPostProcessor 的方法 postProcessAfterInitialization.
    具体实例为：

    1. AnnotationAwareAspectJAutoProxyCreator (使用 aspectj 注解的 aop)
    2. AspectJAwareAdvisorAutoProxyCreator (使用 xml 的 aop)

    org.springframework.aop.framework.autoproxy.AbstractAutoProxyCreator#postProcessAfterInitialization 

    1. @Override
    2. public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
    3.     if (bean != null) {
    4.         // 获取缓存key
    5.         // 如果是普通bean，则返回beanName，如果是FactoryBean,则返回加上前缀&的&beanName
    6.         Object cacheKey = getCacheKey(bean.getClass(), beanName);
    7.         /*
    8.             从earlyProxyReferences 缓存判断
    9.             earlyProxyReferences中缓存的是已经创建好的代理对象
    10.             如果bean不存在相互引用的话，那么这个this.earlyProxyReferences.remove(cacheKey)方法始终返回null
    11.         */
    12.         if (this.earlyProxyReferences.remove(cacheKey) != bean) {
    13.             // 说明移除缓存的不是FactoryBean，那么继续看是否需要被代理
    14.             return wrapIfNecessary(bean, beanName, cacheKey);
    15.         }
    16.     }
    17.     return bean;
    18. }

    在初始化阶段，如果发生循环依赖，代理对象会提前创建放在缓存 earlyProxyReferences 中，
    如果经过缓存 earlyProxyReferences 判断没有创建过代理的话，接下来就需要进行判断是否要为该对象创建代理对象。