在创建 bean 的实例对象时，会调用 (org.springframework.beans.factory.support)AbstractBeanFactory#doGetBean：

    1.     protected <T> T doGetBean(
    2.             String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    3.             throws BeansException {
    5.         // 获取 bean 名称
    6.         String beanName = transformedBeanName(name);
    7.         Object beanInstance;
    9.         // 从缓存中获取单例的 bean：获取单例对象的时候，会触发三级缓存的处理，原型模式和单例模式最大的区别就是，前者不会放入缓存
    10.         // Eagerly check singleton cache for manually registered singletons.
    11.         Object sharedInstance = getSingleton(beanName);
    12.         // 如果获取到单例 bean（bean != null），则走下面代码
    13.         if (sharedInstance != null && args == null) {
    14.             if (logger.isTraceEnabled()) {
    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.             }
    23.             // 如果取出来的 Bean 实例是 FactoryBean 的 Bean 实例，则需要从 FactoryBean 的实例中产生一个对象实例
    24.             beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    25.         }
    27.         else {// 如果没有获取到单例 bean (bean == null)，就走下面的代码
    29.             // 如果 <原型模式(prototype)> 的 bean 发生循环引用，则直接不处理，抛出异常 （大多数获取都是用的单例模式）
    30.             // 原型模式是无法解决循环引用和循环依赖问题的 ...
    31.             // Fail if we're already creating this bean instance:
    32.             // We're assumably within a circular reference.
    33.             if (isPrototypeCurrentlyInCreation(beanName)) {
    34.                 throw new BeanCurrentlyInCreationException(beanName);
    35.             }
    37.             // 调用父工厂去找一找这个 bean
    38.             // Check if bean definition exists in this factory.
    39.             BeanFactory parentBeanFactory = getParentBeanFactory();
    40.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    41.                 // Not found -> check parent.
    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.             }
    60.             // 类型检查是否唯一
    61.             if (!typeCheckOnly) {
    62.                 markBeanAsCreated(beanName);
    63.             }
    65.             StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
    66.                     .tag("beanName", name);
    69. //---------------------------- bean 处理核心 ----------Spring 中一个 try...catch() 基本上就是一个处理核心--------------------------------
    70.             try {
    71.                 if (requiredType != null) {
    72.                     beanCreation.tag("beanType", requiredType::toString);
    73.                 }
    75.                 // 获取要实例化的 bean 的 BeanDefinition 对象
    76.                 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
    77.                 // 检查该 BeanDefinition 对象对应的 Bean 是否是抽象的
    78.                 checkMergedBeanDefinition(mbd, beanName, args);
    80.                 // Guarantee initialization of beans that the current bean depends on.
    81.                 String[] dependsOn = mbd.getDependsOn();
    82.                 if (dependsOn != null) {
    83.                     for (String dep : dependsOn) {
    84.                         if (isDependent(beanName, dep)) {
    85.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    86.                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    87.                         }
    88.                         registerDependentBean(dep, beanName);
    89.                         try {
    90.                             getBean(dep);
    91.                         }
    92.                         catch (NoSuchBeanDefinitionException ex) {
    93.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    94.                                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
    95.                         }
    96.                     }
    97.                 }
    99. // ---------------------------------------- 单例的 Bean---------------------------------------------------------------------------
    100.                 // Create bean instance.
    101.                 if (mbd.isSingleton()) {
    102.                     // 使用 lambuda 表达式来调用 getSingleton 方法获取一个单例对象
    103.                     // public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) 第二个参数传入一个匿名内部类
    104.                     sharedInstance = getSingleton(beanName, () -> {
    105.                         try {
    106.                             // 创建单例 Bean 的主要方法，创建一个单例 bean
    107.                             return createBean(beanName, mbd, args);
    108.                         }
    109.                         catch (BeansException ex) {
    110.                             // Explicitly remove instance from singleton cache: It might have been put there
    111.                             // eagerly by the creation process, to allow for circular reference resolution.
    112.                             // Also remove any beans that received a temporary reference to the bean.
    113.                             destroySingleton(beanName);
    114.                             throw ex;
    115.                         }
    116.                     });
    119.                     beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    120.                 }
    121. // -----------------------------------------------------------------------------------
    123. // ------------------------- 多例（原型） ----------------------------------------------------
    124.                 // 多例
    125.                 else if (mbd.isPrototype()) {
    126.                     // It's a prototype -> create a new instance.
    127.                     Object prototypeInstance = null;
    128.                     try {
    129.                         beforePrototypeCreation(beanName);
    130.                         prototypeInstance = createBean(beanName, mbd, args);
    131.                     }
    132.                     finally {
    133.                         afterPrototypeCreation(beanName);
    134.                     }
    135.                     beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    136.                 }
    137. // -----------------------------------------------------------------------------
    139.                 // 既非单例也非多例，request 或者是 session 级别
    140.                 else {
    141.                     String scopeName = mbd.getScope();
    142.                     if (!StringUtils.hasLength(scopeName)) {
    143.                         throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");
    144.                     }
    145.                     Scope scope = this.scopes.get(scopeName);
    146.                     if (scope == null) {
    147.                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
    148.                     }
    149.                     try {
    150.                         Object scopedInstance = scope.get(beanName, () -> {
    151.                             beforePrototypeCreation(beanName);
    152.                             try {
    153.                                 return createBean(beanName, mbd, args);
    154.                             }
    155.                             finally {
    156.                                 afterPrototypeCreation(beanName);
    157.                             }
    158.                         });
    159.                         beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    160.                     }
    161.                     catch (IllegalStateException ex) {
    162.                         throw new ScopeNotActiveException(beanName, scopeName, ex);
    163.                     }
    164.                 }
    165.             }
    167. //-------------------------------------------------------------------------------------------------------->
    168.             catch (BeansException ex) {
    169.                 beanCreation.tag("exception", ex.getClass().toString());
    170.                 beanCreation.tag("message", String.valueOf(ex.getMessage()));
    171.                 cleanupAfterBeanCreationFailure(beanName);
    172.                 throw ex;
    173.             }
    174.             finally {
    175.                 beanCreation.end();
    176.             }
    177.         }
    179.         return adaptBeanInstance(name, beanInstance, requiredType);
    180.     }

    在创建单例对象时，会先后进入两个方法，第一个会进入 (org.springframework.beans.factory.support)DefaultSingletonBeanRegistry#getSingleton：

    1.     /**
    2.      * 获取单例对象
    3.      */
    4.     public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    5.         Assert.notNull(beanName, "Bean name must not be null");
    6.         synchronized (this.singletonObjects) {
    7.             Object singletonObject = this.singletonObjects.get(beanName);
    8.             if (singletonObject == null) {
    9.                 if (this.singletonsCurrentlyInDestruction) {
    10.                     throw new BeanCreationNotAllowedException(beanName,
    11.                             "Singleton bean creation not allowed while singletons of this factory are in destruction " +
    12.                             "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
    13.                 }
    14.                 if (logger.isDebugEnabled()) {
    15.                     logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
    16.                 }
    18.                 // 创建之前，设置一个创建中的标识
    19.                 beforeSingletonCreation(beanName);
    20.                 boolean newSingleton = false;
    21.                 boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
    22.                 if (recordSuppressedExceptions) {
    23.                     this.suppressedExceptions = new LinkedHashSet<>();
    24.                 }
    25. // ------------------------------- bean 创建流程完成 ---------------------------------------------------------
    26.                 try {
    27.                     // 调用匿名内部类获取单例对象
    28.                     // 该步骤的完成就意味着 bean 的创建流程完成
    29.                     singletonObject = singletonFactory.getObject();
    30.                     newSingleton = true;
    31.                 }
    32. // ----------------------------------------------------------/
    33.                 catch (IllegalStateException ex) {
    34.                     // Has the singleton object implicitly appeared in the meantime ->
    35.                     // if yes, proceed with it since the exception indicates that state.
    36.                     singletonObject = this.singletonObjects.get(beanName);
    37.                     if (singletonObject == null) {
    38.                         throw ex;
    39.                     }
    40.                 }
    41.                 catch (BeanCreationException ex) {
    42.                     if (recordSuppressedExceptions) {
    43.                         for (Exception suppressedException : this.suppressedExceptions) {
    44.                             ex.addRelatedCause(suppressedException);
    45.                         }
    46.                     }
    47.                     throw ex;
    48.                 }
    49.                 finally {
    50.                     if (recordSuppressedExceptions) {
    51.                         this.suppressedExceptions = null;
    52.                     }
    54.                     // 创建成功之后，删除创建中的标识，如果存在这个标识，就说明这个 bean 正在创建中
    55.                     afterSingletonCreation(beanName);
    56.                 }
    58.                 // 将创建的单例 bean 放入缓存中（总共三级缓存）
    59.                 if (newSingleton) {
    60.                     addSingleton(beanName, singletonObject);
    61.                 }
    62.             }
    63.             return singletonObject;
    64.         }
    65.     }

    这里的 afterSingletonCreation(beanName) 的作用是根据 bean 创建一个标识，如果在 bean 创建时检测到已经存在 bean 的标识，就说明这个 bean 正在创建中，如果没有标识就说明 bean 已经创建完成；使用这个方法可以解决循环依赖的问题。

    (org.springframework.beans.factory.support)DefaultSingletonBeanRegistry#afterSingletonCreation：

    1.    protected void afterSingletonCreation(String beanName) {
    2.         if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
    3.             throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
    4.         }
    5.     }

    (org.springframework.beans.factory.support)DefaultSingletonBeanRegistry$singletonsCurrentlyInCreation 是一个集合：

    1.     /**
    2.      *     标记位 可以用这个 set 来判断对象是否在创建中
    3.      */
    4.     private final Set<String> singletonsCurrentlyInCreation =
    5.             Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    此集合可以用来存储 beanName，如果 beanName 在这个集合中，就说明这个 bean 对象正在创建中，如果不在就说明 bean 对象已经创建完成了。

    随后会进入 (org.springframework.beans.factory.support)AbstractAutowireCapableBeanFactory#createBean：

    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.         // 处理方法覆盖
    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.             // 获取 BeanPostProcessor 的代理对象
    30.             // InstantiationAwareBeanPostProcessor 接口对 bean 的实例化的干预处理
    31.             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
    32.             Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    33.             if (bean != null) {
    34.                 return bean;
    35.             }
    36.         }
    37.         catch (Throwable ex) {
    38.             throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
    39.                     "BeanPostProcessor before instantiation of bean failed", ex);
    40.         }
    42.         try {
    43.             // 完成 Bean 实例的创建（实例化 填充属性 初始化）
    44.             Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    45.             if (logger.isTraceEnabled()) {
    46.                 logger.trace("Finished creating instance of bean '" + beanName + "'");
    47.             }
    48.             return beanInstance;
    49.         }
    50.         catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
    51.             // A previously detected exception with proper bean creation context already,
    52.             // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
    53.             throw ex;
    54.         }
    55.         catch (Throwable ex) {
    56.             throw new BeanCreationException(
    57.                     mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    58.         }
    59.     }

    进入 (org.springframework.beans.factory.support)AbstractAutowireCapableBeanFactory#doCreateBean：

    1.     protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
    2.             throws BeanCreationException {
    4.         // Instantiate the bean.
    5.         // Spring 中  ~Wrapper 都是装饰的意思，是 Spring 装饰模式的表现形式
    6.         BeanWrapper instanceWrapper = null;
    7.         if (mbd.isSingleton()) {
    8.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    9.         }
    11. // ------------------------------- bean 初始化第一步：默认调用无参函数构造实例化 Bean ---------------------------
    12.         // 构造参数依赖注入，就是发生在这一步
    13.         if (instanceWrapper == null) {
    14.             instanceWrapper = createBeanInstance(beanName, mbd, args);
    15.         }
    17.         // 实例化后的 Bean 对象
    18.         Object bean = instanceWrapper.getWrappedInstance();
    19.         Class<?> beanType = instanceWrapper.getWrappedClass();
    20.         if (beanType != NullBean.class) {
    21.             mbd.resolvedTargetType = beanType;
    22.         }
    24.         // Allow post-processors to modify the merged bean definition.
    25.         synchronized (mbd.postProcessingLock) {
    26.             if (!mbd.postProcessed) {
    27.                 try {
    28.                     applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    29.                 }
    30.                 catch (Throwable ex) {
    31.                     throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    32.                             "Post-processing of merged bean definition failed", ex);
    33.                 }
    34.                 mbd.postProcessed = true;
    35.             }
    36.         }
    38.         // Eagerly cache singletons to be able to resolve circular references
    39.         // even when triggered by lifecycle interfaces like BeanFactoryAware.
    40. // ------------------------- 将第一步创建的对象放入 3 级缓存中 --------------------------------
    41.         // 解决循环依赖的关键步骤
    42.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    43.                 isSingletonCurrentlyInCreation(beanName));
    44.         // 如果需要提前保留单例 Bean ，则将该 Bean 放入三级缓存中
    45.         if (earlySingletonExposure) {
    46.             if (logger.isTraceEnabled()) {
    47.                 logger.trace("Eagerly caching bean '" + beanName +
    48.                         "' to allow for resolving potential circular references");
    49.             }
    50.             // 将刚创建的 bean 放入三级缓存中 singleFactories(key 是 beanName，value 是 FactoryBean)
    51.             // 此处使用了一个匿名内部类来表示 ObjectFactory () -> getEarlyBeanReference(beanName, mbd, bean)
    52.             // 同时也把第一步创建的 bean 提前封装到了 getEarlyBeanReference 中
    53.             addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    54.         }
    55. // -------------------------------------------------------------------------------/
    58.         // Initialize the bean instance.
    59.         Object exposedObject = bean;
    60.         try {
    61. // ----------------------------------- bean 初始化第二部：填充属性 （DI 依赖注入发生在此步骤） ----------------
    62.             // 调用反射和内容去进行属性设置
    63.             // 属性值需要进行类型转换
    64.             populateBean(beanName, mbd, instanceWrapper);
    65. // ------------------------------------------------/
    67. // ------------------------------------- bean 初始化第三步：调用初始化方法，完成 bean 的初始化操作（AOP 发生在此步骤） ---
    68.             exposedObject = initializeBean(beanName, exposedObject, mbd);
    69. // --------------------------------------------------/
    70.         }
    71.         catch (Throwable ex) {
    72.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
    73.                 throw (BeanCreationException) ex;
    74.             }
    75.             else {
    76.                 throw new BeanCreationException(
    77.                         mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
    78.             }
    79.         }
    81.         if (earlySingletonExposure) {
    82.             Object earlySingletonReference = getSingleton(beanName, false);
    83.             if (earlySingletonReference != null) {
    84.                 if (exposedObject == bean) {
    85.                     exposedObject = earlySingletonReference;
    86.                 }
    87.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    88.                     String[] dependentBeans = getDependentBeans(beanName);
    89.                     Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
    90.                     for (String dependentBean : dependentBeans) {
    91.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
    92.                             actualDependentBeans.add(dependentBean);
    93.                         }
    94.                     }
    95.                     if (!actualDependentBeans.isEmpty()) {
    96.                         throw new BeanCurrentlyInCreationException(beanName,
    97.                                 "Bean with name '" + beanName + "' has been injected into other beans [" +
    98.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
    99.                                 "] in its raw version as part of a circular reference, but has eventually been " +
    100.                                 "wrapped. This means that said other beans do not use the final version of the " +
    101.                                 "bean. This is often the result of over-eager type matching - consider using " +
    102.                                 "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
    103.                     }
    104.                 }
    105.             }
    106.         }
    108.         // Register bean as disposable.
    109.         try {
    110.             registerDisposableBeanIfNecessary(beanName, bean, mbd);
    111.         }
    112.         catch (BeanDefinitionValidationException ex) {
    113.             throw new BeanCreationException(
    114.                     mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    115.         }
    117.         return exposedObject;
    118.     }

    此处完成了 bean 创建的三部曲，同时在第一步骤完成时，做了一个解决循环依赖的操作，此处存入缓存的条件是：

    • 对象是否是单例
    • 能不能允许循环引用
    • 依赖 对象是否创建中 （此处就是指的上一步变量 singletonsCurrentlyInCreation）

    如果符合上面的三个条件，就将创建的 bean 对象放入三级缓存中。

    另外，在可以看到解决循环依赖的代码是位于 bean 创建的第一步骤 和 第二步骤之间，也就是位于 bean 实例化 和 bean 属性填充之间：
    image.png

    所以Spring 通过三级缓存来解决循环依赖，且只能解决Set 方法循环依赖，因为循环依赖解决操作是在对象创建之后才进行的。如果是构造方法循环依赖，是无法解决的，只能修改。