主干流程

beanFactory.preInstantiateSingletons();

  1. @Override
  2. public void preInstantiateSingletons() throws BeansException {
  3.     if (logger.isTraceEnabled()) {
  4.         logger.trace("Pre-instantiating singletons in " + this);
  5.     }
  7.     // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  8.     // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  9.     // 拷贝一份bean
  10.     List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  12.     // Trigger initialization of all non-lazy singleton beans...
  13.     for (String beanName : beanNames) {
  14.         // 取bean的元数据,这里有个合并的动作
  15.         RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  16.         // 处理非抽象，并且是单例，非懒加载的bean
  17.         if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  18.             if (isFactoryBean(beanName)) {
  19.                 // 工厂bean
  20.                 Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  21.                 if (bean instanceof FactoryBean) {
  22.                     FactoryBean<?> factory = (FactoryBean<?>) bean;
  23.                     boolean isEagerInit;
  24.                     // 如果是SmartFactoryBean的实例
  25.                     if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  26.                         // 安全检查
  27.                         isEagerInit = AccessController.doPrivileged(
  28.                                 (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  29.                                 getAccessControlContext());
  30.                     }
  31.                     else {
  32.                         isEagerInit = (factory instanceof SmartFactoryBean &&
  33.                                 ((SmartFactoryBean<?>) factory).isEagerInit());
  34.                     }
  35.                     if (isEagerInit) {
  36.                         getBean(beanName);
  37.                     }
  38.                 }
  39.             }
  40.             else {
  41.                 // 其他的bean
  42.                 getBean(beanName);
  43.             }
  44.         }
  45.     }
  47.     // bean 创建后的回调
  48.     // Trigger post-initialization callback for all applicable beans...
  49.     for (String beanName : beanNames) {
  50.         Object singletonInstance = getSingleton(beanName);
  51.         if (singletonInstance instanceof SmartInitializingSingleton) {
  52.             SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
  53.             if (System.getSecurityManager() != null) {
  54.                 AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  55.                     smartSingleton.afterSingletonsInstantiated();
  56.                     return null;
  57.                 }, getAccessControlContext());
  58.             }
  59.             else {
  60.                 smartSingleton.afterSingletonsInstantiated();
  61.             }
  62.         }
  63.     }
  64. }

片段：合并 bean 定义

getMergedLocalBeanDefinition 合并操作。将 BeanDefinition转换成 RootBeanDefinition。

  • 如果 Abean extends Object ，那么 RootBeanDefinition 就是 Abean 本身的 BeanDefinition；
  • 如果 Abean extends Bbean，那么就需要合并 Abean 和 Bean 的BeanDefinition。

spring-context | org.springframework.beans.factory.support.AbstractBeanFactory#getMergedLocalBeanDefinition

  1. protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
  2.     // Quick check on the concurrent map first, with minimal locking.
  3.     // 检查下缓存，有的话，并且不需要合并的直接返回
  4.     RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
  5.     if (mbd != null && !mbd.stale) {
  6.         return mbd;
  7.     }
  8.     return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
  9. }

调用 getMergedBeanDefinition

  1. protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
  2.             throws BeanDefinitionStoreException {
  4.         return getMergedBeanDefinition(beanName, bd, null);
  5. }

重载的方法

  1. protected RootBeanDefinition getMergedBeanDefinition(
  2.         String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
  3.         throws BeanDefinitionStoreException {
  4.     // ConcurrentHashMap 内部是线程安全的，但是把单个操作组合起来不一定是安全的。比如 map.put(key,value++)。
  5.     synchronized (this.mergedBeanDefinitions) {
  6.         RootBeanDefinition mbd = null;
  7.         RootBeanDefinition previous = null;
  9.         // Check with full lock now in order to enforce the same merged instance.
  10.         if (containingBd == null) {
  11.             mbd = this.mergedBeanDefinitions.get(beanName);
  12.         }
  14.         if (mbd == null || mbd.stale) {
  15.             previous = mbd;
  16.             if (bd.getParentName() == null) {
  17.                 // Use copy of given root bean definition.
  18.                 if (bd instanceof RootBeanDefinition) {
  19.                     mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
  20.                 }
  21.                 else {
  22.                     mbd = new RootBeanDefinition(bd);
  23.                 }
  24.             }
  25.             else {
  26.                 // Child bean definition: needs to be merged with parent.
  27.                 BeanDefinition pbd;
  28.                 try {
  29.                     String parentBeanName = transformedBeanName(bd.getParentName());
  30.                     if (!beanName.equals(parentBeanName)) {
  31.                         pbd = getMergedBeanDefinition(parentBeanName);
  32.                     }
  33.                     else {
  34.                         BeanFactory parent = getParentBeanFactory();
  35.                         if (parent instanceof ConfigurableBeanFactory) {
  36.                             pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
  37.                         }
  38.                         else {
  39.                             throw new NoSuchBeanDefinitionException(parentBeanName,
  40.                                     "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
  41.                                     "': cannot be resolved without a ConfigurableBeanFactory parent");
  42.                         }
  43.                     }
  44.                 }
  45.                 catch (NoSuchBeanDefinitionException ex) {
  46.                     throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
  47.                             "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
  48.                 }
  49.                 // Deep copy with overridden values.
  50.                 mbd = new RootBeanDefinition(pbd);
  51.                 mbd.overrideFrom(bd);
  52.             }
  54.             // Set default singleton scope, if not configured before.
  55.             if (!StringUtils.hasLength(mbd.getScope())) {
  56.                 mbd.setScope(SCOPE_SINGLETON);
  57.             }
  59.             // A bean contained in a non-singleton bean cannot be a singleton itself.
  60.             // Let's correct this on the fly here, since this might be the result of
  61.             // parent-child merging for the outer bean, in which case the original inner bean
  62.             // definition will not have inherited the merged outer bean's singleton status.
  63.             if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
  64.                 mbd.setScope(containingBd.getScope());
  65.             }
  67.             // Cache the merged bean definition for the time being
  68.             // (it might still get re-merged later on in order to pick up metadata changes)
  69.             if (containingBd == null && isCacheBeanMetadata()) {
  70.                 this.mergedBeanDefinitions.put(beanName, mbd);
  71.             }
  72.         }
  73.         if (previous != null) {
  74.             copyRelevantMergedBeanDefinitionCaches(previous, mbd);
  75.         }
  76.         return mbd;
  77.     }
  78. }

合并操作有不同的情况

这里分两种情况去看代码：

  1. 实例化普通的 bean ，比如 Sbean
  2. 实例化有很多父类的 bean，比如 Abean extends Bbean，Bbean extends Cbean …

    情况1：单个bean

    首先进入方法：getMergedLocalBeanDefinition(String beanName)
    1. protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
    2.  // Quick check on the concurrent map first, with minimal locking.
    3.  // 检查下缓存，有的话，并且不需要合并的直接返回
    4.  RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
    5.  if (mbd != null && !mbd.stale) {
    6.      return mbd;
    7.  }
    8.  return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
    9. }

这里肯定没有缓存，所以进入下一个方法：
getMergedBeanDefinition(String beanName, BeanDefinition bd)

  1. protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
  2.         throws BeanDefinitionStoreException {
  4.     return getMergedBeanDefinition(beanName, bd, null);
  5. }

直接进入重载方法：getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) 。如下代码，删除了不会走的分支。

  1. protected RootBeanDefinition getMergedBeanDefinition(
  2.         String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
  3.         throws BeanDefinitionStoreException {
  4.     // ConcurrentHashMap 内部是线程安全的，但是把单个操作组合起来不一定是安全的。比如 map.put(key,value++)。
  5.     synchronized (this.mergedBeanDefinitions) {
  6.         RootBeanDefinition mbd = null;
  7.         RootBeanDefinition previous = null;
  8.         // 这个操作后，mbd==null
  9.         if (containingBd == null) {
  10.             mbd = this.mergedBeanDefinitions.get(beanName);
  11.         }
  12.         if (mbd == null || mbd.stale) {
  13.             previous = mbd; // null
  14.             if (bd.getParentName() == null) {
  15.                 // Use copy of given root bean definition.
  16.                 // 不是
  17.                 if (bd instanceof RootBeanDefinition) {
  18.                     mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
  19.                 }
  20.                 else {
  21.                     // 直接返回这个
  22.                     mbd = new RootBeanDefinition(bd);
  23.                 }
  24.             }
  25.             else {
  26.                 ......
  27.             }
  28.             // Set default singleton scope, if not configured before.
  29.             if (!StringUtils.hasLength(mbd.getScope())) {
  30.                 mbd.setScope(SCOPE_SINGLETON);
  31.             }
  32.             // 加入缓存
  33.             if (containingBd == null && isCacheBeanMetadata()) {
  34.                 this.mergedBeanDefinitions.put(beanName, mbd);
  35.             }
  36.         }
  37.         return mbd;
  38.     }
  39. }

情况2：有继承关系的bean

比如 Abean extends Bbean，Bextends Object 。前几步骤都一样，直接进入重载方法：getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd)
因为 Abean 的 parent 不为空，所以进入分支：

  1. BeanDefinition pbd;
  2. try {
  3.     // 得到父bean的名称
  4.     String parentBeanName = transformedBeanName(bd.getParentName());
  5.     if (!beanName.equals(parentBeanName)) {
  6.         // 如果不是当前bean,取父bean的BeanDefinition,递归
  7.         pbd = getMergedBeanDefinition(parentBeanName);
  8.     }
  9.     else {
  10.         BeanFactory parent = getParentBeanFactory();
  11.         if (parent instanceof ConfigurableBeanFactory) {
  12.             pbd = ((ConfigurableBeanFactory) parent).getMergedBeanDefinition(parentBeanName);
  13.         }
  14.         else {
  15.             throw new NoSuchBeanDefinitionException(parentBeanName,
  16.                     "Parent name '" + parentBeanName + "' is equal to bean name '" + beanName +
  17.                     "': cannot be resolved without a ConfigurableBeanFactory parent");
  18.         }
  19.     }
  20. }
  21. catch (NoSuchBeanDefinitionException ex) {
  22.     throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
  23.             "Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
  24. }
  25. // Deep copy with overridden values.
  26. mbd = new RootBeanDefinition(pbd);
  27. mbd.overrideFrom(bd);

在 pbd = getMergedBeanDefinition(parentBeanName);
方法上会不断查找父bean定义。然后利用方法进行合并。

  1. mbd = new RootBeanDefinition(pbd);
  2. mbd.overrideFrom(bd);

测试代码

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "https://www.springframework.org/dtd/spring-beans-2.0.dtd">
  4. <beans>
  5.     <bean id="dog" class="cn.lichenghao.entity.Dog" lazy-init="false">
  6.         <property name="name">
  7.             <value>Dog11</value>
  8.         </property>
  9.         <property name="age">
  10.             <value>31</value>
  11.         </property>
  12.     </bean>
  14.     <bean id="cat" class="cn.lichenghao.entity.Cat" parent="animal">
  15.         <property name="name">
  16.             <value>Cat123</value>
  17.         </property>
  18.         <property name="age">
  19.             <value>3</value>
  20.         </property>
  21.     </bean>
  23.     <bean id="animal" class="cn.lichenghao.entity.Animal">
  24.         <property name="canRun">
  25.             <value>true</value>
  26.         </property>
  27.     </bean>
  28. </beans>

3个 bean ```java package cn.lichenghao.entity;

public class Animal {

  1. private boolean canRun;
  3. public Animal() {
  4. }
  6. public boolean isCanRun() {
  7.     return canRun;
  8. }
  10. public void setCanRun(boolean canRun) {
  11.     this.canRun = canRun;
  12. }

}

  1. ```java
  2. package cn.lichenghao.entity;
  4. public class Dog {
  5.     private String name;
  6.     private Integer age;
  8.     public Dog() {
  9.         System.out.println("Dog init!!");
  10.     }
  12.     public Dog(String name, Integer age) {
  13.         System.out.println("Dog init!!");
  14.         this.name = name;
  15.         this.age = age;
  16.     }
  18.     public void say(){
  19.         System.out.println("wwwwwwwww");
  20.     }
  22.     public String getName() {
  23.         return name;
  24.     }
  26.     public void setName(String name) {
  27.         this.name = name;
  28.     }
  30.     public Integer getAge() {
  31.         return age;
  32.     }
  34.     public void setAge(Integer age) {
  35.         this.age = age;
  36.     }
  37. }
  1. package cn.lichenghao.entity;
  3. public class Cat extends Animal {
  5.     private String name;
  6.     private Integer age;
  8.     public Cat() {
  9.     }
  11.     public Cat(String name, Integer age) {
  12.         super();
  13.         this.name = name;
  14.         this.age = age;
  15.     }
  17.     public String getName() {
  18.         return name;
  19.     }
  21.     public void setName(String name) {
  22.         this.name = name;
  23.     }
  25.     public Integer getAge() {
  26.         return age;
  27.     }
  29.     public void setAge(Integer age) {
  30.         this.age = age;
  31.     }
  32. }

启动 IOC 测试

  1. public class AppDog {
  2.     public static void main(String[] args) {
  3.         // 根据配置文件加载bean
  4.         ClassPathXmlApplicationContext classPathXmlApplicationContext
  5.                 = new ClassPathXmlApplicationContext("dog.xml");
  6.     }
  7. }

片段：判断 Bean 是否为 FactoryBean

通过代码可以看出，分为两种情况的 Bean ，一种是 FactoryBean，一种是其他的 Bean。

  1. public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException {
  2.         String beanName = transformedBeanName(name);
  3.         Object beanInstance = getSingleton(beanName, false);
  4.         if (beanInstance != null) {
  5.             return (beanInstance instanceof FactoryBean);
  6.         }
  7.         // No singleton instance found -> check bean definition.
  8.         if (!containsBeanDefinition(beanName) 
  9.             && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
  10.             // No bean definition found in this factory -> delegate to parent.
  11.             return ((ConfigurableBeanFactory) getParentBeanFactory()).isFactoryBean(name);
  12.         }
  13.         return isFactoryBean(beanName, getMergedLocalBeanDefinition(beanName));
  14.     }

然后再过安全检查，特权处理。

  1. if (isFactoryBean(beanName)) {
  2.     // 工厂bean
  3.     Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  4.     if (bean instanceof FactoryBean) {
  5.         FactoryBean<?> factory = (FactoryBean<?>) bean;
  6.         boolean isEagerInit;
  7.         // 如果是SmartFactoryBean的实例
  8.         if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  9.             // 安全检查
  10.             isEagerInit = AccessController.doPrivileged(
  11.                     (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  12.                     getAccessControlContext());
  13.         }
  14.         else {
  15.             isEagerInit = (factory instanceof SmartFactoryBean &&
  16.                     ((SmartFactoryBean<?>) factory).isEagerInit());
  17.         }
  18.         if (isEagerInit) {
  19.             getBean(beanName);
  20.         }
  21.     }
  22. }

准备完毕

所有的准备工作已经完毕，接下来就是实例化 bean 的大流程。
Z10NEXG95H7gOsjY6jKOd.png