Spring启动过程+三级缓存+循环依赖详解

Spring的三级缓存

Springboot版本：2.3.2
寻找bean加载位置
下面我们找一下bean加载的位置

注意

找到的不是所有bean加载的位置，有一些bean在这一步之前就加载好了，比如系统、Spring需要先加载的bean，我们找的是其他大部分bean的加载位置（@Controller、@Service等注解的bean）

从启动类出发，中间会跳过一些方法或接口，见到方法点进去就完事儿了

走到doGetBean方法，下面就有很多逻辑都可以看，下面这个表格不是递进的顺序，是doGetBean方法中并列的一些操作，因为本主题只涉及单例bean，所以只看下面代码
代码 简介
Object sharedInstance = getSingleton(beanName); 从缓存取bean
sharedInstance = getSingleton(beanName, () -> {return createBean(beanName, mbd, args);}）
如果isSingleton()，创建单例bean
三级缓存（和他们的朋友们）

三级缓存所属的类叫DefaultSingletonBeanRegistry

此类中的三级缓存：singletonObjects、earlySingletonObjects、singletonFactories，除了他们仨，还有一些辅助的缓存，例如singletonsCurrentlyInCreation，来记录正在创建的bean

/**
     * Cache of singleton objects: bean name to bean instance.
     * 单例对象的缓存：bean名称->bean实例
     * 第一级缓存，存放实例化好的单例对象
     */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    /**
     * Cache of early singleton objects: bean name to bean instance.
     * 早期单例对象的缓存：bean名称->bean实例
     * 第二级缓存，存放提前曝光的实例对象
     */
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

    /**
     * Cache of singleton factories: bean name to ObjectFactory.
     * 单例工厂的缓存：bean名称->ObjectFactory
     * 第三级缓存，存放要被实例化的对象的对象工厂
     */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

	/**
     * Names of beans that are currently in creation.
     * 存放正在创建的bean
     */
    private final Set<String> singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

	/**
     * Set of registered singletons, containing the bean names in registration order.
     * 一组已注册的单例实例，bean名称按注册顺序排列
     */
    private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

bean创建与循环依赖解决流程
从缓存取bean

尝试从各级缓存取bean

先从一级缓存singletonObjects中获取

如果获取不到，并且对象正在创建中

再从二级缓存earlySingletonObjects中获取

如果还是获取不到就从三级缓存singletonFactories中取

如果三级缓存有，则移入二级缓存并返回，否则返回null，执行创建bean

	/**
     * 返回指定名称的 已注册的原始单例对象
     * 检查已实例化单例对象，也允许当前创建的单例使用一个早期引用）（解决了循环依赖）
     */
    @Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
   
        //尝试从一级缓存singletonObjects中获取
        Object singletonObject = this.singletonObjects.get(beanName);
        //如果获取一级缓存singletonObjects拿不到，并且bean在创建中（缓存singletonsCurrentlyInCreation获取到了），再执行以下逻辑，否则说明又没创建好也没创建中，方法直接返回null
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
   
            //“给爷锁住！” 防止其他地方操作singletonObjects引起的并发安全问题
            synchronized (this.singletonObjects) {
   
                //尝试从二级缓存earlySingletonObjects中获取
                singletonObject = this.earlySingletonObjects.get(beanName);
                //二级也拿不到，尝试从三级缓存singletonFactories中获取，入参allowEarlyReference是true的
                if (singletonObject == null && allowEarlyReference) {
   
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    //三级也拿不到，是真没有，可以返回个空了
                    if (singletonFactory != null) {
   
                        //如果三级拿到了，三级缓存移动到了二级缓存
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

创建bean

缓存中获取不到时，再走创建流程

走到

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

的

protected Object createBean(String beanName