我们分析Spring的bean创建从DefaultListableBeanFactory 类开始，在Spring启动时，最终会调用DefaultListableBeanFactory.preInstantiateSingletons()方法来创建Spring bean。

  1. public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
  2.         implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
  3.     // ...省略代码
  5.     @Override
  6.     public void preInstantiateSingletons() throws BeansException {
  7.         if (logger.isTraceEnabled()) {
  8.             logger.trace("Pre-instantiating singletons in " + this);
  9.         }
  11.         // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  12.         // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  13.         List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  15.         // Trigger initialization of all non-lazy singleton beans...
  16.         // 循环所有非惰性（就是需要启动Spring容器就需要注册到IOC容器的bean）注册到IOC容器
  17.         for (String beanName : beanNames) {
  18.             RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  19.             if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  20.                 // 是FactoryBean类型的bean
  21.                 // FactoryBean类型的bean，在实例化bean变身后返回getObject()方法的值做为bean
  22.                 // 具体看FactoryBean 的介绍
  23.                 if (isFactoryBean(beanName)) {
  24.                     // FactoryBean类型的bean，bean的本身通过beanName加前缀&获取
  25.                     Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  26.                     if (bean instanceof FactoryBean) {
  27.                         final FactoryBean<?> factory = (FactoryBean<?>) bean;
  28.                         boolean isEagerInit;
  29.                         if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  30.                             isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
  31.                                             ((SmartFactoryBean<?>) factory)::isEagerInit,
  32.                                     getAccessControlContext());
  33.                         }
  34.                         else {
  35.                             isEagerInit = (factory instanceof SmartFactoryBean &&
  36.                                     ((SmartFactoryBean<?>) factory).isEagerInit());
  37.                         }
  38.                         if (isEagerInit) {
  39.                             getBean(beanName);
  40.                         }
  41.                     }
  42.                 }
  43.                 else {
  44.                     // 获取bean
  45.                     getBean(beanName);
  46.                 }
  47.             }
  48.         }
  50.         // 对SmartInitializingSingleton 类型的bean，在bean全部注册到IOC后进行回调
  51.         for (String beanName : beanNames) {
  52.             Object singletonInstance = getSingleton(beanName);
  53.             if (singletonInstance instanceof SmartInitializingSingleton) {
  54.                 final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  55.                 if (System.getSecurityManager() != null) {
  56.                     AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  57.                         smartSingleton.afterSingletonsInstantiated();
  58.                         return null;
  59.                     }, getAccessControlContext());
  60.                 }
  61.                 else {
  62.                     smartSingleton.afterSingletonsInstantiated();
  63.                 }
  64.             }
  65.         }
  66.     }
  68.     // ...省略代码
  69. }

preInstantiateSingletons()方法中最终会执行AbstractBeanFactory.doGetBean()方法来创建bean，接下来介绍doGetBean()方法的具体是怎么样创建出一个bean的。

  1. protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
  2.             @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
  4.     final String beanName = transformedBeanName(name);
  5.     Object bean;
  7.     // 因为对于Spring的单实例bean被正式创建成功后，会保存到缓存中，确保bean为一个单实例bean
  8.     // 所以先从缓存中获取Bean，如果缓存中有说明bean已经被创建了，直接返回
  9.     Object sharedInstance = getSingleton(beanName);
  10.     if (sharedInstance != null && args == null) {
  11.         if (logger.isTraceEnabled()) {
  12.             if (isSingletonCurrentlyInCreation(beanName)) {
  13.                 logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  14.                              "' that is not fully initialized yet - a consequence of a circular reference");
  15.             }
  16.             else {
  17.                 logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  18.             }
  19.         }
  20.         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  21.     }
  23.     else {
  24.         // Fail if we're already creating this bean instance:
  25.         // We're assumably within a circular reference.
  26.         // 校验bean是否在创建中，如果在创建中说明可能存在循环依赖
  27.         if (isPrototypeCurrentlyInCreation(beanName)) {
  28.             throw new BeanCurrentlyInCreationException(beanName);
  29.         }
  31.         // Check if bean definition exists in this factory.
  32.         BeanFactory parentBeanFactory = getParentBeanFactory();
  33.         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  34.             // Not found -> check parent.
  35.             String nameToLookup = originalBeanName(name);
  36.             if (parentBeanFactory instanceof AbstractBeanFactory) {
  37.                 return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  38.                     nameToLookup, requiredType, args, typeCheckOnly);
  39.             }
  40.             else if (args != null) {
  41.                 // Delegation to parent with explicit args.
  42.                 return (T) parentBeanFactory.getBean(nameToLookup, args);
  43.             }
  44.             else if (requiredType != null) {
  45.                 // No args -> delegate to standard getBean method.
  46.                 return parentBeanFactory.getBean(nameToLookup, requiredType);
  47.             }
  48.             else {
  49.                 return (T) parentBeanFactory.getBean(nameToLookup);
  50.             }
  51.         }
  53.         if (!typeCheckOnly) {
  54.             markBeanAsCreated(beanName);
  55.         }
  57.         try {
  58.             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  59.             checkMergedBeanDefinition(mbd, beanName, args);
  61.             // Guarantee initialization of beans that the current bean depends on.
  62.             String[] dependsOn = mbd.getDependsOn();
  63.             if (dependsOn != null) {
  64.                 for (String dep : dependsOn) {
  65.                     if (isDependent(beanName, dep)) {
  66.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  67.                                                         "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  68.                     }
  69.                     registerDependentBean(dep, beanName);
  70.                     try {
  71.                         getBean(dep);
  72.                     }
  73.                     catch (NoSuchBeanDefinitionException ex) {
  74.                         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  75.                                                         "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  76.                     }
  77.                 }
  78.             }
  80.             // Create bean instance.
  81.             if (mbd.isSingleton()) {
  82.                 // 获取单实例bean
  83.                 sharedInstance = getSingleton(beanName, () -> {
  84.                     try {
  85.                         // 创建bean
  86.                         return createBean(beanName, mbd, args);
  87.                     }
  88.                     catch (BeansException ex) {
  89.                         // Explicitly remove instance from singleton cache: It might have been put there
  90.                         // eagerly by the creation process, to allow for circular reference resolution.
  91.                         // Also remove any beans that received a temporary reference to the bean.
  92.                         destroySingleton(beanName);
  93.                         throw ex;
  94.                     }
  95.                 });
  96.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  97.             }
  99.             else if (mbd.isPrototype()) {
  100.                 // It's a prototype -> create a new instance.
  101.                 Object prototypeInstance = null;
  102.                 try {
  103.                     beforePrototypeCreation(beanName);
  104.                     prototypeInstance = createBean(beanName, mbd, args);
  105.                 }
  106.                 finally {
  107.                     afterPrototypeCreation(beanName);
  108.                 }
  109.                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  110.             }
  112.             else {
  113.                 String scopeName = mbd.getScope();
  114.                 final Scope scope = this.scopes.get(scopeName);
  115.                 if (scope == null) {
  116.                     throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  117.                 }
  118.                 try {
  119.                     Object scopedInstance = scope.get(beanName, () -> {
  120.                         beforePrototypeCreation(beanName);
  121.                         try {
  122.                             return createBean(beanName, mbd, args);
  123.                         }
  124.                         finally {
  125.                             afterPrototypeCreation(beanName);
  126.                         }
  127.                     });
  128.                     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  129.                 }
  130.                 catch (IllegalStateException ex) {
  131.                     throw new BeanCreationException(beanName,
  132.                                                     "Scope '" + scopeName + "' is not active for the current thread; consider " +
  133.                                                     "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  134.                                                     ex);
  135.                 }
  136.             }
  137.         }
  138.         catch (BeansException ex) {
  139.             cleanupAfterBeanCreationFailure(beanName);
  140.             throw ex;
  141.         }
  142.     }
  144.     // Check if required type matches the type of the actual bean instance.
  145.     if (requiredType != null && !requiredType.isInstance(bean)) {
  146.         try {
  147.             T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  148.             if (convertedBean == null) {
  149.                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  150.             }
  151.             return convertedBean;
  152.         }
  153.         catch (TypeMismatchException ex) {
  154.             if (logger.isTraceEnabled()) {
  155.                 logger.trace("Failed to convert bean '" + name + "' to required type '" +
  156.                              ClassUtils.getQualifiedName(requiredType) + "'", ex);
  157.             }
  158.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  159.         }
  160.     }
  161.     return (T) bean;
  162. }

1.缓存中获取Bean

为解决A类依赖B类，B类依赖A类这种依赖注入问题，Spring通过三级缓存解决。三级缓存其实就是三个Map对象，用来存放创建的bean，key为beanName，value为bean对象。最终创建出的完整bean会存在一级缓存singletonObjects中。
一级缓存：最终创建好的完整bean
二级缓存：只实例化，没有进行初始化、赋值的bean
三级缓存：一个ObjectFactory对象，bean在只实例化，没有进行初始化、赋值和增强（创建bean的代理）的时候就将bean的实例放到ObjectFactory中，当出现循环依赖时，从三级缓存中取出ObjectFactory，并调用getObject()回调方法，执行bean的代理创建，如果bean需要被代理

直接尝试从缓存获取或者singletonFactories中的获取ObjectFactory获取，检查缓存中或者实例工厂中是否有对应实例，因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，Spring创建bean的原则是不等bean创建完成就会创建bean的ObjectFactory对象提早曝光，也就是将ObjectFactory加入缓存中，一但下个bean创建的时候需要依赖上个bean则直接使用ObjectFactory对象注入

  1. @Nullable
  2. protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  3.     // 从一级缓存中查找bean
  4.     Object singletonObject = this.singletonObjects.get(beanName);
  5.     // 一级缓存中没有bean，并且当前bean正在创建中
  6.     if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  7.         // 锁主一级缓存
  8.         synchronized (this.singletonObjects) {
  9.             // 从二级缓存中查找bean
  10.             singletonObject = this.earlySingletonObjects.get(beanName);
  11.             // 二级缓存中没有bean，并且这是一个不健全的bean（只实例化）
  12.             if (singletonObject == null && allowEarlyReference) {
  13.                 // 三级缓存中查找
  14.                 ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  15.                 // 三级缓存中查找到ObjectFactory
  16.                 if (singletonFactory != null) {
  17.                     // 回调getObject()方法
  18.                     // 就是执行SmartInstantiationAwareBeanPostProcessor 类型的getEarlyBeanReference()方法
  19.                     // bean的代理对象创建会在这里创建
  20.                     // 有一个AbstractAutoProxyCreator类实现SmartInstantiationAwareBeanPostProcessor接口
  21.                     // 在getEarlyBeanReference()方法中创建bean的代理
  22.                     singletonObject = singletonFactory.getObject();
  23.                     // 一旦执行了ObjectFactory的回调方法getObject()，就把bean从三级缓存中移除，放到二级缓存中
  24.                     // 目的很简单，就是不要重复的回调ObjectFactory的getObject()方法
  25.                     // 以创建bean的代理为例，重复调用会重复创建代理
  26.                     this.earlySingletonObjects.put(beanName, singletonObject);
  27.                     // 从三级缓存中移除bean
  28.                     // 二级缓存和三级缓存是互斥的
  29.                     // 这句话的意思三级缓存中存在的bean不会在二级缓存中存在
  30.                     // 二级缓存中存在的bean不会在三级缓存中存在
  31.                     this.singletonFactories.remove(beanName);
  32.                 }
  33.             }
  34.         }
  35.     }
  36.     return singletonObject;
  37. }

2. 循环依赖校验

前面从三级缓存中查找bean，都没有找到，校验bean是否在创建中，如果在创建中说明此事存在循环依赖，抛出异常

  1. // bean在创建中，抛出正在创建中的异常
  2. if (isPrototypeCurrentlyInCreation(beanName)) {
  3.     throw new BeanCurrentlyInCreationException(beanName);
  4. }

查找bean是否在创建中

  1. protected boolean isPrototypeCurrentlyInCreation(String beanName) {
  2.     // 正在创建的bean实例，如果找到说明bean正在创建中
  3.     Object curVal = this.prototypesCurrentlyInCreation.get();
  4.     return (curVal != null &&
  5.             (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
  6. }

3. 检查bean的定义信息

先检查bean的定义信息有没有存在，如果没存在且有父类Beanfactory对象，那么父类工厂对象中创建bean

  1. // 当前bean的父类BeanFactory工厂对象
  2. BeanFactory parentBeanFactory = getParentBeanFactory();
  3. // 如果从没有找到bean的定义信息，从父类BeanFactory中创建bean
  4. if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  5.     // Not found -> check parent.
  6.     String nameToLookup = originalBeanName(name);
  7.     if (parentBeanFactory instanceof AbstractBeanFactory) {
  8.         return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  9.             nameToLookup, requiredType, args, typeCheckOnly);
  10.     }
  11.     else if (args != null) {
  12.         // Delegation to parent with explicit args.
  13.         return (T) parentBeanFactory.getBean(nameToLookup, args);
  14.     }
  15.     else if (requiredType != null) {
  16.         // No args -> delegate to standard getBean method.
  17.         return parentBeanFactory.getBean(nameToLookup, requiredType);
  18.     }
  19.     else {
  20.         return (T) parentBeanFactory.getBean(nameToLookup);
  21.     }
  22. }

从beanDefinitionMap 中查找bean的定义信息

  1. @Override
  2. public boolean containsBeanDefinition(String beanName) {
  3.     Assert.notNull(beanName, "Bean name must not be null");
  4.     return this.beanDefinitionMap.containsKey(beanName);
  5. }

4.合并bean的定义信息

5. 抽象类校验

如果是抽象类，不允许实例化抛出异常

  1. protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args)
  2.     throws BeanDefinitionStoreException {
  4.     if (mbd.isAbstract()) {
  5.         throw new BeanIsAbstractException(beanName);
  6.     }
  7. }

6.创建优先级高的Bean

所谓优先级高的bean是指在当前bean被创建之前，需要先被创建出来的bean

  1. // 当前bean创建之前需要被创建的beanName
  2. String[] dependsOn = mbd.getDependsOn();
  3. if (dependsOn != null) {
  4.     for (String dep : dependsOn) {
  5.         if (isDependent(beanName, dep)) {
  6.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  7.                                             "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  8.         }
  9.         registerDependentBean(dep, beanName);
  10.         try {
  11.             // 调用getBean 创建bean
  12.             getBean(dep);
  13.         }
  14.         catch (NoSuchBeanDefinitionException ex) {
  15.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  16.                                             "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  17.         }
  18.     }
  19. }

7. 获取单实例Bean

getSingleton()方法很简单，只干了四件事
第一：将bean加入到创建中的集合中，表示bean正在创建中
第二：调用创建bean方法
第三：bean成功创建后，将bean从创建中的集合中移除，表示bean不在创建中
第四：将创建完成的bean加入到singletonObjects缓存中，下一次获取该Bean时，直接从缓存中获取

  1. // 检查单实例Bean
  2. if (mbd.isSingleton()) {
  3.     // 获取单实例bean
  4.     sharedInstance = getSingleton(beanName, () -> {
  5.         try {
  6.             // 回调方法，创建bean
  7.             return createBean(beanName, mbd, args);
  8.         }
  9.         catch (BeansException ex) {
  10.             // Explicitly remove instance from singleton cache: It might have been put there
  11.             // eagerly by the creation process, to allow for circular reference resolution.
  12.             // Also remove any beans that received a temporary reference to the bean.
  13.             destroySingleton(beanName);
  14.             throw ex;
  15.         }
  16.     });
  17.     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  18. }

getSingletion()方法的作用是对Bean创建之前标识bean正在创建中，和bean创建之后移除bean正在创建中的标识，之后将bean加入到singtionObjects中

  1. public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  2.         Assert.notNull(beanName, "Bean name must not be null");
  3.         synchronized (this.singletonObjects) {
  4.             // 从缓存中获取bean
  5.             Object singletonObject = this.singletonObjects.get(beanName);
  6.             // 缓存中没有bean
  7.             if (singletonObject == null) {
  8.                 if (this.singletonsCurrentlyInDestruction) {
  9.                     throw new BeanCreationNotAllowedException(beanName,
  10.                             "Singleton bean creation not allowed while singletons of this factory are in destruction " +
  11.                             "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
  12.                 }
  13.                 if (logger.isDebugEnabled()) {
  14.                     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
  15.                 }
  16.                 // 将bean标识为正在创建中
  17.                 beforeSingletonCreation(beanName);
  18.                 boolean newSingleton = false;
  19.                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  20.                 if (recordSuppressedExceptions) {
  21.                     this.suppressedExceptions = new LinkedHashSet<>();
  22.                 }
  23.                 try {
  24.                     // 回调方法，执行createBean()方法创建bean
  25.                     singletonObject = singletonFactory.getObject();
  26.                     newSingleton = true;
  27.                 }
  28.                 catch (IllegalStateException ex) {
  29.                     // Has the singleton object implicitly appeared in the meantime ->
  30.                     // if yes, proceed with it since the exception indicates that state.
  31.                     singletonObject = this.singletonObjects.get(beanName);
  32.                     if (singletonObject == null) {
  33.                         throw ex;
  34.                     }
  35.                 }
  36.                 catch (BeanCreationException ex) {
  37.                     if (recordSuppressedExceptions) {
  38.                         for (Exception suppressedException : this.suppressedExceptions) {
  39.                             ex.addRelatedCause(suppressedException);
  40.                         }
  41.                     }
  42.                     throw ex;
  43.                 }
  44.                 finally {
  45.                     if (recordSuppressedExceptions) {
  46.                         this.suppressedExceptions = null;
  47.                     }
  48.                     // bean创建完之后，移除bean正在创建中的标识
  49.                     afterSingletonCreation(beanName);
  50.                 }
  51.                 if (newSingleton) {
  52.                     // 将bean 加入到singletonObjects Map缓存中
  53.                     addSingleton(beanName, singletonObject);
  54.                 }
  55.             }
  56.             return singletonObject;
  57.         }
  58.     }

8. 正式创建Bean

  1. protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  2.             throws BeanCreationException {
  4.     if (logger.isTraceEnabled()) {
  5.         logger.trace("Creating instance of bean '" + beanName + "'");
  6.     }
  7.     RootBeanDefinition mbdToUse = mbd;
  9.     // Make sure bean class is actually resolved at this point, and
  10.     // clone the bean definition in case of a dynamically resolved Class
  11.     // which cannot be stored in the shared merged bean definition.
  12.     Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  13.     if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  14.         mbdToUse = new RootBeanDefinition(mbd);
  15.         mbdToUse.setBeanClass(resolvedClass);
  16.     }
  18.     // Prepare method overrides.
  19.     try {
  20.         mbdToUse.prepareMethodOverrides();
  21.     }
  22.     catch (BeanDefinitionValidationException ex) {
  23.         throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  24.                                                beanName, "Validation of method overrides failed", ex);
  25.     }
  27.     try {
  28.         // 先给后置处理器一个机会，通过后置处理器创建bean
  29.         Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  30.         // 后置处理器创建了bean，直接返回
  31.         if (bean != null) {
  32.             return bean;
  33.         }
  34.     }
  35.     catch (Throwable ex) {
  36.         throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
  37.                                         "BeanPostProcessor before instantiation of bean failed", ex);
  38.     }
  40.     try {
  41.         //bean 创建bean的核心逻辑
  42.         Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  43.         if (logger.isTraceEnabled()) {
  44.             logger.trace("Finished creating instance of bean '" + beanName + "'");
  45.         }
  46.         return beanInstance;
  47.     }
  48.     catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
  49.         // A previously detected exception with proper bean creation context already,
  50.         // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
  51.         throw ex;
  52.     }
  53.     catch (Throwable ex) {
  54.         throw new BeanCreationException(
  55.             mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  56.     }
  57. }

8.1. 实例化前后置处理器创建Bean

  1. protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
  2.         Object bean = null;
  3.     if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
  4.         // Make sure bean class is actually resolved at this point.
  5.         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  6.             Class<?> targetType = determineTargetType(beanName, mbd);
  7.             if (targetType != null) {
  8.                 // 执行后置处理器的before方法
  9.                 bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
  10.                 // 执行后置处理器的after方法
  11.                 if (bean != null) {
  12.                     bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
  13.                 }
  14.             }
  15.         }
  16.         mbd.beforeInstantiationResolved = (bean != null);
  17.     }
  18.     return bean;
  19. }

执行InstantiationAwareBeanPostProcessor 类型的后置处理器
InstantiationAwareBeanPostProcessor 典型的有创建Bean的动态代理后置处理器AbstractAdvisorAutoProxyCreator类，该类会对需要代理的类创建相应的动态代理对象

  1. @Nullable
  2. protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
  3.     // 循环所有BeanPostProcessor后置处理器
  4.     for (BeanPostProcessor bp : getBeanPostProcessors()) {
  5.         // 只处理InstantiationAwareBeanPostProcessor类型的后置处理器
  6.         if (bp instanceof InstantiationAwareBeanPostProcessor) {
  7.             InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  8.             // 执行后置处理器before方法
  9.             Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
  10.             if (result != null) {
  11.                 return result;
  12.             }
  13.         }
  14.     }
  15.     return null;
  16. }

如果bean被创建，执行后置处理器的after方法，Spring中的规则是在bean的初始化后尽可能保证将注册的后置处理器postProcessAfterInitialization()方法应用到该bean中，因为如果在实例化前置处理器中的bean不为空，那么便不会再次经历普通的bean创建过程，所以只能在这里应用后置处理器的postProcessAfterInitialization()方法

调用BeanPostProcessor类型的postProcessAfterInitialization()方法

  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. }

8.2. 创建bean核心

  1. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
  2.             throws BeanCreationException {
  4.     // Instantiate the bean.
  5.     BeanWrapper instanceWrapper = null;
  6.     if (mbd.isSingleton()) {
  7.         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
  8.     }
  9.     if (instanceWrapper == null) {
  10.         // 实例化bean
  11.         instanceWrapper = createBeanInstance(beanName, mbd, args);
  12.     }
  13.     final Object bean = instanceWrapper.getWrappedInstance();
  14.     Class<?> beanType = instanceWrapper.getWrappedClass();
  15.     if (beanType != NullBean.class) {
  16.         mbd.resolvedTargetType = beanType;
  17.     }
  19.     // Allow post-processors to modify the merged bean definition.
  20.     synchronized (mbd.postProcessingLock) {
  21.         if (!mbd.postProcessed) {
  22.             try {
  23.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  24.             }
  25.             catch (Throwable ex) {
  26.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  27.                                                 "Post-processing of merged bean definition failed", ex);
  28.             }
  29.             mbd.postProcessed = true;
  30.         }
  31.     }
  33.     // Eagerly cache singletons to be able to resolve circular references
  34.     // even when triggered by lifecycle interfaces like BeanFactoryAware.
  35.     boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  36.                                       isSingletonCurrentlyInCreation(beanName));
  37.     if (earlySingletonExposure) {
  38.         if (logger.isTraceEnabled()) {
  39.             logger.trace("Eagerly caching bean '" + beanName +
  40.                          "' to allow for resolving potential circular references");
  41.         }
  42.         // bean实例化后，提早将bean放到三级缓存singletonFactories中
  43.         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  44.     }
  46.     // Initialize the bean instance.
  47.     Object exposedObject = bean;
  48.     try {
  49.         // 属性赋值
  50.         populateBean(beanName, mbd, instanceWrapper);
  51.         // 初始化bean
  52.         exposedObject = initializeBean(beanName, exposedObject, mbd);
  53.     }
  54.     catch (Throwable ex) {
  55.         if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
  56.             throw (BeanCreationException) ex;
  57.         }
  58.         else {
  59.             throw new BeanCreationException(
  60.                 mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
  61.         }
  62.     }
  64.     if (earlySingletonExposure) {
  65.         Object earlySingletonReference = getSingleton(beanName, false);
  66.         if (earlySingletonReference != null) {
  67.             if (exposedObject == bean) {
  68.                 exposedObject = earlySingletonReference;
  69.             }
  70.             else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  71.                 String[] dependentBeans = getDependentBeans(beanName);
  72.                 Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  73.                 for (String dependentBean : dependentBeans) {
  74.                     if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  75.                         actualDependentBeans.add(dependentBean);
  76.                     }
  77.                 }
  78.                 if (!actualDependentBeans.isEmpty()) {
  79.                     throw new BeanCurrentlyInCreationException(beanName,
  80.                                                                "Bean with name '" + beanName + "' has been injected into other beans [" +
  81.                                                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  82.                                                                "] in its raw version as part of a circular reference, but has eventually been " +
  83.                                                                "wrapped. This means that said other beans do not use the final version of the " +
  84.                                                                "bean. This is often the result of over-eager type matching - consider using " +
  85.                                                                "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
  86.                 }
  87.             }
  88.         }
  89.     }
  91.     // Register bean as disposable.
  92.     try {
  93.         registerDisposableBeanIfNecessary(beanName, bean, mbd);
  94.     }
  95.     catch (BeanDefinitionValidationException ex) {
  96.         throw new BeanCreationException(
  97.             mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  98.     }
  100.     return exposedObject;
  101. }

8.2.1. 实例化bean

  1. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
  2.     // 解析bean 的class
  3.     Class<?> beanClass = resolveBeanClass(mbd, beanName);
  5.     if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  6.         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  7.                                         "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
  8.     }
  10.     Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
  11.     if (instanceSupplier != null) {
  12.         return obtainFromSupplier(instanceSupplier, beanName);
  13.     }
  15.     // 使用工厂方法实例化bean
  16.     if (mbd.getFactoryMethodName() != null) {
  17.         return instantiateUsingFactoryMethod(beanName, mbd, args);
  18.     }
  20.     // Shortcut when re-creating the same bean...
  21.     boolean resolved = false;
  22.     boolean autowireNecessary = false;
  23.     if (args == null) {
  24.         synchronized (mbd.constructorArgumentLock) {
  25.             if (mbd.resolvedConstructorOrFactoryMethod != null) {
  26.                 resolved = true;
  27.                 autowireNecessary = mbd.constructorArgumentsResolved;
  28.             }
  29.         }
  30.     }
  31.     if (resolved) {
  32.         if (autowireNecessary) {
  33.             // 使用非默认构造函数实例化bean
  34.             return autowireConstructor(beanName, mbd, null, null);
  35.         }
  36.         else {
  37.             // 使用默认构造函数实例化bean
  38.             return instantiateBean(beanName, mbd);
  39.         }
  40.     }
  42.     // 根据参数解析，决定使用哪个构造函数实例化bean
  43.     Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  44.     if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
  45.         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
  46.         return autowireConstructor(beanName, mbd, ctors, args);
  47.     }
  49.     // Preferred constructors for default construction?
  50.     ctors = mbd.getPreferredConstructors();
  51.     if (ctors != null) {
  52.         return autowireConstructor(beanName, mbd, ctors, null);
  53.     }
  55.     // No special handling: simply use no-arg constructor.
  56.     return instantiateBean(beanName, mbd);
  57. }

8.2.2. 提早曝光Bean

为了解决循环依赖问题，提早将bean曝光（这个bean还是一个没有任何属性填充的bean，就是一个只实例化但还没有对bean中的属性赋值），添加到addSingletonFactory中，后面如果有执行getBean()循环依赖该bean时，会先从singletonFactory中获取bean直接返回，从而中断后面的populateBean()方法，就不会再次执行getBean(),这样就解决了循环依赖

  1. boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  2.                 isSingletonCurrentlyInCreation(beanName));
  3. if (earlySingletonExposure) {
  4.     if (logger.isTraceEnabled()) {
  5.         logger.trace("Eagerly caching bean '" + beanName +
  6.                      "' to allow for resolving potential circular references");
  7.     }
  8.     // bean实例化后，将ObjectFactory对象放到缓存中，这个ObjectFactory提供一个回调方法getObject()
  9.     // 此时如果有循环依赖，创建另一个bean时会回调getObject()方法
  10.     addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  11. }

ObjectFactory回调方法getObject()，只执行SmartInstantiationAwareBeanPostProcessor类型，典型的有AbstractAutoProxyCreator类创建bean的代理对象

  1. protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
  2.     Object exposedObject = bean;
  3.     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  4.         for (BeanPostProcessor bp : getBeanPostProcessors()) {
  5.             if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
  6.                 SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
  7.                 exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
  8.             }
  9.         }
  10.     }
  11.     return exposedObject;
  12. }

8.2.3. 属性填充

对bean的熟悉进行填充，将各个属性值注入，其中可能存在依赖于其他bean的属性，则会递归初始依赖bean，即调用getBean()方法

  1. protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
  2.     if (bw == null) {
  3.         if (mbd.hasPropertyValues()) {
  4.             throw new BeanCreationException(
  5.                 mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
  6.         }
  7.         else {
  8.             // Skip property population phase for null instance.
  9.             return;
  10.         }
  11.     }
  13.     // 执行bean实例化后的后置处理器
  14.     // 执行InstantiationAwareBeanPostProcessor类型中的postProcessAfterInstantiation()方法
  15.     // 如果postProcessAfterInstantiation()方法返回false就终止后续的执行，既属性注入执行，可以用来控制程序是否继续进行属性填充
  16.     if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  17.         for (BeanPostProcessor bp : getBeanPostProcessors()) {
  18.             if (bp instanceof InstantiationAwareBeanPostProcessor) {
  19.                 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  20.                 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
  21.                     return;
  22.                 }
  23.             }
  24.         }
  25.     }
  27.     PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
  29.     int resolvedAutowireMode = mbd.getResolvedAutowireMode();
  30.     if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  31.         MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  32.         // Add property values based on autowire by name if applicable.
  33.         if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
  34.             autowireByName(beanName, mbd, bw, newPvs);
  35.         }
  36.         // Add property values based on autowire by type if applicable.
  37.         if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  38.             autowireByType(beanName, mbd, bw, newPvs);
  39.         }
  40.         pvs = newPvs;
  41.     }
  43.     boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
  44.     boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
  46.     PropertyDescriptor[] filteredPds = null;
  47.     if (hasInstAwareBpps) {
  48.         if (pvs == null) {
  49.             pvs = mbd.getPropertyValues();
  50.         }
  51.         for (BeanPostProcessor bp : getBeanPostProcessors()) {
  52.             if (bp instanceof InstantiationAwareBeanPostProcessor) {
  53.                 InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  54.                 PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
  55.                 if (pvsToUse == null) {
  56.                     if (filteredPds == null) {
  57.                         filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  58.                     }
  59.                     pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
  60.                     if (pvsToUse == null) {
  61.                         return;
  62.                     }
  63.                 }
  64.                 pvs = pvsToUse;
  65.             }
  66.         }
  67.     }
  68.     if (needsDepCheck) {
  69.         if (filteredPds == null) {
  70.             filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  71.         }
  72.         checkDependencies(beanName, mbd, filteredPds, pvs);
  73.     }
  75.     if (pvs != null) {
  76.         applyPropertyValues(beanName, mbd, bw, pvs);
  77.     }
  78. }

8.2.3.1. 实例化后的后置处理器

执行InstantiationAwareBeanPostProcessor类型中的postProcessAfterInstantiation()方法，如果postProcessAfterInstantiation()方法返回false就终止后续的执行，既属性注入执行，可以用来控制程序是否继续进行属性填充

  1. if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  2.     for (BeanPostProcessor bp : getBeanPostProcessors()) {
  3.         if (bp instanceof InstantiationAwareBeanPostProcessor) {
  4.             InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  5.             if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
  6.                 return;
  7.             }
  8.         }
  9.     }
  10. }

8.2.3.2. 按名称注入属性

  1. protected void autowireByName(
  2.             String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
  3.         // 获取bean 被注入的属性
  4.         String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
  5.         for (String propertyName : propertyNames) {
  6.             // beanName 存在BeanDefinition信息
  7.             if (containsBean(propertyName)) {
  8.                 // 调用getBean创建bean
  9.                 Object bean = getBean(propertyName);
  10.                 pvs.add(propertyName, bean);
  11.                 registerDependentBean(propertyName, beanName);
  12.                 if (logger.isTraceEnabled()) {
  13.                     logger.trace("Added autowiring by name from bean name '" + beanName +
  14.                             "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
  15.                 }
  16.             }
  17.             else {
  18.                 if (logger.isTraceEnabled()) {
  19.                     logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
  20.                             "' by name: no matching bean found");
  21.                 }
  22.             }
  23.         }
  24.     }

8.2.3.3. 按类型输入属性

  1. protected void autowireByType(
  2.             String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
  4.     TypeConverter converter = getCustomTypeConverter();
  5.     if (converter == null) {
  6.         converter = bw;
  7.     }
  9.     Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
  10.     // 获取所有属性名称
  11.     String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
  12.     for (String propertyName : propertyNames) {
  13.         try {
  14.             PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
  15.             // Don't try autowiring by type for type Object: never makes sense,
  16.             // even if it technically is a unsatisfied, non-simple property.
  17.             if (Object.class != pd.getPropertyType()) {
  18.                 MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
  19.                 // Do not allow eager init for type matching in case of a prioritized post-processor.
  20.                 boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
  21.                 DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
  22.                 Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
  23.                 if (autowiredArgument != null) {
  24.                     pvs.add(propertyName, autowiredArgument);
  25.                 }
  26.                 for (String autowiredBeanName : autowiredBeanNames) {
  27.                     registerDependentBean(autowiredBeanName, beanName);
  28.                     if (logger.isTraceEnabled()) {
  29.                         logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
  30.                                      propertyName + "' to bean named '" + autowiredBeanName + "'");
  31.                     }
  32.                 }
  33.                 autowiredBeanNames.clear();
  34.             }
  35.         }
  36.         catch (BeansException ex) {
  37.             throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
  38.         }
  39.     }
  40. }

8.2.3.4. 执行postProcessPropertyValues()

对属性真正应用到bean上前执行InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法。
典型应用是可以扩展RequiredAnnotationBeanPostProcessor类中对属性验证

  1. if (hasInstAwareBpps) {
  2.     if (pvs == null) {
  3.         pvs = mbd.getPropertyValues();
  4.     }
  5.     for (BeanPostProcessor bp : getBeanPostProcessors()) {
  6.         if (bp instanceof InstantiationAwareBeanPostProcessor) {
  7.             // 执行InstantiationAwareBeanPostProcessor 类型中的postProcessPropertyValues()方法
  8.             InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
  9.             PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
  10.             if (pvsToUse == null) {
  11.                 if (filteredPds == null) {
  12.                     filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  13.                 }
  14.                 pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
  15.                 if (pvsToUse == null) {
  16.                     return;
  17.                 }
  18.             }
  19.             pvs = pvsToUse;
  20.         }
  21.     }
  22. }

8.2.3.5. 将属性应用到Bean中

将属性从PropertyValues应用到bean中

  1. protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
  2.     if (pvs.isEmpty()) {
  3.         return;
  4.     }
  6.     if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
  7.         ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
  8.     }
  10.     MutablePropertyValues mpvs = null;
  11.     List<PropertyValue> original;
  13.     if (pvs instanceof MutablePropertyValues) {
  14.         mpvs = (MutablePropertyValues) pvs;
  15.         if (mpvs.isConverted()) {
  16.             // Shortcut: use the pre-converted values as-is.
  17.             try {
  18.                 bw.setPropertyValues(mpvs);
  19.                 return;
  20.             }
  21.             catch (BeansException ex) {
  22.                 throw new BeanCreationException(
  23.                     mbd.getResourceDescription(), beanName, "Error setting property values", ex);
  24.             }
  25.         }
  26.         original = mpvs.getPropertyValueList();
  27.     }
  28.     else {
  29.         original = Arrays.asList(pvs.getPropertyValues());
  30.     }
  32.     TypeConverter converter = getCustomTypeConverter();
  33.     if (converter == null) {
  34.         converter = bw;
  35.     }
  36.     BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
  38.     // Create a deep copy, resolving any references for values.
  39.     List<PropertyValue> deepCopy = new ArrayList<>(original.size());
  40.     boolean resolveNecessary = false;
  41.     for (PropertyValue pv : original) {
  42.         if (pv.isConverted()) {
  43.             deepCopy.add(pv);
  44.         }
  45.         else {
  46.             String propertyName = pv.getName();
  47.             Object originalValue = pv.getValue();
  48.             if (originalValue == AutowiredPropertyMarker.INSTANCE) {
  49.                 Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
  50.                 if (writeMethod == null) {
  51.                     throw new IllegalArgumentException("Autowire marker for property without write method: " + pv);
  52.                 }
  53.                 originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
  54.             }
  55.             Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
  56.             Object convertedValue = resolvedValue;
  57.             boolean convertible = bw.isWritableProperty(propertyName) &&
  58.                 !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
  59.             if (convertible) {
  60.                 convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
  61.             }
  62.             // Possibly store converted value in merged bean definition,
  63.             // in order to avoid re-conversion for every created bean instance.
  64.             if (resolvedValue == originalValue) {
  65.                 if (convertible) {
  66.                     pv.setConvertedValue(convertedValue);
  67.                 }
  68.                 deepCopy.add(pv);
  69.             }
  70.             else if (convertible && originalValue instanceof TypedStringValue &&
  71.                      !((TypedStringValue) originalValue).isDynamic() &&
  72.                      !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
  73.                 pv.setConvertedValue(convertedValue);
  74.                 deepCopy.add(pv);
  75.             }
  76.             else {
  77.                 resolveNecessary = true;
  78.                 deepCopy.add(new PropertyValue(pv, convertedValue));
  79.             }
  80.         }
  81.     }
  82.     if (mpvs != null && !resolveNecessary) {
  83.         mpvs.setConverted();
  84.     }
  86.     // Set our (possibly massaged) deep copy.
  87.     try {
  88.         bw.setPropertyValues(new MutablePropertyValues(deepCopy));
  89.     }
  90.     catch (BeansException ex) {
  91.         throw new BeanCreationException(
  92.             mbd.getResourceDescription(), beanName, "Error setting property values", ex);
  93.     }
  94. }

8.2.4. 初始化Bean

初始化bean这里是当bean的属性赋值完成后，执行bean的初始化方法，在执行初始化方法之前，会先执行各种Aware接口的子类方法。

  1. protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
  2.     if (System.getSecurityManager() != null) {
  3.         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  4.             // 执行Aware 接口的子类方法
  5.             invokeAwareMethods(beanName, bean);
  6.             return null;
  7.         }, getAccessControlContext());
  8.     }
  9.     else {
  10.         // 执行Aware 接口的子类方法
  11.         invokeAwareMethods(beanName, bean);
  12.     }
  14.     Object wrappedBean = bean;
  15.     if (mbd == null || !mbd.isSynthetic()) {
  16.         // 初始化方法前，执行初始化后置处理器before()方法
  17.         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  18.     }
  20.     try {
  21.         // 执行初始化方法
  22.         invokeInitMethods(beanName, wrappedBean, mbd);
  23.     }
  24.     catch (Throwable ex) {
  25.         throw new BeanCreationException(
  26.             (mbd != null ? mbd.getResourceDescription() : null),
  27.             beanName, "Invocation of init method failed", ex);
  28.     }
  29.     if (mbd == null || !mbd.isSynthetic()) {
  30.         // 初始化方法后，执行初始化后置处理器after()方法
  31.         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  32.     }
  34.     return wrappedBean;
  35. }

8.2.4.1. 执行Aware

先执行BeanNameAwar、BeanClassLoaderAware、BeanFactoryAware 三类Aware子类的对应方法，可以通过实现这些类型的Aware接口，在执行bean的初始化方法之前做些扩展

  1. private void invokeAwareMethods(final String beanName, final Object bean) {
  2.     if (bean instanceof Aware) {
  3.         if (bean instanceof BeanNameAware) {
  4.             ((BeanNameAware) bean).setBeanName(beanName);
  5.         }
  6.         if (bean instanceof BeanClassLoaderAware) {
  7.             ClassLoader bcl = getBeanClassLoader();
  8.             if (bcl != null) {
  9.                 ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
  10.             }
  11.         }
  12.         if (bean instanceof BeanFactoryAware) {
  13.             ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
  14.         }
  15.     }
  16. }

8.2.4.2. 初始化之前后置处理器

在执行bean的初始化方法之前，先执行初始化后置处理器before()方法，典型的应用是ApplicationContextAwareProcessor后置处理器，用于在执行bean的初始化方法之前，执行EnvironmentAware、EmbeddedValueResolverAware、ResourceLoaderAware、ApplicationEventPublisherAware、MessageSourceAware、ApplicationContextAware 这些Aware

  1. if (mbd == null || !mbd.isSynthetic()) {
  2.     wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  3. }

执行BeanPostProcessor后置处理器的before方法

  1. public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
  2.     throws BeansException {
  4.     Object result = existingBean;
  5.     // 执行所有BeanPostProcess后置处理器的postProcessBeforeInitialization()方法
  6.     for (BeanPostProcessor processor : getBeanPostProcessors()) {
  7.         Object current = processor.postProcessBeforeInitialization(result, beanName);
  8.         if (current == null) {
  9.             return result;
  10.         }
  11.         result = current;
  12.     }
  13.     return result;
  14. }

8.2.4.3. 执行初始化方法

bean的初始化方法分两类，一类是实现InitializingBean接口的bean，执行afterPropertiesSet()方法，一类是自定义的初始化方法，通过反射执行。

  1. protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
  2.     throws Throwable {
  3.     // 执行InitializingBean类型的bean的初始化方法afterPropertiesSet()
  4.     boolean isInitializingBean = (bean instanceof InitializingBean);
  5.     if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
  6.         if (logger.isTraceEnabled()) {
  7.             logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
  8.         }
  9.         if (System.getSecurityManager() != null) {
  10.             try {
  11.                 AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
  12.                     ((InitializingBean) bean).afterPropertiesSet();
  13.                     return null;
  14.                 }, getAccessControlContext());
  15.             }
  16.             catch (PrivilegedActionException pae) {
  17.                 throw pae.getException();
  18.             }
  19.         }
  20.         else {
  21.             ((InitializingBean) bean).afterPropertiesSet();
  22.         }
  23.     }
  25.     // 执行自定义初始化方法，反射执行
  26.     if (mbd != null && bean.getClass() != NullBean.class) {
  27.         String initMethodName = mbd.getInitMethodName();
  28.         if (StringUtils.hasLength(initMethodName) &&
  29.             !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
  30.             !mbd.isExternallyManagedInitMethod(initMethodName)) {
  31.             invokeCustomInitMethod(beanName, bean, mbd);
  32.         }
  33.     }
  34. }

8.2.4.4. 初始化方法之后后置处理器

执行初始化方法之后，调用BeanPostProcessor的postProcessAfterInitialization()方法来扩展业务需求

  1. if (mbd == null || !mbd.isSynthetic()) {
  2.     wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  3. }

执行BeanPostProcessor后置处理器的after方法

  1. @Override
  2. public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
  3.     throws BeansException {
  5.     Object result = existingBean;
  6.     // 执行所有BeanPostProcessor后置处理器的postProcessAfterInitialization()方法
  7.     for (BeanPostProcessor processor : getBeanPostProcessors()) {
  8.         Object current = processor.postProcessAfterInitialization(result, beanName);
  9.         if (current == null) {
  10.             return result;
  11.         }
  12.         result = current;
  13.     }
  14.     return result;
  15. }

9. BeanFactory类型的bean

对于是BeanFactory类型的bean，我们在创建bean之后，不是直接返回bean的信息，而是返回getObject()方法的返回值。这样做的目的是为bean提供扩展，如：MyBatis 和Spring的整合，MyBatis的接口其实是不能实例化的，我们将接口转换为一个Bean，最后调用BeanFactory方法的getObject()方法返回接口的代理对象

  1. protected Object getObjectForBeanInstance(
  2.             Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
  4.     // 对于FactoryBean类型的，获取他的原型是在beanName前加&
  5.     // 校验是获取FactoryBean类型的原型bean
  6.     if (BeanFactoryUtils.isFactoryDereference(name)) {
  7.         if (beanInstance instanceof NullBean) {
  8.             return beanInstance;
  9.         }
  10.         if (!(beanInstance instanceof FactoryBean)) {
  11.             throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
  12.         }
  13.         if (mbd != null) {
  14.             mbd.isFactoryBean = true;
  15.         }
  16.         return beanInstance;
  17.     }
  19.     // 不是FactoryBean的bean直接返回
  20.     if (!(beanInstance instanceof FactoryBean)) {
  21.         return beanInstance;
  22.     }
  24.     Object object = null;
  25.     if (mbd != null) {
  26.         mbd.isFactoryBean = true;
  27.     }
  28.     else {
  29.         // 从缓存中获取bean
  30.         object = getCachedObjectForFactoryBean(beanName);
  31.     }
  32.     // 缓存中为空调用getObject()方法
  33.     if (object == null) {
  34.         // Return bean instance from factory.
  35.         FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
  36.         // Caches object obtained from FactoryBean if it is a singleton.
  37.         if (mbd == null && containsBeanDefinition(beanName)) {
  38.             mbd = getMergedLocalBeanDefinition(beanName);
  39.         }
  40.         boolean synthetic = (mbd != null && mbd.isSynthetic());
  41.         // 调用getObject()方法获取bean
  42.         object = getObjectFromFactoryBean(factory, beanName, !synthetic);
  43.     }
  44.     return object;
  45. }