1.         Object person = xmlBeanFactory.getBean("person");
  4.     AbstractBeanFactory.class
  5.     @Override
  6.     public Object getBean(String name) throws BeansException {
  7.         return doGetBean(name, null, null, false);
  8.     }
  1. @SuppressWarnings("unchecked")
  2.     protected <T> T doGetBean(
  3.             String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
  4.             throws BeansException {
  5.         //1.转换为beanName
  6.         String beanName = transformedBeanName(name);
  7.         Object beanInstance;
  9.         //2.从三级缓存中获取
  10.         Object sharedInstance = getSingleton(beanName);
  11.         //获取到了
  12.         if (sharedInstance != null && args == null) {
  13.             if (logger.isTraceEnabled()) {
  14.                 //3.是否是循环依赖
  15.                 if (isSingletonCurrentlyInCreation(beanName)) {
  16.                     logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  17.                             "' that is not fully initialized yet - a consequence of a circular reference");
  18.                 }
  19.                 else {
  20.                     logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  21.                 }
  22.             }
  24.             //获取Bean实例
  25.             beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  26.         }
  28.         else {
  29.             // Fail if we're already creating this bean instance:
  30.             // We're assumably within a circular reference.
  31.             //若缓存中没有，且是一个 原型的循环依赖时 抛出异常
  32.             if (isPrototypeCurrentlyInCreation(beanName)) {
  33.                 throw new BeanCurrentlyInCreationException(beanName);
  34.             }
  36.             //获取父级的BeanFactory
  37.             BeanFactory parentBeanFactory = getParentBeanFactory();
  39.             //若父级不为空，且此容器没有beanName的BeanDefinition定义进入
  40.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  41.                 // Not found -> check parent. 最初的beanname
  42.                 String nameToLookup = originalBeanName(name);
  43.                 if (parentBeanFactory instanceof AbstractBeanFactory) {
  44.                     return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  45.                             nameToLookup, requiredType, args, typeCheckOnly);
  46.                 }
  47.                 else if (args != null) {
  48.                     // Delegation to parent with explicit args.
  49.                     return (T) parentBeanFactory.getBean(nameToLookup, args);
  50.                 }
  51.                 else if (requiredType != null) {
  52.                     // No args -> delegate to standard getBean method.
  53.                     return parentBeanFactory.getBean(nameToLookup, requiredType);
  54.                 }
  55.                 else {
  56.                     return (T) parentBeanFactory.getBean(nameToLookup);
  57.                 }
  58.                 //..........
  59.             }
  60.             //从父级那边获取元素
  63.             if (!typeCheckOnly) {
  64.                 //标记Bean已经被创建
  65.                 markBeanAsCreated(beanName);
  66.             }
  68.             StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
  69.                     .tag("beanName", name);
  70.             try {
  71.                 if (requiredType != null) {
  72.                     beanCreation.tag("beanType", requiredType::toString);
  73.                 }
  74.                 //转换为 RootBeanDefinition
  75.                 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  76.                 checkMergedBeanDefinition(mbd, beanName, args);
  78.                 // 先get依赖的类
  79.                 String[] dependsOn = mbd.getDependsOn();
  80.                 if (dependsOn != null) {
  81.                     for (String dep : dependsOn) {
  82.                         //若互相依赖则抛异常
  83.                         if (isDependent(beanName, dep)) {
  84.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  85.                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  86.                         }
  87.                         //
  88.                         registerDependentBean(dep, beanName);
  89.                         try {
  90.                             //先构造dep依赖
  91.                             getBean(dep);
  92.                         }
  93.                         catch (NoSuchBeanDefinitionException ex) {
  94.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  95.                                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  96.                         }
  97.                     }
  98.                 }
  100.                 // Create bean instance.
  101.                 if (mbd.isSingleton()) {
  102.                     //若是单例模式  beanName 和  lamda
  103.                     sharedInstance = getSingleton(beanName, () -> {
  104.                         try {
  105.                             return createBean(beanName, mbd, args);
  106.                         }
  107.                         catch (BeansException ex) {
  108.                             // Explicitly remove instance from singleton cache: It might have been put there
  109.                             // eagerly by the creation process, to allow for circular reference resolution.
  110.                             // Also remove any beans that received a temporary reference to the bean.
  111.                             destroySingleton(beanName);
  112.                             throw ex;
  113.                         }
  114.                     });
  115.                     //
  116.                     beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  117.                 }
  119.                 else if (mbd.isPrototype()) {
  120.                     //r若是原型Bean
  121.                     Object prototypeInstance = null;
  122.                     try {
  123.                         beforePrototypeCreation(beanName);
  124.                         prototypeInstance = createBean(beanName, mbd, args);
  125.                     }
  126.                     finally {
  127.                         afterPrototypeCreation(beanName);
  128.                     }
  129.                     beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  130.                 }
  132.                 else {
  133.                     //其他的Scope
  134.                     String scopeName = mbd.getScope();
  135.                     if (!StringUtils.hasLength(scopeName)) {
  136.                         throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
  137.                     }
  138.                     Scope scope = this.scopes.get(scopeName);
  139.                     if (scope == null) {
  140.                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  141.                     }
  142.                     try {
  143.                         Object scopedInstance = scope.get(beanName, () -> {
  144.                             beforePrototypeCreation(beanName);
  145.                             try {
  146.                                 return createBean(beanName, mbd, args);
  147.                             }
  148.                             finally {
  149.                                 afterPrototypeCreation(beanName);
  150.                             }
  151.                         });
  152.                         beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  153.                     }
  154.                     catch (IllegalStateException ex) {
  155.                         throw new ScopeNotActiveException(beanName, scopeName, ex);
  156.                     }
  157.                 }
  158.             }
  159.             catch (BeansException ex) {
  160.                 beanCreation.tag("exception", ex.getClass().toString());
  161.                 beanCreation.tag("message", String.valueOf(ex.getMessage()));
  162.                 cleanupAfterBeanCreationFailure(beanName);
  163.                 throw ex;
  164.             }
  165.             finally {
  166.                 beanCreation.end();
  167.             }
  168.         }
  170.         return adaptBeanInstance(name, beanInstance, requiredType);
  171.     }

1.转换成对应的beanName

  1. 对于"&xxx"这种的的，是去除&
  2. 对于一些别名的传入，会转换为beanName ```java protected String transformedBeanName(String name) {
    1.  return canonicalName(BeanFactoryUtils.transformedBeanName(name));
    }

// BeanFactoryUtils.transformedBeanName(name) public static String transformedBeanName(String name) { //name不可为空 Assert.notNull(name, “‘name’ must not be null”); if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) { //若不是 &开头返回即可 return name; } //若这个name不存在，则将这个name取去除&符号的name 将其作为 &xxx->xxx存入map中 return transformedBeanNameCache.computeIfAbsent(name, beanName -> { do { beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length()); } while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)); return beanName; }); }

//SimpleAliasRegistry.class中的方法将别名转换为beanName //aliasMap就是 alia->beanName public String canonicalName(String name) { String canonicalName = name; // Handle aliasing… String resolvedName; do { resolvedName = this.aliasMap.get(canonicalName); if (resolvedName != null) { canonicalName = resolvedName; } } while (resolvedName != null); return canonicalName; }

  1. <a name="CoAqt"></a>
  2. # 2.尝试从缓存中加载单例
  3. 这里的缓存就是传说中的3级缓存，来自`DefaultSingletonBeanRegistry`类中的三级缓存
  4. ```java
  5. @Nullable
  6.     protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  7.         // 快速的从单例对象缓存（一级缓存）获取对象且不加锁
  8.         Object singletonObject = this.singletonObjects.get(beanName);
  9.         //单例对象获取不到且 正在被创建才会进入
  10.         if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  11.             //从早期对象中获取
  12.             singletonObject = this.earlySingletonObjects.get(beanName);
  14.             //早期对象还是没有
  15.             if (singletonObject == null && allowEarlyReference) {
  16.                 //对单例对象进行加锁
  17.                 synchronized (this.singletonObjects) {
  18.                     //DCL
  19.                     singletonObject = this.singletonObjects.get(beanName);
  21.                     //确实没有
  22.                     if (singletonObject == null) {
  23.                         //再从二级缓存获取
  24.                         singletonObject = this.earlySingletonObjects.get(beanName);
  25.                         if (singletonObject == null) {
  27.                             ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  28.                             //三级缓存中有 ObjectFactory
  29.                             if (singletonFactory != null) {
  30.                                 //执行构建
  31.                                 singletonObject = singletonFactory.getObject();
  32.                                 this.earlySingletonObjects.put(beanName, singletonObject);
  33.                                 this.singletonFactories.remove(beanName);
  34.                             }
  35.                         }
  36.                     }
  37.                 }
  38.             }
  41.         }
  42.         return singletonObject;
  43.     }
  1. 整体代码就是一个DCL，第一遍检查一、二级缓存到底有无bean、加锁后再次检查一遍
  2. 判断是否bean正在被创建时 ```java //这样的Set就是一个线程安全的 里面放入正在创建啊的beanName private final Set singletonsCurrentlyInCreation =
    1.      Collections.newSetFromMap(new ConcurrentHashMap<>(16));
  1. //代码简单
  2. public boolean isSingletonCurrentlyInCreation(String beanName) {
  3.     return this.singletonsCurrentlyInCreation.contains(beanName);
  4. }
  2. 3. `allowEarlyReference`参数是调用时传入，代表是否允许引用早期Bean对象
  3. 4. `ObjectFactory<>`是一个函数式接口，也就是说三级缓存时beanName->getObject的lamda表达式
  4. ```java
  5. @FunctionalInterface
  6. public interface ObjectFactory<T> {
  8.     /**
  9.      * Return an instance (possibly shared or independent)
  10.      * of the object managed by this factory.
  11.      * @return the resulting instance
  12.      * @throws BeansException in case of creation errors
  13.      */
  14.     T getObject() throws BeansException;
  16. }

3.bean的实例化

  1. if (sharedInstance != null && args == null) {
  2.             if (logger.isTraceEnabled()) {
  3.                 if (isSingletonCurrentlyInCreation(beanName)) {
  4.                     logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
  5.                             "' that is not fully initialized yet - a consequence of a circular reference");
  6.                 }
  7.                 else {
  8.                     logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
  9.                 }
  10.             }
  11.             beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  12.         }
  14.         else {
  15.             //....
  17.         }

若从三级缓存中获取了实例

  2. /** 
  3. * 要么就是bean实例自己
  4. * 要么就是FactoryBean创建的对象
  5. * 
  6. */
  7. protected Object getObjectForBeanInstance(
  8.             Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
  10.         // 若name是对FactoryBean的应用则 返回beanInstance
  11.         if (BeanFactoryUtils.isFactoryDereference(name)) {
  12.             if (beanInstance instanceof NullBean) {
  13.                 return beanInstance;
  14.             }
  15.             if (!(beanInstance instanceof FactoryBean)) {
  16.                 throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
  17.             }
  18.             if (mbd != null) {
  19.                 mbd.isFactoryBean = true;
  20.             }
  21.             return beanInstance;
  22.         }
  24.         // 若不是Factorybean直接返回
  25.         if (!(beanInstance instanceof FactoryBean)) {
  26.             return beanInstance;
  27.         }
  29.         Object object = null;
  30.         if (mbd != null) {
  31.             mbd.isFactoryBean = true;
  32.         }
  33.         else {
  34.             //从这个Map factoryBeanObjectCache中获取内容， beanName->getObject()
  35.             object = getCachedObjectForFactoryBean(beanName);
  36.         }
  37.         if (object == null) {
  38.             // Return bean instance from factory.
  39.             FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
  40.             // Caches object obtained from FactoryBean if it is a singleton.
  41.             if (mbd == null && containsBeanDefinition(beanName)) {
  42.                 mbd = getMergedLocalBeanDefinition(beanName);
  43.             }
  44.             boolean synthetic = (mbd != null && mbd.isSynthetic());
  45.             object = getObjectFromFactoryBean(factory, beanName, !synthetic);
  46.         }
  47.         return object;
  48.     }
  1. protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
  2.         if (factory.isSingleton() && containsSingleton(beanName)) {
  3.             //如果是单例且 FactoryBean已经创建出来了
  4.             synchronized (getSingletonMutex()) {
  5.                 //还是先尝试从 factoryBeanObjectCache中获取 bean
  6.                 Object object = this.factoryBeanObjectCache.get(beanName);
  7.                 if (object == null) {
  8.                     //没有的话就doGet
  9.                     object = doGetObjectFromFactoryBean(factory, beanName);
  10.                     // Only post-process and store if not put there already during getObject() call above
  11.                     // (e.g. because of circular reference processing triggered by custom getBean calls)
  12.                     //这里会从缓存中再尝试获取一次
  13.                     Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
  14.                     if (alreadyThere != null) {
  15.                         object = alreadyThere;
  16.                     }
  17.                     else {
  18.                         if (shouldPostProcess) {
  19.                             //若 beanname正在创建，则直接返回object
  20.                             if (isSingletonCurrentlyInCreation(beanName)) {
  21.                                 // Temporarily return non-post-processed object, not storing it yet..
  22.                                 //这是一个没有走后置逻辑的object
  23.                                 return object;
  24.                             }
  25.                             //将beanName设置为正在创建
  26.                             beforeSingletonCreation(beanName);
  27.                             try {
  28.                                 //执行postProcessAfterInitialization
  29.                                 object = postProcessObjectFromFactoryBean(object, beanName);
  30.                             }
  31.                             catch (Throwable ex) {
  32.                                 throw new BeanCreationException(beanName,
  33.                                         "Post-processing of FactoryBean's singleton object failed", ex);
  34.                             }
  35.                             finally {
  36.                                 //从正在创建的bean中移出
  37.                                 afterSingletonCreation(beanName);
  38.                             }
  39.                         }
  40.                         if (containsSingleton(beanName)) {
  41.                             //若进入了一级缓存则， factoryBean也缓存一份
  42.                             this.factoryBeanObjectCache.put(beanName, object);
  43.                         }
  44.                     }
  45.                 }
  46.                 return object;
  47.             }
  48.         }
  49.         else {
  50.             //若不是单例FactoyBean，直接重新获取FactoryBean ，.getObject
  51.             Object object = doGetObjectFromFactoryBean(factory, beanName);
  52.             if (shouldPostProcess) {
  53.                 try {
  54.                     object = postProcessObjectFromFactoryBean(object, beanName);
  55.                 }
  56.                 catch (Throwable ex) {
  57.                     throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
  58.                 }
  59.             }
  60.             return object;
  61.         }
  62.     }
  1.     private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
  2.         Object object;
  3.         try {
  4.             if (System.getSecurityManager() != null) {
  5.                 AccessControlContext acc = getAccessControlContext();
  6.                 try {
  7.                     object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
  8.                 }
  9.                 catch (PrivilegedActionException pae) {
  10.                     throw pae.getException();
  11.                 }
  12.             }
  13.             else {
  14.                 //调用getObject方法
  15.                 object = factory.getObject();
  16.             }
  17.         }
  18.         catch (FactoryBeanNotInitializedException ex) {
  19.             throw new BeanCurrentlyInCreationException(beanName, ex.toString());
  20.         }
  21.         catch (Throwable ex) {
  22.             throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
  23.         }
  25.         // Do not accept a null value for a FactoryBean that's not fully
  26.         // initialized yet: Many FactoryBeans just return null then.
  27.         if (object == null) {
  28.             if (isSingletonCurrentlyInCreation(beanName)) {
  29.                 throw new BeanCurrentlyInCreationException(
  30.                         beanName, "FactoryBean which is currently in creation returned null from getObject");
  31.             }
  32.             object = new NullBean();
  33.         }
  34.         return object;
  35.     }

以上是bean在三级缓存中可以取到内容的情况，下面我们来看一下else分支

这段代码就是下面的4~8的一个大概流程

  1.         if (sharedInstance != null && args == null) {
  2.             //三级缓存中可以取到的场景
  3.         }
  4.         else {
  5.             // Fail if we're already creating this bean instance:
  6.             // We're assumably within a circular reference.
  7.             //若是原型模式正在创建，则直接抛出异常
  8.             if (isPrototypeCurrentlyInCreation(beanName)) {
  9.                 throw new BeanCurrentlyInCreationException(beanName);
  10.             }
  12.             // 获取父Beanfactory
  13.             BeanFactory parentBeanFactory = getParentBeanFactory();
  14.             //若自己没有这个BeanDefinition
  15.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  16.                 // Not found -> check parent.
  17.                 String nameToLookup = originalBeanName(name);
  18.                 if (parentBeanFactory instanceof AbstractBeanFactory) {
  19.                     return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  20.                             nameToLookup, requiredType, args, typeCheckOnly);
  21.                 }
  22.                 else if (args != null) {
  23.                     // Delegation to parent with explicit args.
  24.                     return (T) parentBeanFactory.getBean(nameToLookup, args);
  25.                 }
  26.                 else if (requiredType != null) {
  27.                     // No args -> delegate to standard getBean method.
  28.                     return parentBeanFactory.getBean(nameToLookup, requiredType);
  29.                 }
  30.                 else {
  31.                     return (T) parentBeanFactory.getBean(nameToLookup);
  32.                 }
  33.             }
  35.             //标记bean被创建
  36.             if (!typeCheckOnly) {
  37.                 markBeanAsCreated(beanName);
  38.             }
  40.             StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
  41.                     .tag("beanName", name);
  42.             try {
  43.                 if (requiredType != null) {
  44.                     beanCreation.tag("beanType", requiredType::toString);
  45.                 }
  46.                 // 获取BeanDefinition
  47.                 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  48.                 checkMergedBeanDefinition(mbd, beanName, args);
  50.                 // Guarantee initialization of beans that the current bean depends on.                //保证没有循环的depend-on
  51.                 String[] dependsOn = mbd.getDependsOn();
  52.                 if (dependsOn != null) {
  53.                     for (String dep : dependsOn) {
  54.                         if (isDependent(beanName, dep)) {
  55.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  56.                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  57.                         }
  58.                         //注册 被依赖的 bean
  59.                         registerDependentBean(dep, beanName);
  60.                         try {
  61.                             //getBean depend-on
  62.                             getBean(dep);
  63.                         }
  64.                         catch (NoSuchBeanDefinitionException ex) {
  65.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  66.                                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  67.                         }
  68.                     }
  69.                 }
  71.                 // Create bean instance.
  72.                 if (mbd.isSingleton()) {
  73.                       //若是单例模式 ,rgetSinleton 并放入 beanName->ObjectFactory表达式
  74.                     sharedInstance = getSingleton(beanName, () -> {
  75.                         try {
  76.                             return createBean(beanName, mbd, args);
  77.                         }
  78.                         catch (BeansException ex) {
  79.                             // Explicitly remove instance from singleton cache: It might have been put there
  80.                             // eagerly by the creation process, to allow for circular reference resolution.
  81.                             // Also remove any beans that received a temporary reference to the bean.
  82.                             destroySingleton(beanName);
  83.                             throw ex;
  84.                         }
  85.                     });
  86.                     beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  87.                 }
  89.                 else if (mbd.isPrototype()) {
  90.                     // It's a prototype -> create a new instance.
  91.                     Object prototypeInstance = null;
  92.                     try {
  93.                         beforePrototypeCreation(beanName);
  94.                         prototypeInstance = createBean(beanName, mbd, args);
  95.                     }
  96.                     finally {
  97.                         afterPrototypeCreation(beanName);
  98.                     }
  99.                     beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  100.                 }
  102.                 else {
  103.                     String scopeName = mbd.getScope();
  104.                     if (!StringUtils.hasLength(scopeName)) {
  105.                         throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
  106.                     }
  107.                     Scope scope = this.scopes.get(scopeName);
  108.                     if (scope == null) {
  109.                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  110.                     }
  111.                     try {
  112.                         Object scopedInstance = scope.get(beanName, () -> {
  113.                             beforePrototypeCreation(beanName);
  114.                             try {
  115.                                 return createBean(beanName, mbd, args);
  116.                             }
  117.                             finally {
  118.                                 afterPrototypeCreation(beanName);
  119.                             }
  120.                         });
  121.                         beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  122.                     }
  123.                     catch (IllegalStateException ex) {
  124.                         throw new ScopeNotActiveException(beanName, scopeName, ex);
  125.                     }
  126.                 }
  127.             }
  128.             catch (BeansException ex) {
  129.                 beanCreation.tag("exception", ex.getClass().toString());
  130.                 beanCreation.tag("message", String.valueOf(ex.getMessage()));
  131.                 cleanupAfterBeanCreationFailure(beanName);
  132.                 throw ex;
  133.             }
  134.             finally {
  135.                 beanCreation.end();
  136.             }
  137.         }
  138.         return adaptBeanInstance(name, beanInstance, requiredType);
  1. @SuppressWarnings("unchecked")
  2.     <T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
  3.         // Check if required type matches the type of the actual bean instance.
  4.         if (requiredType != null && !requiredType.isInstance(bean)) {
  5.             try {
  6.                 Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  7.                 if (convertedBean == null) {
  8.                     throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  9.                 }
  10.                 return (T) convertedBean;
  11.             }
  12.             catch (TypeMismatchException ex) {
  13.                 if (logger.isTraceEnabled()) {
  14.                     logger.trace("Failed to convert bean '" + name + "' to required type '" +
  15.                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
  16.                 }
  17.                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  18.             }
  19.         }
  20.         return (T) bean;
  21.     }

4.原型模式的依赖检查

  1.     public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
  2.         Assert.notNull(beanName, "Bean name must not be null");
  3.         synchronized (this.singletonObjects) {
  5.             Object singletonObject = this.singletonObjects.get(beanName);
  6.             if (singletonObject == null) {
  7.                 if (this.singletonsCurrentlyInDestruction) {
  8.                     throw new BeanCreationNotAllowedException(beanName,
  9.                             "Singleton bean creation not allowed while singletons of this factory are in destruction " +
  10.                             "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
  11.                 }
  12.                 if (logger.isDebugEnabled()) {
  13.                     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
  14.                 }
  15.                 beforeSingletonCreation(beanName);
  16.                 boolean newSingleton = false;
  17.                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
  18.                 if (recordSuppressedExceptions) {
  19.                     this.suppressedExceptions = new LinkedHashSet<>();
  20.                 }
  21.                 try {
  24.                     //最后会条这里，执行lamda表达式 见图
  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.                     afterSingletonCreation(beanName);
  49.                 }
  50.                 if (newSingleton) {
  52.                     //若是新单例还会 放入 三级缓存
  53.                     addSingleton(beanName, singletonObject);
  54.                 }
  55.             }
  56.             return singletonObject;
  57.         }
  58.     }

image.png

  1.     @Override
  2.     protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  3.             throws BeanCreationException {
  5.         if (logger.isTraceEnabled()) {
  6.             logger.trace("Creating instance of bean '" + beanName + "'");
  7.         }
  8.         RootBeanDefinition mbdToUse = mbd;
  10.         // Make sure bean class is actually resolved at this point, and
  11.         // clone the bean definition in case of a dynamically resolved Class
  12.         // which cannot be stored in the shared merged bean definition.
  13.         Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
  14.         if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
  15.             mbdToUse = new RootBeanDefinition(mbd);
  16.             mbdToUse.setBeanClass(resolvedClass);
  17.         }
  19.         // Prepare method overrides.
  20.         try {
  21.             mbdToUse.prepareMethodOverrides();
  22.         }
  23.         catch (BeanDefinitionValidationException ex) {
  24.             throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
  25.                     beanName, "Validation of method overrides failed", ex);
  26.         }
  28.         try {
  29.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  30.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
  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 {
  42.             //到doCreateBean
  43.             Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  44.             if (logger.isTraceEnabled()) {
  45.                 logger.trace("Finished creating instance of bean '" + beanName + "'");
  46.             }
  47.             return beanInstance;
  48.         }
  49.         catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
  50.             // A previously detected exception with proper bean creation context already,
  51.             // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
  52.             throw ex;
  53.         }
  54.         catch (Throwable ex) {
  55.             throw new BeanCreationException(
  56.                     mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  57.         }
  58.     }
  1. protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @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.         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.                     //应用BeanMergedBeanDefinitionPostProcessor
  24.                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  25.                 }
  26.                 catch (Throwable ex) {
  27.                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  28.                             "Post-processing of merged bean definition failed", ex);
  29.                 }
  30.                 mbd.postProcessed = true;
  31.             }
  32.         }
  34.         // Eagerly cache singletons to be able to resolve circular references
  35.         // even when triggered by lifecycle interfaces like BeanFactoryAware.
  36.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
  37.                 isSingletonCurrentlyInCreation(beanName));
  38.         if (earlySingletonExposure) {
  39.             if (logger.isTraceEnabled()) {
  40.                 logger.trace("Eagerly caching bean '" + beanName +
  41.                         "' to allow for resolving potential circular references");
  42.             }
  43.             //放入三级缓存解决循环依赖
  44.             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  45.         }
  47.         // Initialize the bean instance.
  48.         Object exposedObject = bean;
  49.         try {
  50.             //填充bean的属性
  51.             populateBean(beanName, mbd, instanceWrapper);
  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.         //若是二级缓存引用， 需要判断
  65.         if (earlySingletonExposure) {
  66.             Object earlySingletonReference = getSingleton(beanName, false);
  67.             if (earlySingletonReference != null) {
  68.                 //exporsedObject在一波 populate后任 和 实例化时的对象是同一个
  69.                 if (exposedObject == bean) {
  70.                     exposedObject = earlySingletonReference;
  71.                 }
  72.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
  73.                     String[] dependentBeans = getDependentBeans(beanName);
  74.                     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
  75.                     for (String dependentBean : dependentBeans) {
  76.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
  77.                             actualDependentBeans.add(dependentBean);
  78.                         }
  79.                     }
  80.                     if (!actualDependentBeans.isEmpty()) {
  81.                         throw new BeanCurrentlyInCreationException(beanName,
  82.                                 "Bean with name '" + beanName + "' has been injected into other beans [" +
  83.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
  84.                                 "] in its raw version as part of a circular reference, but has eventually been " +
  85.                                 "wrapped. This means that said other beans do not use the final version of the " +
  86.                                 "bean. This is often the result of over-eager type matching - consider using " +
  87.                                 "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
  88.                     }
  89.                 }
  90.             }
  91.         }
  93.         // Register bean as disposable.
  94.         try {
  95.             //注册 Disposable
  96.             registerDisposableBeanIfNecessary(beanName, bean, mbd);
  97.         }
  98.         catch (BeanDefinitionValidationException ex) {
  99.             throw new BeanCreationException(
  100.                     mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
  101.         }
  103.         return exposedObject;
  104.     }
  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.         // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
  14.         // state of the bean before properties are set. This can be used, for example,
  15.         // to support styles of field injection.
  16.         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  17.             for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
  18.                 if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
  19.                     return;
  20.                 }
  21.             }
  22.         }
  24.         PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
  27.         //进行了自动装配
  28.         int resolvedAutowireMode = mbd.getResolvedAutowireMode();
  29.         if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  30.             MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
  31.             // Add property values based on autowire by name if applicable.
  32.             if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
  33.                 autowireByName(beanName, mbd, bw, newPvs);
  34.             }
  35.             // Add property values based on autowire by type if applicable.
  36.             if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
  37.                 autowireByType(beanName, mbd, bw, newPvs);
  38.             }
  39.             pvs = newPvs;
  40.         }
  42.         boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
  43.         boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
  45.         PropertyDescriptor[] filteredPds = null;
  46.         if (hasInstAwareBpps) {
  47.             if (pvs == null) {
  48.                 pvs = mbd.getPropertyValues();
  49.             }
  50.             for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
  51.                 PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
  52.                 if (pvsToUse == null) {
  53.                     if (filteredPds == null) {
  54.                         filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  55.                     }
  56.                     pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
  57.                     if (pvsToUse == null) {
  58.                         return;
  59.                     }
  60.                 }
  61.                 pvs = pvsToUse;
  62.             }
  63.         }
  64.         if (needsDepCheck) {
  65.             if (filteredPds == null) {
  66.                 filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
  67.             }
  68.             checkDependencies(beanName, mbd, filteredPds, pvs);
  69.         }
  71.         if (pvs != null) {
  72.             applyPropertyValues(beanName, mbd, bw, pvs);
  73.         }
  74.     }
  1. protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
  2.         if (System.getSecurityManager() != null) {
  3.             AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
  4.                 invokeAwareMethods(beanName, bean);
  5.                 return null;
  6.             }, getAccessControlContext());
  7.         }
  8.         else {
  9.             //唤醒Aware方法
  10.             invokeAwareMethods(beanName, bean);
  11.         }
  13.         Object wrappedBean = bean;
  14.         if (mbd == null || !mbd.isSynthetic()) {
  15.             //执行BeanPostProcessor的 BeforeInitialization
  16.             wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
  17.         }
  19.         try {
  20.             //调用初始化方法
  21.             invokeInitMethods(beanName, wrappedBean, mbd);
  22.         }
  23.         catch (Throwable ex) {
  24.             throw new BeanCreationException(
  25.                     (mbd != null ? mbd.getResourceDescription() : null),
  26.                     beanName, "Invocation of init method failed", ex);
  27.         }
  28.         if (mbd == null || !mbd.isSynthetic()) {
  29.             //执行初始化后方法
  30.             wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
  31.         }
  33.         return wrappedBean;
  34.     }

5.检测parentBeanFactory

6.将XML存储的GernericBeanDefinition转换为Root

7.寻找依赖

8.不同Scope进行bean的创建

9.类型转换

总结

image.png