（二）Spring框架原理之实例化bean和@Autowired实现原理

目录

一、UML类图及流程分析

1.UML类图组成

2.流程分析

二、源码分析

1.DefaultListableBeanFactory类实例化bean部分

2.AbstractBeanFactory抽象类

3.AbstractAutowireCapableBeanFactory抽象类

4.DefaultSingletonBeanRegistry类

5.AutowiredAnnotationBeanPostProcessor类

6.InjectionMetadata类

7.AutowiredFieldElement内部类

8.DefaultListableBeanFactory类处理@Autowired注解

---

两部分流程都较长，如果只对Bean的实例化感兴趣只需要看到5.DefaultSingletonBeanRegistry小节即可，后面是分析@Autowired注解的实现原理。

一、UML类图及流程分析

1.UML类图组成

UML类图组成如下：

这个图中我们可以大致分为六个部分：

1. 第一部分肯定是BeanDefinition的父类和子类组成的，这部分的组成有需要再细分一下，共可以分为六部分：
   1. AttributeAccessor接口：这个接口提供了setAttribute和getAttribute等操作属性的方法提供给子类实现；
   2. BeanMetadataElement接口：该接口只提供了一个getSource方法，提供子类获取源对象方法；
   3. BeanDefinition接口：bean定义的直接接口，这个接口提供了常见的scope、lazy、dependsOn、initMethod和destroyMethod等属性配置方法，规范了一个Spring管理的Bean必须实现哪些属性；
   4. AnnotatedBeanDefinition：注解bean定义，里面提供了两个方法，一个是获取注解元数据，另一个是获得方法元数据；
   5. BeanDefinitionHolder：该类和子类BeanComponentDefinition的作用便是持有bean的名字、别名和其对应的BeanDefinition，可以注册为内部bean的占位符；
   6. BeanDefinitionBuilder：普通BeanDefinition的构造器，这里面可以构造RootBeanDefinition、ChildBeanDefinition和GenericBeanDefinition等多个类型的bean定义，想要快速实例化一个bean定义可以用此类完成；
2. BeanDefinitionParser接口：从名字便可以看出来其大致作用，用来解析BeanDefinition的接口，其主要是被Spring的NamespaceHandlerSupport实现子类来完成诸如和等XML标签的读取解析去获取Bean定义的；
3. BeanDefinitionRegistry接口：bean定义的注册中心，该接口的实现子类将可以完成注册、删除和获取bean定义等操作，Spring默认实现的Bean工厂DefaultListableBeanFactory便实现了该接口来管理bean定义；
4. BeanWrapper接口：这部分的接口功能便是封装一个bean实例，且提供为这个bean调用对应的setter和getter方法，设置bean的具体成员属性值；
5. @Autowired注解实现相关的类：如图中的最右侧部分的InjectionPoint实现层级和InjectionMetadata相关层级，这部分是存储实现@Autowired注解功能的必要参数，如class类型和这个class对象所需要的自动注入的对象；而DependencyDescriptor则保存了需要赋值的字段或者方法返回值和赋值的beanClass类型，随后再根据DependencyDescriptor的具体子类类型判断返回list、map、array或者单个的bean对象；
6. NamedBeanHolder：用来存储beanName和已经初始化完成的bean实例，这个对象在参数为class类型调用getBean时被使用。

2.流程分析

Spring工厂实例化bean时对象的变化流程图：

我在分析该流程时将其分为了三个部分：

1. 中间的核心部分：这部分的主要流程是在bean工厂的两个抽象类AbstractBeanFactory和AbstractAutowireCapableBeanFactory中完成的，主要的功能便是通过bean的名称调用getBean方法，随后在这两个类中完成初始化以及调用此过程中涉及到的接口，其中比较常用的便是FactoryBean和BeanPostProcessor两个接口，诸如其它的Aware接口也是在这个流程调用的；
2. 右边的封装部分：虽然这部分调用的getBean也是BeanFactory接口声明的方法，但我们分析初始化Bean流程时可以把这个部分当成额外的封装部分，是对通过beanName获取bean的一种基于便利性的额外封装实现。这个流程主要是在DefaultListableBeanFactory类中完成的，其大致作用便是通过class类型获取唯一的候选者beanName，因为一个class类型可能会在工厂中匹配到多个beanName，因此需要做一些额外处理，当获得beanName之后再调用核心部分去实例化bean；
3. 左边的功能拓展部分：这部分的入口是在获取到BeanWrapper之后，调用BeanPostProcessor实现类AutowiredAnnotationBeanPostProcessor来完成的。这部分的功能便是处理@Autowired注解，先通过BeanWrapper获取bean的class对象，再判断其字段和方法有哪些是被这个注解的，随后再依次处理判断，在获得自动注入的这些实例时，将再次调用getBean，形成一个递归调用，完成bean的获取和赋值到字段或方法上。

二、源码分析

1.DefaultListableBeanFactory类实例化bean部分

先从外部额外封装的getBean方法分析起，其关键源码部分如下：

public class DefaultListableBeanFactory 
        extends AbstractAutowireCapableBeanFactory
        implements ConfigurableListableBeanFactory, BeanDefinitionRegistry,
        Serializable {
    @Override
    public  T getBean(Class requiredType) throws BeansException {
       // 对外单个类参数获取bean，将会调用后面带有参数args的方法
       return getBean(requiredType, (Object[]) null);
    }
    @Override
    public  T getBean(Class requiredType, @Nullable Object... args) 
            throws BeansException {
       // 调用resolveBean方法解析bean
       Object resolved = resolveBean(ResolvableType
               .forRawClass(requiredType), args, false);
       // 如果返回的是nll，则代表Spring工厂中没有class类型的bean信息
       if (resolved == null) {
          throw new NoSuchBeanDefinitionException(requiredType);
       }
       return (T) resolved;
    }
    @Nullable
    private  T resolveBean(ResolvableType requiredType, 
            @Nullable Object[] args, boolean nonUniqueAsNull) {
       // 流程图中右侧的最后一步，将resolveNamedBean方法返回的NamedBeanHolder
       // 类型判空，如果不为空则直接将内部的beanInstance实例返回，在
       // resolveNamedBean方法中执行的是第三步，把ResolvableType转为beanName
       NamedBeanHolder namedBean = resolveNamedBean(requiredType, args, 
               nonUniqueAsNull);
       if (namedBean != null) {
          return namedBean.getBeanInstance();
       }
       // 如果从当前的beanFactory中获取不到bean的信息则从父类beanFactory中
       // 获取，依次递归下去，这里可以忽略这段代码（正常情况下没有层级关系）
       ...
       return null;
    }
    @Nullable
    private  NamedBeanHolder resolveNamedBean(
          ResolvableType requiredType, @Nullable Object[] args, 
          boolean nonUniqueAsNull) throws BeansException {
       // 根据requiredType中的class类型获取beanName集合，这里面将会判断list
       // 集合beanDefinitionNames来获取普通的bean候选者，判断set集合
       // manualSingletonNames中手动添加的单例对象，两者都会判断FactoryBean和
       // 普通的bean对象，并选举出来称为候选者，具体流程不分析
       String[] candidateNames = getBeanNamesForType(requiredType);
       // 如果获取到的beanName是多个，则说明这一个class对应多个bean
       if (candidateNames.length > 1) {
          List autowireCandidates = 
                  new ArrayList<>(candidateNames.length);
          // 先判断beanDefinitionMap集合中是否含有该candidateName
          // 如果有则后续进行转换到candidateNames数组
          for (String beanName : candidateNames) {
             if (!containsBeanDefinition(beanName) || 
                     getBeanDefinition(beanName).isAutowireCandidate()) {
                autowireCandidates.add(beanName);
             }
          }
          // 将List转换为原来的String[]数组
          if (!autowireCandidates.isEmpty()) {
             candidateNames = StringUtils
                     .toStringArray(autowireCandidates);
          }
       }
       // 如果candidateNames数组长度为1，则说明class只有一个对应的bean
       if (candidateNames.length == 1) {
          String beanName = candidateNames[0];
          // 直接获取0号位置的beanName，并调用getBean(beanName)方法初始化bean
          // 随后将bean实例赋值到NamedBeanHolder中的beanInstance属性中
          // 以便该方法返回后直接返回beanInstance属性对象
          return new NamedBeanHolder<>(beanName, (T) getBean(beanName, 
                  requiredType.toClass(), args));
       }
       else if (candidateNames.length > 1) {
          Map candidates = 
                  new LinkedHashMap<>(candidateNames.length);
          // 对candidateNames进行依次处理
          for (String beanName : candidateNames) {
             // 如果是单例对象，即singletonObjects中含有此bean
             if (containsSingleton(beanName) && args == null) {
                // 直接先调用getBean(beanName)获取bean实例
                Object beanInstance = getBean(beanName);
                // 虽然放入到candidates集合中，以便后续返回具体的bean
                candidates.put(beanName, (beanInstance instanceof NullBean?
                        null : beanInstance));
             }
             else {
                // 如果是原型的，则先把class类型放到candidates中，后续返回时再
                // 实例化返回
                candidates.put(beanName, getType(beanName));
             }
          }
          // 获取主要的候选者，即最终的bean返回对象，即声明对象时是否使用
          // @Primary注解了，如果注解了则使用其中最后一个候选者
          String candidateName = determinePrimaryCandidate(candidates, 
                  requiredType.toClass());
          // 如果判断的主要候选者为空（没有一个bean被@Primary注解）
          if (candidateName == null) {
             // 根据OrderComparator优先级获取优先级最高的bean
             candidateName = determineHighestPriorityCandidate(candidates,
                     requiredType.toClass());
          }
          // 如果不为空
          if (candidateName != null) {
             // 从前面组装的candidates集合Map中获取对应的bean对象
             // 这里获取到的可能是bean实例化对象，也有可能是class对象
             Object beanInstance = candidates.get(candidateName);
             // 如果beanInstance是空或者类型是class
             if (beanInstance == null || beanInstance instanceof Class) {
                // 调用getBean(candidateName)方法实例化bean
                beanInstance = getBean(candidateName, 
                        requiredType.toClass(), args);
             }
             // 使用NamedBeanHolder封装bean实例并返回
             return new NamedBeanHolder<>(candidateName, (T)beanInstance);
          }
          // 前面传入的nonUniqueAsNull值是false，因此如果到这里candidateName
          // 还是为null，则抛出异常没有唯一的bean可返回
          if (!nonUniqueAsNull) {
             throw new NoUniqueBeanDefinitionException(requiredType, 
                     candidates.keySet());
          }
       }
       // 如果候选者candidateNames为0，则直接返回null
       return null;
    }
}

这个类中主要方法栈为四层，调用这四个方法栈将会调用到其它的类中，如调用完之后将会返回已经实例化的bean对象，在调用方法栈中将会调用到AbstractBeanFactory类中的getBean方法中。也就是说DefaultListableBeanFactory类只是对getBean(class)这个方法进行了一层额外的封装，最终还是调用到了AbstractBeanFactory类中，因此我自己把这部分流程划为额外封装实现。

2.AbstractBeanFactory抽象类

前面说过，调用getBean(class)最终实例化bean时将会调用到这个类中，且这个类是核心部分的入口，可以说是非常重要了。接下来我们看下其部分关键源码：

public abstract class AbstractBeanFactory 
        extends FactoryBeanRegistrySupport 
        implements ConfigurableBeanFactory {
    @Override
    public Object getBean(String name) throws BeansException {
       return doGetBean(name, null, null, false);
    }
    @Override
    public  T getBean(String name, Class requiredType) 
            throws BeansException {
       return doGetBean(name, requiredType, null, false);
    }
    @Override
    public Object getBean(String name, Object... args) 
            throws BeansException {
       // 这三个方法都是调用了doGetBean，唯一的不同便在于传入的参数不一样
       // 但是name这个参数是必须的
       return doGetBean(name, null, args, false);
    }
    protected  T doGetBean(final String name, 
            @Nullable final Class requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) 
            throws BeansException {
       // 或许这个方法看起来会很长，但实际上可以把其分为五个功能大点
       // 一、使用aliasMap集合将传入的name转变成beanName
       final String beanName = transformedBeanName(name);
       Object bean;
       // 二、先从singletonObjects单例缓存集合中获取bean对象，如果不为空
       // 则直接返回赋值给sharedInstance对象如果为空则从singletonFactories集合
       // 中获取单例工厂类，并调用getObject获取单例bean对象返回赋值
       Object sharedInstance = getSingleton(beanName);
       if (sharedInstance != null && args == null) {
          // 如果sharedInstance不为空，则调用getObjectForBeanInstance方法
          // 判断其是否被FactoryBean封装的，如果是则调用该接口的getObject方法
          // 获取bean对象，如果不是则直接返回，其具体的方法流程略过，主要是
          // 判断FactoryBean接口的，有兴趣的可以去看下，后面都会用到
          bean = getObjectForBeanInstance(sharedInstance, name, beanName, 
                  null);
       } else {
          // 判断该beanName是否是原型且正在被创建的，如果是则抛出异常
          if (isPrototypeCurrentlyInCreation(beanName)) {
             throw new BeanCurrentlyInCreationException(beanName);
          }
          // 三、判断该beanFactory的父类工厂是否含有该bean对象，此略过，最终
          // 还是会跑到该方法的后续流程
          BeanFactory parentBeanFactory = getParentBeanFactory();
          if (parentBeanFactory != null && 
                  !containsBeanDefinition(beanName)) {
             ...
          }
          // typeCheckOnly传入的是false，因此会进入判断
          if (!typeCheckOnly) {
             // 该方法的作用便是将beanName添加到alreadyCreated集合中，标记为
             // 已经实例化过beanName对应的bean对象
             markBeanAsCreated(beanName);
          }
          // 该try-catch块将是实例化bean的地方，前面只是判断
          try {
             // 从mergedBeanDefinitions集合中获取具体的BeanDefinition对象
             final RootBeanDefinition mbd = 
                     getMergedLocalBeanDefinition(beanName);
             // 判断该bean定义是否合乎标准，如非抽象类
             checkMergedBeanDefinition(mbd, beanName, args);
             // 四、处理@DependsOn注解中的bean对象，在这里将会先实例化注解中
             // 引用的bean
             String[] dependsOn = mbd.getDependsOn();
             if (dependsOn != null) {
                // 如果获取的dependsOn不为空则依次遍历其中引入的值
                for (String dep : dependsOn) {
                   // 判断是否是循环依赖，如果是则抛出异常，所谓循环依赖则是
                   // @Bean注解的A方法使用@DependsOn依赖了@Bean注解的B方法
                   // 但是B方法又使用了@DependsOn依赖了A方法，形成死循环
                   if (isDependent(beanName, dep)) {
                      throw new BeanCreationException();
                   }
                   // 跑到这里代表前面并没有死循环依赖的发生，则把彼此相关的
                   // 依赖关系放入到dependentBeanMap中，因此第一次是绝对会
                   // 执行到这里的
                   registerDependentBean(dep, beanName);
                   try {
                      // 实例化依赖的bean
                      getBean(dep);
                   }
                   catch (NoSuchBeanDefinitionException ex) {
                      throw new BeanCreationException();
                   }
                }
             }
             // 五、判断Bean是单例或是原型进行相应的实例化操作
             if (mbd.isSingleton()) {
                // 如果是单例，则使用lambda实例化一个ObjectFactory对象传入
                // getSingleton方法实例化单例，这个方法也很重要，后续会分析
                sharedInstance = getSingleton(beanName, () -> {
                   try {
                      // 实例化的ObjectFactory对象执行的方法也很简单
                      // 单纯的调用createBean方法创造bean对象
                      return createBean(beanName, mbd, args);
                   }
                   catch (BeansException ex) {
                      // 如果创造失败则销毁对象（清除缓存）
                      destroySingleton(beanName);
                      throw ex;
                   }
                });
                // 判断这个bean是否被FactoryBean封装
                bean = getObjectForBeanInstance(sharedInstance, name, 
                        beanName, mbd);
             } else if (mbd.isPrototype()) {
                // 如果bean是原型
                Object prototypeInstance = null;
                try {
                   // 记录原型bean正在被创建，在前面会进行判断
                   beforePrototypeCreation(beanName);
                   prototypeInstance = createBean(beanName, mbd, args);
                }
                finally {
                   // 执行完后将当前创建的原型bean标记去除
                   afterPrototypeCreation(beanName);
                }
                // 判断这个bean是否被FactoryBean封装
                bean = getObjectForBeanInstance(prototypeInstance, name, 
                        beanName, mbd);
             } else {
                // 如果是其它类型的scope参数
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                // scope属性不能为空
                if (scope == null) {
                   throw new IllegalStateException();
                }
                try {
                   // Scope接口是Spring提供给外部使用的，因此如果指定了
                   // 自定义的Scope实现，调用里面的get方法将会执行普通的
                   // 原型bean流程，只是开发者可以在Scope中对该bean进行
                   // 额外的处理判断
                   Object scopedInstance = scope.get(beanName, () -> {
                      // 实际上ObjectFactory对象的操作流程和原型bean一模一样
                      beforePrototypeCreation(beanName);
                      try {
                         return createBean(beanName, mbd, args);
                      }
                      finally {
                         afterPrototypeCreation(beanName);
                      }
                   });
                   // 判断这个bean是否被FactoryBean封装
                   bean = getObjectForBeanInstance(scopedInstance, name, 
                           beanName, mbd);
                }
                catch (IllegalStateException ex) {
                   throw new BeanCreationException();
                }
             }
          }
          catch (BeansException ex) {
             cleanupAfterBeanCreationFailure(beanName);
             throw ex;
          }
       }
       // 这部分是判断如果要求的类型requiredType和获得的bean类型不一致进行
       // 转换的地方，正常使用是不会出现这种情况的，因此暂时略过
       if (requiredType != null && !requiredType.isInstance(bean)) {
          ...
       }
       // 返回bean对象
       return (T) bean;
    }
    
}

实际上doGetBean这个方法流程可以分为五个部分流程，如下图：

3.AbstractAutowireCapableBeanFactory抽象类

我们从上面的AbstractBeanFactory类已经分析到了createBean方法了，由于创建和初始化bean的核心流程都在AbstractAutowireCapableBeanFactory类的几个方法中，因此这个类的流程会比较多，大致流程可以看到下面的流程图：

接下来我们看下其关键部分源码：

public abstract class AbstractAutowireCapableBeanFactory 
        extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {
    public  T createBean(Class beanClass) throws BeansException {
       // AbstractBeanFactory并没有调用这个方法，但是我们也可以看下
       // 这个方法流程就是将beanClass封装成Bean定义且设置成原型
       RootBeanDefinition bd = new RootBeanDefinition(beanClass);
       bd.setScope(SCOPE_PROTOTYPE);
       bd.allowCaching = ClassUtils.isCacheSafe(beanClass, 
               getBeanClassLoader());
       return (T) createBean(beanClass.getName(), bd, null);
    }
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, 
            @Nullable Object[] args)
            throws BeanCreationException {
       // 真正创造bean的方法，这个方法大致可以分为三个部分
       RootBeanDefinition mbdToUse = mbd;
       // 一、将beanName和bean定义解析成对应的class类型
       Class resolvedClass = resolveBeanClass(mbd, beanName);
       if (resolvedClass != null && !mbd.hasBeanClass() && 
               mbd.getBeanClassName() != null) {
          mbdToUse = new RootBeanDefinition(mbd);
          // 确定具体的beanClass类型
          mbdToUse.setBeanClass(resolvedClass);
       }
       // 准备方法覆盖，无关紧要
       try {
          mbdToUse.prepareMethodOverrides();
       }
       catch (BeanDefinitionValidationException ex) {
          throw new BeanDefinitionStoreException();
       }
       // 二、如果bean定义的beforeInstantiationResolved属性为true
       // 则直接使用BeanPostProcessor对bean进行处理，且处理后直接返回
       // 不再使用Spring工厂的实例化流程，意味着Spring很多实例化中途的接口
       // 都将不起作用，还没见到过这种实例化方式的。这里面将会调用
       // InstantiationAwareBeanPostProcessor接口的before方法，调用
       // BeanPostProcessor接口的after方法
       try {
          Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
          if (bean != null) {
             return bean;
          }
       }
       catch (Throwable ex) {
          throw new BeanCreationException();
       }
       try {
          // 三、调用doCreateBean方法实行真正创建bean流程
          Object beanInstance = doCreateBean(beanName, mbdToUse, args);
          return beanInstance;
       } catch (BeanCreationException | 
               ImplicitlyAppearedSingletonException ex) {
          throw ex;
       } catch (Throwable ex) {
          throw new BeanCreationException();
       }
    }
    protected Object doCreateBean(final String beanName, 
            final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
       // 根据createBean方法的流程来看，其相当于是外面再封装了一层，用来解析
       // beanClass属性和提前使用BeanPostProcessor完成bean的实例化，真正的
       // Spring实例化bean的流程其实是在这个方法中
       // 在这个方法中共可以分为五个部分
       BeanWrapper instanceWrapper = null;
       // 一、如果是单例对象，则把factoryBeanInstanceCache缓存清掉，同时获取
       // 缓存的BeanWrapper实例对象，单例对象（FactoryBean）在调用getType等
       // 方法时将会被实例化后放到factoryBeanInstanceCache中，一般流程为null
       if (mbd.isSingleton()) {
          instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
       }
       // 如果instanceWrapper为null，则调用createBeanInstance实例化对象
       // 在执行完这个方法后bean对象才会被实例化
       if (instanceWrapper == null) {
          // 具体实例化对象的地方，其大部分会调用instantiateBean方法利用反射来
          // 完成bean的实例化
          instanceWrapper = createBeanInstance(beanName, mbd, args);
       }
       // 分别获取实例化对象和class类型
       final Object bean = instanceWrapper.getWrappedInstance();
       Class beanType = instanceWrapper.getWrappedClass();
       if (beanType != NullBean.class) {
          mbd.resolvedTargetType = beanType;
       }
       // 二、允许程序在创建bean对象后再修改合并后的bean定义
       synchronized (mbd.postProcessingLock) {
          if (!mbd.postProcessed) {
             try {
                // 里面会调用MergedBeanDefinitionPostProcessor的实现类
                // 其也是BeanPostProcessor的一个子接口
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, 
                        beanName);
             }
             catch (Throwable ex) {
                throw new BeanCreationException();
             }
             mbd.postProcessed = true;
          }
       }
       // 三、快速缓存单例即使被BeanFactoryAware这样的生命周期接口触发
       // 以便能够解决循环引用，前提是该单例bean正在创建中
       boolean earlySingletonExposure = (mbd.isSingleton() && 
               this.allowCircularReferences &&
               isSingletonCurrentlyInCreation(beanName));
       if (earlySingletonExposure) {
          // 将bean缓存到singletonObjects等单例集合中
          // 大部分单例类都会调用到这里面，以便完成复杂的循环引用，当所有的
          // 实例被后续的流程初始化后，最终的单例将变成最终的形态
          addSingletonFactory(beanName, () -> 
                  getEarlyBeanReference(beanName, mbd, bean));
       }
       Object exposedObject = bean;
       // 四、对bean进行bean定义属性填充及执行一系列Spring初始化接口
       try {
          // 构造bean，这里面将会处理@Autowired和@Resource等操作bean成员属性
          // 的注解，也会分别调用setter方法去设置对应的值，等下会分析
          populateBean(beanName, mbd, instanceWrapper);
          // initializeBean方法将会执行工厂接口的回调，如aware系列接口、
          // InitializingBean接口、initMethod和BeanPostProcessor的接口调用
          // 这里调用BeanPostProcessor是真正的调用其接口after和before方法
          exposedObject = initializeBean(beanName, exposedObject, mbd);
       } catch (Throwable ex) {
          if (ex instanceof BeanCreationException && 
                  beanName.equals(((BeanCreationException) ex)
                          .getBeanName())) {
             throw (BeanCreationException) ex;
          } else {
             throw new BeanCreationException();
          }
       }
       // 五、判断单例对象是否造成了两次实例化导致单例对象出现不一致的现象
       // 如果前面的提前存储单例对象成立，则进入（一般来说会进入）
       if (earlySingletonExposure) {
          // 再次获得提前放入的bean对象
          Object earlySingletonReference = getSingleton(beanName, false);
          // 如果提前放入的bean对象引入不为空
          if (earlySingletonReference != null) {
             // 如果经过populateBean和initializeBean方法后bean引用没变
             // 则把早期的bean对象赋值给exposedObject对象
             if (exposedObject == bean) {
                exposedObject = earlySingletonReference;
             } else if (!this.allowRawInjectionDespiteWrapping && 
                     hasDependentBean(beanName)) {
                // 如果经过两个初始化方法bean引用变了，则说明其它的bean已经
                // 通过这两个方法实例化成功了单例bean，且两个单例bean不一致
                // 抛出异常
                String[] dependentBeans = getDependentBeans(beanName);
                Set actualDependentBeans = 
                        new LinkedHashSet<>(dependentBeans.length);
                for (String dependentBean : dependentBeans) {
                   if (!removeSingletonIfCreatedForTypeCheckOnly(
                           dependentBean)) {
                      actualDependentBeans.add(dependentBean);
                   }
                }
                if (!actualDependentBeans.isEmpty()) {
                   throw new BeanCurrentlyInCreationException();
                }
             }
          }
       }
       try {
          // 注册需要销毁的bean对象：实现了DisposableBean和AutoCloseable接口
          // 或者指明了destroy方法
          registerDisposableBeanIfNecessary(beanName, bean, mbd);
       } catch (BeanDefinitionValidationException ex) {
          throw new BeanCreationException();
       }
       // 返回暴露的bean对象
       return exposedObject;
    }
    protected void populateBean(String beanName, RootBeanDefinition mbd, 
            @Nullable BeanWrapper bw) {
       // 这个方法共可以分为四个部分
       // 该方法的主要作用便是使用bean定义属性值为BeanWrapper中的对象
       // 填充对应的值
       if (bw == null) {
          // 如果bean定义为空且属性值不为空则抛出异常，否则直接跳过该方法
          if (mbd.hasPropertyValues()) {
             throw new BeanCreationException();
          } else {
             return;
          }
       }
       // 一、根据InstantiationAwareBeanPostProcessor接口的
       // postProcessAfterInstantiation方法返回值判断是否
       // 继续执行填充bean对象属性
       boolean continueWithPropertyPopulation = true;
       if (!mbd.isSynthetic() && 
               hasInstantiationAwareBeanPostProcessors()) {
          for (BeanPostProcessor bp : getBeanPostProcessors()) {
             if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = 
                        (InstantiationAwareBeanPostProcessor) bp;
                // 根据其接口方法返回值判断要不要继续执行后面的填充流程
                if (!ibp.postProcessAfterInstantiation(bw
                        .getWrappedInstance(), beanName)) {
                   continueWithPropertyPopulation = false;
                   break;
                }
             }
          }
       }
       // 为false则直接跳过
       if (!continueWithPropertyPopulation) {
          return;
       }
       // 获取bean定义中的属性值
       PropertyValues pvs = (mbd.hasPropertyValues() ? 
               mbd.getPropertyValues() : null);
       // 二、判断bean的自动注入模式为AUTOWIRE_BY_NAME或AUTOWIRE_BY_TYPE
       // 一般都是使用默认的后续流程，只有特殊指定才会进入这两步，这两个
       // 方法的作用便是把当前的bean定义根据参数名字或者类型从bean工厂中
       // 获取对应的bean，并且保存到newPvs对象中，如mybatis的mapper便是
       // 使用type类型获取到sqlSessionTemplate和sqlSessionFactory两个bean的
       if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME || 
               mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
          MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
          // 根据autotowire的名称(如适用)添加属性值
          if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_NAME) {
             autowireByName(beanName, mbd, bw, newPvs);
          }
          // 根据自动装配的类型(如果适用)添加属性值
          if (mbd.getResolvedAutowireMode() == AUTOWIRE_BY_TYPE) {
             autowireByType(beanName, mbd, bw, newPvs);
          }
          pvs = newPvs;
       }
       // 判断是否有InstantiationAwareBeanPostProcessor接口，有为true
       boolean hasInstAwareBpps = 
               hasInstantiationAwareBeanPostProcessors();
       // 是否需要检查依赖，一般而言此值默认为false，暂时忽略
       boolean needsDepCheck = (mbd.getDependencyCheck() != 
               AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
       // 三、如果有InstantiationAwareBeanPostProcessor接口则进入
       PropertyDescriptor[] filteredPds = null;
       if (hasInstAwareBpps) {
          if (pvs == null) {
             pvs = mbd.getPropertyValues();
          }
          // 依次获取InstantiationAwareBeanPostProcessor接口调用其
          // postProcessProperties方法和postProcessPropertyValues方法
          // 并获得这两个方法的返回值，以便后续使用
          // 解析@Autowired注解并赋值便是在段方法中完成的，后面会分析
          for (BeanPostProcessor bp : getBeanPostProcessors()) {
             if (bp instanceof InstantiationAwareBeanPostProcessor) {
                InstantiationAwareBeanPostProcessor ibp = 
                        (InstantiationAwareBeanPostProcessor) bp;
                PropertyValues pvsToUse = ibp.postProcessProperties(pvs, 
                        bw.getWrappedInstance(), beanName);
                // 此方法流程已被官方删除，原来的流程实际调用的也是
                // postProcessProperties，因此这一段可以忽略
                if (pvsToUse == null) {
                   ...
                }
                pvs = pvsToUse;
             }
          }
       }
       // 略过
       if (needsDepCheck) {
          if (filteredPds == null) {
             filteredPds = filterPropertyDescriptorsForDependencyCheck(bw,
                     mbd.allowCaching);
          }
          checkDependencies(beanName, mbd, filteredPds, pvs);
       }
       // 四、如果返回的pvs不为空，则说明这些属性需要设置到BeanWrapper中
       if (pvs != null) {
          applyPropertyValues(beanName, mbd, bw, pvs);
       }
    }
    protected Object initializeBean(final String beanName, 
            final Object bean, @Nullable RootBeanDefinition mbd) {
       // 这个方法共可以分为四个部分
       // 一、调用invokeAwareMethods方法，从名字就可以看出来，这个方法是用来
       // 调用Aware系列接口，包括BeanNameAware、BeanClassLoaderAware和
       // BeanFactoryAware，System.getSecurityManager()语句只是为了判断当前
       // 系统有没有权限调用Aware接口
       if (System.getSecurityManager() != null) {
          AccessController.doPrivileged((PrivilegedAction