Spring AOP源码(四)：创建被代理类的代理对象

　　在AOP源码(三)：创建AOP相关的Bean中，介绍了Spring创建AOP的Advisor、AnnotationAwareAspectJAutoProxyCreator的创建，其中被代理类的代理对象是如何创建的未做说明，下面来看看AOP代理对象的创建。

　　在IOC容器启动完成，容器一级缓存singletonObjects里被代理类mathCalculator对应的value为MathCalculator$$EnhancerBySpring$$9bfe5203@2543,是一个代理对象。到这里可以带出两个问题：

　　1、被代理类是使用代理对象调用目标方法的，被代理类的bean是否会被创建

　　2、代理对象是在什么时候创建

　　3、代理对象在什么时候放入三级缓存的

1、AOP创建被代理类实例化入口

　　一般在AOP的配置中，被代理类用bean标签声明的，在IOC容器refresh()方法中，对于普通、非懒加载的bean的实例化是在finishBeanFactoryInitialization(beanFactory);方法中完成实例化、初始化、并将创建好的bean放入三级缓存中，从finishBeanFactoryInitialization方法中分析被代理类相关的创建过程。

2、AOP创建被代理类的代理对象核心伪代码

　　DefaultListableBeanFactory#preInstantiateSingletons 核心伪代码如下

// 实例化并初始化IOC容器中所有的单例bean
public void preInstantiateSingletons() throws BeansException {
   
   // 创建一个beanDefinitionNames的一个副本
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
   
   // 触发所有非延迟加载单例bean的初始化，遍历集合的对象
   for (String beanName : beanNames) {
      getBean(beanName);
   }
}

　　当前beanDefinitionNames的包含被代理类MathCalculator的beanName，遍历beanNames，并通过getBean获取被代理类的实际bean信息。

　　通过AbstractBeanFactory#getBean -> AbstractBeanFactory#doGetBeanBean -> AbstractAutowireCapableBeanFactory#createBean -> AbstractAutowireCapableBeanFactory#doCreateBean 的流程创建被代理类的bean信息。

　　AbstractAutowireCapableBeanFactory#doCreateBean 核心伪代码：

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {

    // 用来持有创建出来的bean对象的
    BeanWrapper instanceWrapper = null;
    
    // 创建被代理类的bean实例（反射，无参构造方法实例化被代理类）
    instanceWrapper = createBeanInstance(beanName, mbd, args);
    
    // 从包装类中获取原始bean
    Object bean = instanceWrapper.getWrappedInstance();

    // 初始化返回的bean对象：exposedObject，此时仍然为被代理类MathCalculator的bean实例对象
    Object exposedObject = bean;

    // 对bean的属性进行填充，将各个属性值注入，其中，可能存在依赖于其他bean的属性，则会递归初始化依赖的bean
    populateBean(beanName, mbd, instanceWrapper);
    
    // 执行初始化逻辑，此处返回代理类的代理对象
    exposedObject = initializeBean(beanName, exposedObject, mbd);
    
    // 返回被代理类的代理对象
    return exposedObject;
}

　　当执行完createBeanInstance(beanName, mbd, args);步骤，此时instanceWrapper为被代理类MathCalculator的bean实例对象。

　　初始化返回的bean对象内容，exposedObject为被代理类MathCalculator的bean实例对象。

　　populateBean(beanName, mbd, instanceWrapper);对实例化的bean做属性填充，不涉及返回对象exposedObject的处理，该方法可不做考虑。

　　初始化方法initializeBean(beanName, exposedObject, mbd);执行完成，exposedObject对象已变成被代理类MatchCalculator的代理对象了。

 

通过上述分析，可以简单的回答最开始抛出的问题了：

　　1、被代理类是使用代理对象调用目标方法的，被代理类是否会被创建

　　　　被代理类的bean会被创建

　　2、代理对象是在什么时候创建

　　　　在被代理类bean初始化阶段创建的代理对象

3、被代理类的bean如何被代理对象替换的

　　到目前为止已经知道被代理类在初始化阶段会返回代理对象，

　　AbstractAutowireCapableBeanFactory#initializeBean 初始化Bean信息核心伪代码：

// 初始化bean信息
protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
  
   Object wrappedBean = bean;
   
   //如果mdb不为null || mbd不是"synthetic"。只有AOP相关的prointCut配置或者Advice配置才会将 synthetic设置为true
   if (mbd == null || !mbd.isSynthetic()) {
      // 初始化Bean的前置处理方法
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }

  //调用初始化方法，通过反射执行
  invokeInitMethods(beanName, wrappedBean, mbd);
   
   //如果mbd为null || mbd不是"synthetic"
   if (mbd == null || !mbd.isSynthetic()) {
      // 初始化Bean的后置处理方法
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }

   //返回包装后的Bean
   return wrappedBean;
}

　　在Bean的初始化后置处理之前，wrappedBean都为被代理类的MatchCalculator的对象，执行完applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)方法，wrappedBean就变为被代理类的代理对。

　　此处我们可以得出结论，AOP被代理类的代理对象是在初始化Bean的后置处理创建并返回的。

初始化bean的后置处理器核心伪代码：

　　AbstractAutoProxyCreator#postProcessAfterInitialization

// Bean初始化的后置处理
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
   if (bean != null) {
      // 获取缓存中当前bean的key：如果beanName不为空，则以beanName为key，此处为mathCalculator
      Object cacheKey = getCacheKey(bean.getClass(), beanName);
      // 当前bean是否已经被提前代理
      if (this.earlyProxyReferences.remove(cacheKey) != bean) {
         // bean未被提前代理，若需要代理，创建代理对象并返回
         return wrapIfNecessary(bean, beanName, cacheKey);
      }
   }
   return bean;
}

　　AbstractAutoProxyCreator#wrapIfNecessary 核心伪代码：

// bean生成代理对象的类型，key=beanName， value为生成代理类的Class对象
private final Map<Object, Class<?>> proxyTypes = new ConcurrentHashMap<>(16);

// 已经被代理的beanName的容器，value=true 表示key=beanName已经生成了代理对象
private final Map<Object, Boolean> advisedBeans = new ConcurrentHashMap<>(256);

// 代理对象创建
protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
    
    // 这里isInfrastructureClass()用于判断当前bean是否为Spring系统自带的bean，自带的bean是不用进行代理的；
    // shouldSkip()则用于判断当前bean是否应该被略过
    if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
       this.advisedBeans.put(cacheKey, Boolean.FALSE);
       return bean;
    } 
    
   // 获取当前bean的Advices和Advisors， 添加ExoseInvocationInterceptor的处理链并放在索引为0的位置
   Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
   
   // 对当前bean的代理状态进行缓存
   if (specificInterceptors != DO_NOT_PROXY) {
      // 对当前bean的代理状态进行缓存
      this.advisedBeans.put(cacheKey, Boolean.TRUE);
      
      // 根据获取到的Advices和Advisors为当前bean生成代理对象
      Object proxy = createProxy(
            bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
      // 缓存生成的代理bean的类型，并且返回生成的代理bean
      this.proxyTypes.put(cacheKey, proxy.getClass());
      return proxy;
   }

   this.advisedBeans.put(cacheKey, Boolean.FALSE);
   return bean;
}

　　到这里可以很清楚的看到，当IOC容器中有Advisor通知时，会创建被代理类MathCalCulator的代理对象并返回，将代理对象的引用设置给exposedObject变量。这里要注意一点， getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null)添加了一个ExoseInvocationInterceptor的Advice,用作执行AOP责任链的控制器。

4、被代理类的代理对象是如何设置进三级缓存的

　　createBean的入口是在AbstractBeanFactory#doGetBean方法中，getSingleton(String beanName, ObjectFactory singletonFactory)，singletonFactory是一个函数式接口，当执行到getSingleton里的singletonFactory.getObject();时，执行创建bean的方法createBean

 

protected <T> T doGetBean(
      String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
      throws BeansException {
    Object bean;
    
    // 提前检查单例缓存中是否有手动注册的单例对象
    Object sharedInstance = getSingleton(beanName);
      
    // 创建单例bean的实例对象
    if (mbd.isSingleton()) {
        // 返回以beanName的(原始)单例对象，如果尚未注册，则使用singletonFactory创建并注册一个对象:
        sharedInstance = getSingleton(beanName, () -> {
           try {
              // 为给定的合并后BeanDefinition(和参数)创建一个bean实例
              return createBean(beanName, mbd, args);
           }
           catch (BeansException ex) {
              destroySingleton(beanName);
              throw ex;
           }
        });
        // 从beanInstance中获取公开的Bean对象，主要处理beanInstance是FactoryBean对象的情况，如果不是
        // FactoryBean会直接返回beanInstance实例
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }
        
   // 将bean返回出去
   return (T) bean;
}

　　DefaultSingletonBeanRegistry#getSingleton 核心伪代码

// 获取单例Bean
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {

    // 从单例对象的三级缓存中获取beanName对应的单例对象
    Object singletonObject = this.singletonObjects.get(beanName);
      
    // 如果单例对象获取不到
    if (singletonObject == null) {       
        // 从单例工厂中获取对象
        singletonObject = singletonFactory.getObject();
        // 生成了新的单例对象的标记为true，表示生成了新的单例对象
        newSingleton = true;
    }
         
     // 生成了新的单例对象
     if (newSingleton) {
        // 将beanName和singletonObject的映射关系添加到该工厂的单例缓存中:
        addSingleton(beanName, singletonObject);
     }

      // 返回该单例对象
      return singletonObject;
}

　　从doCreateBean中返回的exposeObject代理对象，最终在singletonObject = singletonFactory.getObject();步骤中，将代理对象赋值给singletonObject，并标记为新建的单例对象，通过addSingleton方法将代理对象设置进三级缓存中。

　　DefaultSingletonBeanRegistry#addSingleton 核心代码

protected void addSingleton(String beanName, Object singletonObject) {
   synchronized (this.singletonObjects) {
      // 将映射关系添加到单例对象的一级缓存中
      this.singletonObjects.put(beanName, singletonObject);
      // 移除beanName在单例工厂缓存中的数据
      this.singletonFactories.remove(beanName);
      // 移除beanName在早期单例对象的高速缓存的数据
      this.earlySingletonObjects.remove(beanName);
      // 将beanName添加到已注册的单例集中
      this.registeredSingletons.add(beanName);
   }
}

代理对象在什么时候放入三级缓存的：

　　与普通bean一样，都是在实例化完成之后，将返回的bean信息放入三级缓存中，只不过对于AOP的被代理类，实例化后返回的不是bean本身，而是代理类的代理对象的bean。

5、AOP创建被代理类的代理对象核心流程图