http://misko.hevery.com/2008/08/01/circular-dependency-in-constructors-and-dependency-injection/

package com.lxl.www.circulardependencies;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;

@Component
@Scope("prototype")
public class InstanceA {
    @Autowired
    private InstanceB instanceB;

    public InstanceA() {
        System.out.println(调用 instanceA的构造函数);
    }

     InstanceA(InstanceB instanceB) {
        this.instanceB = instanceB;
    }

    void say(){
        System.out.println( I am A);
    }


     InstanceB getInstanceB() {
        return setInstanceB(InstanceB instanceB) {
         instanceB;
    }

}

 InstanceB {

    @Autowired
    private InstanceA instanceA;
     InstanceB() {
        System.调用 instanceB的构造函数 InstanceA getInstanceA() {
         instanceA;
    }

     setInstanceA(InstanceA instanceA) {
        this.instanceA = instanceA;
    }



}

 MainStart {
    private static Map<String,BeanDeFinition> beanDeFinitionMap = new ConcurrentHashMap<>();

    /**
     * 读取bean定义,当然在spring中肯定是根据配置 动态扫描注册的
     *
     * InstanceA和InstanceB都有注解@Component,所以,在spring扫描读取配置类的时候,会把他们两个扫描到BeanDeFinitionMap中.
     * 这里,我们省略这一步,直接将instanceA和instanceB放到BeanDeFinitionMap中.
     */
    static void loadBeanDeFinitions(){
        RootBeanDeFinition aBeanDeFinition = new RootBeanDeFinition(InstanceA.);
        RootBeanDeFinition bBeanDeFinition = new RootBeanDeFinition(InstanceB.);
        beanDeFinitionMap.put("instanceA",aBeanDeFinition);
        beanDeFinitionMap.put("instanceB",bBeanDeFinition);
    }

     main(String[] args) throws Exception {

        // 第一步: 扫描配置类,读取bean定义
        loadBeanDeFinitions();

......
}

/**
     * 获取bean,根据beanName获取
     */
    static Object getBean(String beanName) throws Exception {*
         * 第一步: 实例化
         * 我们这里是模拟,采用反射的方式进行实例化. 调用的也是最简单的无参构造函数
         */
        RootBeanDeFinition beanDeFinition = (RootBeanDeFinition) beanDeFinitionMap.get(beanName);
        Class<?> beanClass = beanDeFinition.getBeanClass();
         调用无参的构造函数进行实例化
        Object instanceBean = beanClass.newInstance();

     　　*
         *  第二步: 属性赋值
         *  instanceA这类类里面有一个属性,InstanceB. 所以,先拿到 instanceB,然后在判断属性头上有没有Autowired注解.
         *  注意: 这里我们只是判断有没有Autowired注解. spring中还会判断有没有@Resource注解. @Resource注解还有两种方式,一种是name,一种是type
         
        Field[] declaredFields = beanClass.getDeclaredFields();
        for (Field declaredField: declaredFields) {
             判断每一个属性是否有@Autowired注解
            Autowired annotation = declaredField.getAnnotation(Autowired.);
            if (annotation != null) {
                 设置这个属性是可访问的
                declaredField.setAccessible(true);
                 那么这个时候还要构建这个属性的bean.
                
                 * 获取属性的名字
                 * 真实情况,spring这里会判断,是根据名字,还是类型,还是构造函数来获取类.
                 * 我们这里模拟,所以简单一些,直接根据名字获取.
                 
                String name = declaredField.getName();

                *
                 * 这样,在这里我们就拿到了 instanceB 的 bean
                 
                Object fileObject = getBean(name);

                 为属性设置类型
                declaredField.set(instanceBean,fileObject);
            }
        }


        *
         * 第三步: 初始化
         * 初始化就是设置类的init-method.这个可以设置也可以不设置. 我们这里就不设置了
         */
         instanceBean;
    }

　　// 一级缓存
    private static Map<String,Object> singletonObjects = new ConcurrentHashMap<>();

　　 static Object getBean(String beanName) throws Exception {

         增加一个出口. 判断实体类是否已经被加载过了
        Object singleton = getSingleton(beanName);
        if (singleton != ) {
             singleton;
        }

        *
         * 第一步: 实例化
         * 我们这里是模拟,1)"> beanClass.newInstance();

        第二步: 放入到一级缓存
         
        singletonObjects.put(beanName,instanceBean);
        *
         *  第三步: 属性赋值
         *  instanceA这类类里面有一个属性,一种是type
          *
         * 第四步: 初始化
         * 初始化就是设置类的init-method.这个可以设置也可以不设置. 我们这里就不设置了
          instanceBean;
    }

 MainStart {
    new ConcurrentHashMap<>();

     一级缓存
    etonObjects = ();

     二级缓存
    etonObjects = new ConcurrentHashMap<>();

    *
     * 读取bean定义,1)"> loadBeanDeFinitions(){
        RootBeanDeFinition aBeanDeFinition = );
        beanDeFinitionMap.put(instanceAFinition);
        beanDeFinitionMap.put(instanceBFinition);
    }

            loadBeanDeFinitions();

         第二步: 循环创建bean
         (String key: beanDeFinitionMap.keySet()) {
             第一次: key是instanceA,所以先创建A类
            getBean(key);

        }

         测试: 看是否能执行成功
        InstanceA instanceA = (InstanceA) getBean();
        instanceA.say();

    }

     Object getBean(String beanName) throws Exception {

        // 增加一个出口. 判断实体类是否已经被加载过了
        Object singleton = getSingleton(beanName);
        if (singleton != null) {
            return singleton;
        }

        *
         * 第一步: 实例化
         * 我们这里是模拟,1)"> beanClass.newInstance();
        /**
         * 第二步: 放入到二级缓存
         */
        earlySingletonObjects.put(beanName,instanceBean);

        *
         *  第三步: 属性赋值
         *  instanceA这类类里面有一个属性,1)">*
         * 第四步: 初始化
         * 初始化就是设置类的init-method.这个可以设置也可以不设置. 我们这里就不设置了
         */

        *
         * 第二步: 放入到一级缓存
          instanceBean;
    }

    *
     * 判断是否是循环引用的出口.
     * @param beanName
     * @return
      Object getSingleton(String beanName) {
         先去一级缓存里拿,如果一级缓存没有拿到,去二级缓存里拿
        if (singletonObjects.containsKey(beanName)) {
            return singletonObjects.(beanName);
        } else  (earlySingletonObjects.containsKey(beanName)){
            return earlySingletonObjects.else {
            return null;
        }
    }
}

一级缓存: 解决循环依赖的问题

二级缓存: 在创建实例bean和放入到一级缓存之间还有一段间隙. 如果在这之间从一级缓存拿实例,肯定是返回null的. 为了避免这个问题,增加了二级缓存.

面试题: 在创建bean的时候,在哪里创建的动态代理,这个应该怎么回答呢?
很多人会说在初始化之后,或者在实例化之后.
其实更严谨的说, 有两种情况: 第一种是在初始化之后调用 . 第二种是出现了循环依赖,会在实例化之后调用

　　/**
         * 第一步: 实例化
         * 我们这里是模拟,1)"> beanClass.newInstance();

        /**
         * 创建AOP动态代理 (不是耦合的,通过BeanPostProcessor bean的后置处理器得来的.  之前讲过,* 在初始化之后,调用Bean的后置处理器去创建的AOP的动态代理 )
         */
        instanceBean = new JdkProxyBeanPostProcessor().getEarlyBeanReference(instanceBean,);

        *
         * 第二步: 放入到二级缓存
         */
        earlySingletonObjects.put(beanName,instanceBean);

        */
　　　　  //   正常动态代理创建的时机
        
        *
         * 第五步: 放入到一级缓存
          instanceBean;
    }

 JdkProxyBeanPostProcessor implements SmartInstantiationAwareBeanPostProcessor {
    *
     * 假设A被切点命中 需要创建代理  @pointcut("execution(* *..InstanceA.*(..))")
     * @param bean the raw bean instance
     * @param beanName the name of the bean
     * @return
     * @throws BeansException
     
    @Override
     Object getEarlyBeanReference(Object bean,String beanName) throws BeansException {

         假设A被切点命中 需要创建代理  @pointcut("execution(* *..InstanceA.*(..))")

        /**
         * 这里,我们简单直接判断bean是不是InstanceA实例,如果是,就创建动态代理.
         * 这里没有去解析切点,解析切点是AspectJ做的事.
         */
         (bean instanceof InstanceA) {
            JdkDynimcProxy jdkDynimcProxy = new JdkDynimcProxy(bean);
             jdkDynimcProxy.getProxy();
        }
         bean;
    }
}

 Object getSingleton(String beanName) {
         (earlySingletonObjects.containsKey(beanName)){

            /**
             * 第一次创建bean是正常的instanceBean. 他并不是循环依赖. 第二次进来判断,这个bean已经存在了,就说明是循环依赖了
             * 这时候通过动态代理创建bean. 然后将这个bean在放入到二级缓存中覆盖原来的instanceBean.
             */
            Object obj =  JdkProxyBeanPostProcessor()
                    .getEarlyBeanReference(earlySingletonObjects.(beanName),beanName);

            earlySingletonObjects.put(beanName,obj);

            ;
        }
    }

问题1: 我们发现在创建动态代理的时候,我们使用的bean的后置处理器JdkProxyBeanPostProcessor.这有点不太符合规则,因为,spring在getBean()的时候并没有使用Bean的后置处理器,而是在createBean()的时候才去使用的bean的后置处理器.
问题2: 如果A是AOP,他一直都是,最开始创建的时候也应该是. 使用这种方法,结果是第一次创建出来的bean不是AOP动态代理.

 一级缓存
     二级缓存: 为了将成熟的bean和纯净的bean分离. 避免读取到不完整的bean.
    etonObjects = ();

    // 三级缓存:
    private static Map<String,ObjectFactory> singletonFactories = new ConcurrentHashMap<>();

    // 循环依赖的标识---当前正在创建的实例bean
    private static Set<String> singletonsCurrectlyInCreation = new HashSet<>();

先去一级缓存里拿
        Object bean = singletonObjects.(beanName);
         一级缓存中没有,但是正在创建的bean标识中有,说明是循环依赖
        if (bean == null && singletonsCurrectlyInCreation.contains(beanName)) {
            bean = earlySingletonObjects.(beanName);
             如果二级缓存中没有,就从三级缓存中拿
             从三级缓存中取
                ObjectFactory objectFactory = singletonFactories.(beanName);
                if (objectFactory != ) {
                     这里是真正创建动态代理的地方.
                    Object obj = objectFactory.getobject();
                     然后将其放入到二级缓存中. 因为如果有多次依赖,就去二级缓存中判断. 已经有了就不在再次创建了
                    earlySingletonObjects.put(beanName,obj);
                }
            }
        }
         bean;
    }

package com.lxl.www.circulardependencies;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowire;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDeFinition;
import org.springframework.beans.factory.support.RootBeanDeFinition;

import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;

 MainStart {
    ();

     三级缓存:
    etonFactories =  循环依赖的标识---当前正在创建的实例bean
    static Set<String> singletonsCurrectlyInCreation = new HashSet<> main(String[] args) throws Exception {

                loadBeanDeFinitions();

                    getBean(key);

        }

         增加一个出口. 判断实体类是否已经被加载过了
        Object singleton = getSingleton(beanName);
         标记bean正在创建
        if (!singletonsCurrectlyInCreation.contains(beanName)) {
            singletonsCurrectlyInCreation.add(beanName);
        }

        第一步: 实例化
         * 我们这里是模拟,1)"> beanClass.newInstance();


        第二步: 放入到三级缓存
         * 每一次createBean都会将其放入到三级缓存中. getobject是一个钩子方法. 在这里不会被调用.
         * 什么时候被调用呢?
         * 在getSingleton()从三级缓存中取数据,调用创建动态代理的时候
         */
        singletonFactories.put(beanName, ObjectFactory() {
            @Override
             Object getobject() throws BeansException {
                new JdkProxyBeanPostProcessor().getEarlyBeanReference(earlySingletonObjects.earlySingletonObjects.put(beanName,instanceBean);

        */


        *
         * 第五步: 放入到一级缓存
         *
         * 在这里二级缓存存的是动态代理,那么一级缓存肯定也要存动态代理的实例.
         * 从二级缓存中取出实例,放入到一级缓存中
         */
         (earlySingletonObjects.containsKey(beanName)) {
            instanceBean = earlySingletonObjects.(beanName);
        }
        singletonObjects.put(beanName,instanceBean);
         instanceBean;
    }

    /**
     * 判断是否是循环引用的出口.
     * @param beanName
     * @return
     */
    先去一级缓存里拿,
        Object bean = singletonObjects.return bean;
    }
}

1 @Override
 2     public void preInstantiateSingletons() throws BeansException {
 3         if (logger.isTraceEnabled()) {
 4             logger.trace("Pre-instantiating singletons in " + this);
 5         }
 6 
 7 
 8         // 获取容器中所有bean定义的名字
 9         List<String> beanNames = new ArrayList<>(.beanDeFinitionNames);
10 
11          Trigger initialization of all non-lazy singleton beans...
12         /**
13          * 第一步: 循环bean定义的name
14          */
15         for (String beanName : beanNames) {
16              获取bean定义
17             RootBeanDeFinition bd = getMergedLocalBeanDeFinition(beanName);
18              生产bean定义的条件: 不是抽象的,是单例的,不是懒加载的. 符合这个标准的,最后才会调用getBean()生产bean
19             if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
20                  这里判断是不是工厂bean,这里和beanfactory不是一个意思,判断当前这个bean是否实现了beanfactory的接口
21                  (isfactorybean(beanName)) {
22                     Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
23                      (bean instanceof factorybean) {
24                         final factorybean<?> factory = (factorybean<?>) bean;
25                         boolean isEagerInit;
26                         if (System.getSecurityManager() != null && factory instanceof Smartfactorybean) {
27                             isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
28                                             ((Smartfactorybean<?>) factory)::isEagerInit,29                                     getAccessControlContext());
30                         }
31                         else {
32                             isEagerInit = (factory instanceof Smartfactorybean &&
33                                     ((Smartfactorybean<?>) factory).isEagerInit());
3435                          (isEagerInit) {
36                              获取bean
37                             getBean(beanName);
3839                     }
40                 }
41                  {
　　　　　　　　　　　　　　// 第二步: 调用bean定义
42                     getBean(beanName);
4344             }
45         }
46 
47          Trigger post-initialization callback for all applicable beans...
48         
51         52              从缓存中得到实例instance
53             Object singletonInstance = getSingleton(beanName);
54              (singletonInstance instanceof SmartinitializingSingleton) {
55                 final SmartinitializingSingleton smartSingleton = (SmartinitializingSingleton) singletonInstance;
56                 null) {
57                     AccessController.doPrivileged((PrivilegedAction<Object>) () ->58                         smartSingleton.afterSingletonsInstantiated();
59                         return ;
60                     },getAccessControlContext());
6162                 63                     smartSingleton.afterSingletonsInstantiated();
64656667     }

1 protected <T> T doGetBean(final String name,@Nullable final Class<T> requiredType,1)">2             @Nullable final Object[] args,boolean typeCheckOnly) throws BeansException {
  3 
  4         // 第一步: 转换bean name. 在这里传入进来的name可能是别名,也有可能是工厂bean的name,所以在这里进行一个转换
  5         final String beanName = transformedBeanName(name);
  6         Object bean;
  7 
   Eagerly check singleton cache for manually registered singletons.
  9         // 第二步: 尝试去缓存中获取对象,如果没有获取到就创建bean
 10         Object sharedInstance = getSingleton(beanName);
 if (sharedInstance != null && args == ) {
 12             13                 判断当前类是否是正在创建中
 14                  (isSingletonCurrentlyInCreation(beanName)) {
 15                     logger.trace(Returning eagerly cached instance of singleton bean '" + beanName +
 16                             ' that is not fully initialized yet - a consequence of a circular reference"17                 }
 18                  {
 19                     logger.trace(Returning cached instance of singleton bean '" + beanName + '2021             }
 22             bean = getobjectForBeanInstance(sharedInstance,name,beanName,2324 
 25         26              Fail if we're already creating this bean instance:
 27              We're assumably within a circular reference.
 28             *
 29              * 判断当前的bean是不是多例,如果是这抛出异常
 30              *
 31              * 判断当前这个bean是不是多例bean. 如果配置了@Scope("prototype") 就表示这是一个多例的bean
 32              * spring 只能解决单例对象的setter注入的循环依赖,不能解决构造器注入
 33              *
 34              * 如果是多例的bean,当前正在创建bean,也会抛出异常---这也是循环依赖的问题
 35              */
 36              (isPrototypeCurrentlyInCreation(beanName)) {
 37                 throw new BeanCurrentlyInCreationException(beanName);
 39 
 40             *
 41              * 下面这段代码是关于子父容器的,只有spring mvc继承自spring,才会有子父容器的问题.
 42              43              Check if bean deFinition exists in this factory.
 44             beanfactory parentbeanfactory = getParentbeanfactory();
 45             if (parentbeanfactory != null && !containsBeanDeFinition(beanName)) {
 46                  Not found -> check parent.
 47                 String nametoLookup = originalBeanName(name);
 48                  (parentbeanfactory instanceof Abstractbeanfactory) {
 49                     return ((Abstractbeanfactory) parentbeanfactory).doGetBean(
 50                             nametoLookup,requiredType,args,typeCheckOnly);
 5152                 else if (args != 53                      Delegation to parent with explicit args.
 54                      (T) parentbeanfactory.getBean(nametoLookup,args);
 55if (requiredType != 57                      No args -> delegate to standard getBean method.
 58                      parentbeanfactory.getBean(nametoLookup,requiredType);
 5960                 61                      (T) parentbeanfactory.getBean(nametoLookup);
 6264 
 65             *
 66              * 方法参数typeCheckOnly是用来判断#getBean()方法时,表示是否为仅仅进行类型检查,67              * 如果不仅仅做类型检查,而是创建bean对象,则需要调用#markBeanAsCreated(String name)
 68              *
 69              70             if (!typeCheckOnly) {
 71                 markBeanAsCreated(beanName);
 7273 
 74             try75                 final RootBeanDeFinition mbd = getMergedLocalBeanDeFinition(beanName);
 76                 checkMergedBeanDeFinition(mbd,1)">77 
 78                  Guarantee initialization of beans that the current bean depends on.
 79                 *
 80                  * 现在有两个bean1,bean2,加载的时候调用的是bean1,bean2. 但如果我们想要bean2优先加载,就使用@DependOn注解
 81                  * 用来解析带有dependOn注解的类
 82                  83                 String[] dependsOn = mbd.getDependsOn();
 84                 if (dependsOn != 85                      (String dep : dependsOn) {
 86                          (isDependent(beanName,dep)) {
 87                              BeanCreationException(mbd.getResourceDescription(),1)">88                                     Circular depends-on relationship between '' and '" + dep + 89                         }
 90                         registerDependentBean(dep,beanName);
 91                         92                             getBean(dep);
 9394                         catch (NoSuchBeanDeFinitionException ex) {
 95                             96                                     ' depends on missing bean ',ex);
 9798                     }
 99100 
101                  Create bean instance.
102                 *
103                  * 第三步: 创建单例bean实例
104                  105                 if (mbd.isSingleton()) {  处理单例bean
106                     *
107                      * 这里getSingleton()和上面的getSigleton不一样,上面的是从一级缓存中拿.
108                      * 这个getSingleton()就办了一件事: 将bean设置为正在创建的状态. 这个状态很重要,如果出现循环依赖,发现bean正在创建,就不会再创建了
109                      110                     sharedInstance = getSingleton(beanName,() ->111                         112                              createBean(beanName,mbd,args);
113114                          (BeansException ex) {
115                              Explicitly remove instance from singleton cache: It might have been put there
116                              eagerly by the creation process,to allow for circular reference resolution.
117                              Also remove any beans that received a temporary reference to the bean.
118                             destroySingleton(beanName);
119                             throw ex;
120121                     });
122                      得到bean实例对象
123                     bean = getobjectForBeanInstance(sharedInstance,mbd);
124125 
126                 if (mbd.isPrototype()) {  处理多例bean
127                      It's a prototype -> create a new instance.
128                     Object prototypeInstance = 129                     130                          当前正在创建多例bean
131                         beforePrototypeCreation(beanName);
132                          执行创建bean
133                         prototypeInstance =134135                     finally136                         afterPrototypeCreation(beanName);
137138                      获取bean实例对象
139                     bean = getobjectForBeanInstance(prototypeInstance,1)">140141 
142                 else {  处理其他类型的bean
143                     String scopeName = mbd.getScope();
144                     final Scope scope = this.scopes.get(scopeName);
145                     if (scope == 146                         new IllegalStateException(No Scope registered for scope name '" + scopeName + );
147148                     149                         Object scopedInstance = scope.get(beanName,1)">150                             beforePrototypeCreation(beanName);
151                             152                                 153                             }
154                             155                                 afterPrototypeCreation(beanName);
156157                         });
158                         bean = getobjectForBeanInstance(scopedInstance,1)">159160                      (IllegalStateException ex) {
161                          BeanCreationException(beanName,1)">162                                 Scope '' is not active for the current thread; consider " +
163                                 defining a scoped proxy for this bean if you intend to refer to it from a singleton164                                 ex);
165166167168             169                 cleanupAfterBeanCreationFailure(beanName);
170                 171172         } 

 Object sharedInstance = getSingleton(beanName);

　　　　if (sharedInstance != null && args == null) {
             (logger.isTraceEnabled()) {
                判断当前bean是否是正在创建中(单例bean)
                 (isSingletonCurrentlyInCreation(beanName)) {
                    logger.trace(" + beanName +
                            );
                }
                 {
                    logger.trace();
                }
            }
            bean = getobjectForBeanInstance(sharedInstance,null);
        }

*
 29              * 判断当前的bean是不是多例,如果是这抛出异常
 30              *
 31              * 判断当前这个bean是不是多例bean. 如果配置了@Scope("prototype") 就表示这是一个多例的bean
 32              * spring 只能解决单例对象的setter注入的循环依赖,1)">38             }

if (mbd.isSingleton()) {  处理单例bean
mbd.isPrototype()) {  处理多例bean
else {  处理其他类型的bean
166                 }

if (mbd.isSingleton()) { // 处理单例bean
110                     sharedInstance = getSingleton(beanName,() -> {
111                         try {
112                             return createBean(beanName,args);
113                         }
114                         catch (BeansException ex) {
115                             // Explicitly remove instance from singleton cache: It might have been put there
116                             // eagerly by the creation process,to allow for circular reference resolution.
117                             // Also remove any beans that received a temporary reference to the bean.
118                             destroySingleton(beanName);
119                             throw ex;
120                         }
                     });
123                     bean =124                 }

 public Object getSingleton(String beanName,ObjectFactory<?> singletonFactory) {
 2         Assert.notNull(beanName,Bean name must not be null3         synchronized (.singletonObjects) {
 4             // 第一步: 从一级缓存中获取单例对象
 5             Object singletonObject = this.singletonObjects.(beanName);
 6             if (singletonObject == 7                 .singletonsCurrentlyInDestruction) {
 8                      BeanCreationNotAllowedException(beanName,1)">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!)1112                  (logger.isDebugEnabled()) {
13                     logger.debug(Creating shared instance of singleton bean '1415                 // 第二步: 将bean添加到singletonsCurrentlyInCreation中,表示bean正在创建
16                 beforeSingletonCreation(beanName);
17                 boolean newSingleton = false18                 boolean recordSuppressedExceptions = (this.suppressedExceptions == 19                  (recordSuppressedExceptions) {
20                     this.suppressedExceptions = new LinkedHashSet<>();
22                 23                     // 第三步: 这里调用getobject()钩子方法,就会回调匿名函数,调用singletonFactory的createBean()
24                     singletonObject = singletonFactory.getobject();
25                     newSingleton = true2627                 28                      Has the singleton object implicitly appeared in the meantime ->
29                      if yes,proceed with it since the exception indicates that state.
30                     singletonObject = (beanName);
31                     32                         3335                  (BeanCreationException ex) {
36                     37                         for (Exception suppressedException : .suppressedExceptions) {
                             ex.addRelatedCause(suppressedException);
41                     43                 44                     45                         4647                     afterSingletonCreation(beanName);
4849                  (newSingleton) {
                     addSingleton(beanName,singletonObject);
5253              singletonObject;
5455     }

　　　　　　　　　　　　sharedInstance = getSingleton(beanName,1)"> {
                         {
                            // 这里定义了一个钩子函数. 此时只是定义,并不执行. 在真正需要创建bean的地方才会执行
                            return createBean(beanName,args);
                        }
                         (BeansException ex) {
                             Explicitly remove instance from singleton cache: It might have been put there
                            cular reference resolution.
                             Also remove any beans that received a temporary reference to the bean.
                            destroySingleton(beanName);
                             ex;
                        }
                    });

  1 protected Object doCreateBean(final String beanName,final RootBeanDeFinition mbd,final @Nullable Object[] args)
  2             throws BeanCreationException {
  3 
  4          Instantiate the bean.
  5         BeanWrapper instanceWrapper = ;
  6          (mbd.isSingleton()) {
  7             instanceWrapper = .factorybeanInstanceCache.remove(beanName);
  8         }
  9         if (instanceWrapper == ) {
 10             *
 11              * 第一步: 实例化
 12              * 这里面的调用链非常深,后面再看
 13              * bean实例化有两种方式
 14              * 1. 使用反射:  使用反射也有两种方式, 15              *         a. 通过无参构造函数 (默认的方式)
 16              *             从beanDeFinition中可以得到beanClass,1)"> 17              *             ClassName = BeanDeFinition.beanClass
 18              *             Class clazz = Class.forName(ClassName);
 19              *             clazz.newInstance();
 20              *             这样就可以实例化bean了
 21              *
 22              *         b. 通过有参函数.
 23              *            ClassName = BeanDeFinition.beanClass
 24  25              *             Constractor con = class.getConstractor(args....)
 26              *             con.newInstance();
 27  28              * 2. 使用工厂
 29              *         我们使用@Bean的方式,就是使用的工厂模式,自己控制实例化过程
 30  31              */
 32             instanceWrapper = createBeanInstance(beanName,args);
 33  34          这里使用了装饰器的设计模式
 35         final Object bean = instanceWrapper.getWrappedInstance();
 36         Class<?> beanType = instanceWrapper.getWrappedClass();
 37         if (beanType != NullBean.class 38             mbd.resolvedtargettype = beanType;
 39  40 
 41          Allow post-processors to modify the merged bean deFinition.
 42          允许后置处理器修改已经合并的beanDeFinition
 43         synchronized (mbd.postProcessingLock) {
 44             mbd.postProcessed) {
 45                  {
 46                     applyMergedBeanDeFinitionPostProcessors(mbd,beanType,beanName);
 47                 }
 48                  (Throwable ex) {
 49                      50                             Post-processing of merged bean deFinition Failed 51  52                 mbd.postProcessed =  53             }
 54  55 
 56          57          * 缓存单例bean到三级缓存中,以防止循环依赖
 58          * 判断是否是早期引用的bean,如果是,则允许提前暴露引用
 59 　　　　　*
 60          * 判断是否能够早起暴露的条件
 61          *     1. 是单例
 62          *     2. 允许循环依赖
 63          *     3. 正在创建的bean
 64           65         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
 66                 isSingletonCurrentlyInCreation(beanName));
 67          (earlySingletonExposure) {
 68              (logger.isTraceEnabled()) {
 69                 logger.trace(Eagerly caching bean '" + beanName +
 70                         ' to allow for resolving potential circular references);
 71  72              把我们的早期对象包装成一个singletonFactory对象,该对象提供了getobject()方法,把静态的bean放到三级缓存中去了.
 73             addSingletonFactory(beanName,1)"> getEarlyBeanReference(beanName,bean));
 74  75 
 76          Initialize the bean instance.
 77         Object exposedobject = bean;
 78          79              第二步:填充属性,给属性赋值(调用set方法)  这里也是调用的后置处理器
 80             populateBean(beanName,instanceWrapper);
 81             // 第三步: 初始化.
 82             exposedobject = initializeBean(beanName,exposedobject,mbd);
 83  84          85             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
 86                  (BeanCreationException) ex;
 87  88              89                  BeanCreationException(
 90                         mbd.getResourceDescription(),1)">Initialization of bean Failed 91  92  93 
 94          95          * 初始化完成以后,判断是否是早期的对象
 96          * 是循环依赖. 才会走进这里来
 97            98          99              去缓存中获取到我们的对象 由于传递的allowEarlyReference是false,要求只能在一级二级缓存中取
100              正常的普通的bean(不存在循环依赖的bean) 创建的过程中,不会把三级缓存提升到二级缓存中.
101             Object earlySingletonReference = getSingleton(beanName,1)">102             if (earlySingletonReference != 103                 if (exposedobject == bean) {
104                     exposedobject = earlySingletonReference;
105 106                 this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
107                     String[] dependentBeans = getDependentBeans(beanName);
108                     Set<String> actualDependentBeans = (dependentBeans.length);
109                      (String dependentBean : dependentBeans) {
110                         removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
111                             actualDependentBeans.add(dependentBean);
112                         }
113                     }
114                     actualDependentBeans.isEmpty()) {
115                          BeanCurrentlyInCreationException(beanName,1)">116                                 Bean with name '' has been injected into other beans [" +
117                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
118                                 ] in its raw version as part of a circular reference,but has eventually been 119                                 wrapped. This means that said other beans do not use the final version of the 120                                 bean. This is often the result of over-eager type matching - consider using 121                                 'getBeanNamesForType' with the 'allowEagerInit' flag turned off,for example.122 123 124 125 126 
127          Register bean as disposable.
128         129             registerdisposableBeanIfNecessary(beanName,bean,1)">130 131          (BeanDeFinitionValidationException ex) {
132             133                     mbd.getResourceDescription(),1)">Invalid destruction signature134 135 
136          exposedobject;
137     }

 1 　　　　　　　 2  3  4  5              * 1. 使用反射:  使用反射也有两种方式,1)"> 6  7  8  9 10 11 12 13 14 15 16 17 18 19              * 2. 使用工厂
20 21 22              23             instanceWrapper = createBeanInstance(beanName,args);

 　　　　 判断是否能够早起暴露的条件
         *     1. 是单例
         *     2. 允许循环依赖
         *     3. 正在创建的bean
         */
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));    

// 第二步:填充属性,给属性赋值(调用set方法)  这里也是调用的后置处理器
populateBean(beanName,instanceWrapper);

@SuppressWarnings(deprecation")   for postProcesspropertyValues
    protected  populateBean(String beanName,RootBeanDeFinition mbd,@Nullable BeanWrapper bw) {
        if (bw == ) {
             (mbd.hasPropertyValues()) {
                 BeanCreationException(
                        mbd.getResourceDescription(),1)">Cannot apply property values to null instance);
            }
             {
                 Skip property population phase for null instance.
                ;
            }
        }

         Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
         state of the bean before properties are set. This can be used,for example,1)"> to support styles of field injection.
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
             (BeanPostProcessor bp : getBeanPostProcessors()) {
                 (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    ibp.postProcessAfterInstantiation(bw.getWrappedInstance(),beanName)) {
                        ;
                    }
                }
            }
        }

        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : );

         判断属性是否有Autowired注解
        int resolvedAutowireMode = mbd.getResolvedAutowireMode();
         Autowired是根据名字或者根据类型
        if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            // Add property values based on autowire by name if applicable.
            if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
                autowireByName(beanName,bw,newPvs);
            }
            // Add property values based on autowire by type if applicable.
            if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
                autowireByType(beanName,newPvs);
            }
            pvs = newPvs;
        }

        ......
    }

 1  autowireByName(
            String beanName,AbstractBeanDeFinition mbd,BeanWrapper bw,MutablePropertyValues pvs) {
 3 
 4         String[] propertyNames = unsatisfiednonSimpleProperties(mbd,bw);
 5          (String propertyName : propertyNames) {
 6              (containsBean(propertyName)) {
 7                 // 调用getBean
 8                 Object bean = getBean(propertyName);
                pvs.add(propertyName,bean);
                registerDependentBean(propertyName,1)">11                 12                     logger.trace(Added autowiring by name from bean name '13                             ' via property '" + propertyName + ' to bean named '17                 18                     logger.trace(Not autowiring property '' of bean '19                             ' by name: no matching bean found22 23     }

 // 第三步: 初始化.
 exposedobject = initializeBean(beanName,mbd);

*
         * 初始化完成以后,判断是否是早期的对象
         * 是循环依赖. 才会走进这里来
          */
         (earlySingletonExposure) {
            
            Object earlySingletonReference = getSingleton(beanName,1)">);
            ) {
                 bean) {
                    exposedobject = earlySingletonReference;
                }
                 hasDependentBean(beanName)) {
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set<String> actualDependentBeans = (dependentBeans.length);
                     (String dependentBean : dependentBeans) {
                        removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    actualDependentBeans.isEmpty()) {
                        " +
                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                " +
                                );
                    }
                }
            }
        }

 1             /**
 2              * 第二步: 判断当前bean是否是正在创建中的多例bean,如果是就抛出异常
 3              *
 4              * 2. 判断当前这个bean是不是多例bean. 如果配置了@Scope("prototype") 就表示这是一个多例的bean
 5              * spring 只能解决单例对象的setter注入的循环依赖,不能解决构造器注入
 6              *
 7              * 如果是多例的bean,也会抛出异常---这也是循环依赖的问题
 8              */
 9              (isPrototypeCurrentlyInCreation(beanName)) {
10                  BeanCurrentlyInCreationException(beanName);
11             }   

addSingletonFactory(beanName,() -> getEarlyBeanReference(beanName,mbd,bean));

/**
     * 获取bean,根据beanName获取
     */
    public static Object getBean(String beanName) throws Exception {

        // 增加一个出口. 判断实体类是否已经被加载过了
        Object singleton = getSingleton(beanName);
        if (singleton != null) {
            return singleton;
        }
        Object instanceBean;
        synchronized (singletonObjects) {

             标记bean正在创建
            if (!singletonsCurrectlyInCreation.contains(beanName)) {
                singletonsCurrectlyInCreation.add(beanName);
            }

            *
             * 第一步: 实例化
             * 我们这里是模拟,采用反射的方式进行实例化. 调用的也是最简单的无参构造函数
             */
            RootBeanDeFinition beanDeFinition = (RootBeanDeFinition) beanDeFinitionMap.get(beanName);
            Class<?> beanClass = beanDeFinition.getBeanClass();
             调用无参的构造函数进行实例化
            instanceBean = beanClass.newInstance();


            *
             * 第二步: 放入到三级缓存
             * 每一次createBean都会将其放入到三级缓存中. getobject是一个钩子方法. 在这里不会被调用.
             * 什么时候被调用呢?
             * 在getSingleton()从三级缓存中取数据,调用创建动态代理的时候
             
            singletonFactories.put(beanName,new ObjectFactory() {
                @Override
                public Object getobject() throws BeansException {
                    return new JdkProxyBeanPostProcessor().getEarlyBeanReference(earlySingletonObjects.(beanName),beanName);
                }
            });
            earlySingletonObjects.put(beanName,instanceBean);

            *
             *  第三步: 属性赋值
             *  instanceA这类类里面有一个属性,InstanceB. 所以,先拿到 instanceB,然后在判断属性头上有没有Autowired注解.
             *  注意: 这里我们只是判断有没有Autowired注解. spring中还会判断有没有@Resource注解. @Resource注解还有两种方式,一种是name,一种是type
             
            Field[] declaredFields = beanClass.getDeclaredFields();
            for (Field declaredField : declaredFields) {
                 判断每一个属性是否有@Autowired注解
                Autowired annotation = declaredField.getAnnotation(Autowired.class);
                if (annotation != ) {
                     设置这个属性是可访问的
                    declaredField.setAccessible(true);
                     那么这个时候还要构建这个属性的bean.
                    
                     * 获取属性的名字
                     * 真实情况,spring这里会判断,是根据名字,还是类型,还是构造函数来获取类.
                     * 我们这里模拟,所以简单一些,直接根据名字获取.
                     
                    String name = declaredField.getName();

                    *
                     * 这样,在这里我们就拿到了 instanceB 的 bean
                     
                    Object fileObject = getBean(name);

                     为属性设置类型
                    declaredField.set(instanceBean,fileObject);
                }
            }


            *
             * 第四步: 初始化
             * 初始化就是设置类的init-method.这个可以设置也可以不设置. 我们这里就不设置了
             */


            *
             * 第五步: 放入到一级缓存
             *
             * 在这里二级缓存存的是动态代理,那么一级缓存肯定也要存动态代理的实例.
             * 从二级缓存中取出实例,放入到一级缓存中
             */
            if (earlySingletonObjects.containsKey(beanName)) {
                instanceBean = earlySingletonObjects.(beanName);
            }
            singletonObjects.put(beanName,instanceBean);

             删除二级缓存

             删除三级缓存
        }
         instanceBean;
    }

private  Object getSingleton(String beanName) {
        先去一级缓存里拿,
        Object bean = singletonObjects.(beanName);
         一级缓存中没有,但是正在创建的bean标识中有,说明是循环依赖
        if (bean == null && singletonsCurrectlyInCreation.contains(beanName)) {
            synchronized (singletonObjects) {
                bean = earlySingletonObjects.(beanName);
                 如果二级缓存中没有,就从三级缓存中拿
                 从三级缓存中取
                    ObjectFactory objectFactory = singletonFactories.(beanName);
                    if (objectFactory != ) {
                         这里是真正创建动态代理的地方.
                        bean = objectFactory.getobject();
                         然后将其放入到二级缓存中. 因为如果有多次依赖,就去二级缓存中判断. 已经有了就不在再次创建了
                        earlySingletonObjects.put(beanName,bean);
                    }
                }
            }
        }
         bean;
    }

 1 public Object getSingleton(String beanName,ObjectFactory<?> singletonFactory) {
 2         Assert.notNull(beanName,"Bean name must not be null");
 3         synchronized (this.singletonObjects) {
 4              第一步: 从一级缓存中获取单例对象
 5             Object singletonObject = this.singletonObjects.(beanName);
 6             if (singletonObject == ) {
 7                 if (this.singletonsCurrentlyInDestruction) {
 8                     throw  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                  (logger.isDebugEnabled()) {
13                     logger.debug(Creating shared instance of singleton bean '" + beanName + '1415                  第二步: 将bean添加到singletonsCurrentlyInCreation中,表示bean正在创建
16                 beforeSingletonCreation(beanName);
17                 boolean newSingleton = false;
18                 boolean recordSuppressedExceptions = (this.suppressedExceptions == 19                  (recordSuppressedExceptions) {
20                     this.suppressedExceptions = new LinkedHashSet<>();
2122                 try {
23                      第三步: 这里调用getobject()钩子方法,就会回调匿名函数,调用singletonFactory的createBean()
24                     singletonObject = singletonFactory.getobject();
25                     newSingleton = 2627                 catch (IllegalStateException ex) {
28                      Has the singleton object implicitly appeared in the meantime ->
29                      if yes,proceed with it since the exception indicates that state.
30                     singletonObject = (beanName);
31                     ) {
32                         throw ex;
33                     }
3435                  (BeanCreationException ex) {
36                     37                         for (Exception suppressedException : .suppressedExceptions) {
38                             ex.addRelatedCause(suppressedException);
39                         }
4041                     4243                 finally44                     45                         4647                     afterSingletonCreation(beanName);
4849                  (newSingleton) {
50                     addSingleton(beanName,singletonObject);
5152             }
53              singletonObject;
54         }
55     }

protected Object getSingleton(String beanName,boolean allowEarlyReference) {
         从一级缓存中获取bean实例对象
        Object singletonObject = *
         * 如果在第一级的缓存中没有获取到对象,并且singletonsCurrentlyIncreation为true,也就是这个类正在创建.
         * 标明当前是一个循环依赖.
         *
         * 这里有处理循环依赖的问题.-- 我们使用三级缓存解决循环依赖
         */
         isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                *
                 * 从二级缓存中拿bean,二级缓存中的对象是一个早期对象
                 * 什么是早期对象?就是bean刚刚调用了构造方法,还没有给bean的属性进行赋值,和初始化,这就是早期对象
                  

                singletonObject = this.earlySingletonObjects. allowEarlyReference) {
                    *
                     * 从三级缓存拿bean,singletonFactories是用来解决循环依赖的关键所在.
                     * 在ios后期的过程中,当bean调用了构造方法的时候,把早期对象包装成一个ObjectFactory对象,暴露在三级缓存中
                      
                    ObjectFactory<?> singletonFactory = this.singletonFactories.if (singletonFactory != *
                         * 在这里通过暴露的ObjectFactory包装对象. 通过调用他的getobject()方法来获取对象
                         * 在这个环节中会调用getEarlyBeanReference()来进行后置处理
                         
                        singletonObject = singletonFactory.getobject();
                         把早期对象放置在二级缓存中
                        .earlySingletonObjects.put(beanName,singletonObject);
                         删除三级缓存
                        .singletonFactories.remove(beanName);
                    }
                }
            }
         singletonObject;
    }