spring如何解决循环依赖

1年前 (2022) 程序员胖胖胖虎阿
202 0 0

在Spring中,我们使用getBean方法从容器获取一个Bean,那么就从getBean方法入手
AbstractApplicationContext类中的getBean

public Object getBean(String name) throws BeansException {
        assertBeanFactoryActive();
        return getBeanFactory().getBean(name);
    }

接着进入AbstractBeanFactory类中的getBean

public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

再进入到doGetBean方法中,该方法比较长,截取其中比较核心的点来说先说getSingleton方法

//从缓存中获取指定的bean
        Object sharedInstance = getSingleton(beanName);

进入到DefaultSingletonBeanRegistry的getSingleton方法中

public Object getSingleton(String beanName) {
        return getSingleton(beanName, true);
    }
 
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        //先从一级缓存中查找
        Object singletonObject = this.singletonObjects.get(beanName);
        //如果一级缓存中没有,且当前bean正处于创建的过程中
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                //从二级缓存中查找
                singletonObject = this.earlySingletonObjects.get(beanName);
                //如果二级缓存中也没有,且允许暴露早期引用时
                if (singletonObject == null && allowEarlyReference) {
                    //从三级缓存中查找到bean的工厂
                    ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        //调用getObject方法生成bean
                        singletonObject = singletonFactory.getObject();
                        //放入到二级缓存中
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        //从三级缓存中移除
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }
        return singletonObject;
    }

看到这里,Spring在解决循环依赖时,其实也用到了缓存,缓存声明及定义如下:

private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
 
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
 
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

singletonObjects,一级缓存,存放的是最终的成品,即完成实例化(仅调用构造方法)、属性注入、初始化后的
beanearlySingletonObjects,二级缓存,存放的是半成品,或叫早期曝光对象,即只完成实例化,未完成属性注入及初始化的
beansingletonFactories,三级缓存,存放的是能获取到半成品的工厂前几节我们自己解决了循环依赖,一级缓存的存在是为了在单线程的情况下解决循环依赖,而二级缓存的存在是为了兼容多线程,提升获取bean的效率。那三级缓存存在的意义又是什么呢?

解决循环依赖,其中的一个核心前提是bean必须是单例的,因此我们接着看doGetBean方法中第二处核心的代码,即处理单例bean的代码/处理单例bean

    if (mbd.isSingleton()) {
        //sharedInstance就是从缓存中获取的bean,一般来说,这里是null的
        sharedInstance = getSingleton(beanName, () -> {
            try {
                return createBean(beanName, mbd, args);
            } catch (BeansException ex) {
                destroySingleton(beanName);
                throw ex;
            }
        });
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
    }

其中getSingleton方法中的第二个参数是一个函数式接口类型的ObjectFactory,因此这里可以直接使用lambda表达式来传入一个默认的实现,即createBean方法。进入到getSingleton(beanName,objectFactory)方法中,精简后的代码如下:

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        //如果不在缓存中,就会利用getObject方法去创建
        synchronized (this.singletonObjects) {
            Object singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
                //标志当前bean正在创建中,如果被多次创建,这里也会抛出异常
                beforeSingletonCreation(beanName);
                boolean newSingleton = false;
                //执行getObject,即执行外部传入的createBean方法
                singletonObject = singletonFactory.getObject();
                newSingleton = true;
                //省略异常处理,出现异常时,newSingleton=false
                //取消bean正在创建的标志
                afterSingletonCreation(beanName);
                if (newSingleton) {
                    //管理缓存,移除三级缓存与二级缓存,加入到一级缓存中
                    addSingleton(beanName, singletonObject);
                }
            }
            return singletonObject;
        }
    }

当走到getObject方法时,就会进入到AbstractAutowireCapableBeanFactorycreateBean方法中核心的方法是这一句话Object beanInstance = doCreateBean(beanName, mbdToUse, args);接着进入到同类中的doCreateBean方法中,精简之后的代码:

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
 
        // 实例化bean
        BeanWrapper instanceWrapper = createBeanInstance(beanName, mbd, args);
 
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            //加入到三级缓存中,getEarlyBeanReference会返回单例工厂
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
 
        Object exposedObject = bean;
        //属性注入
        populateBean(beanName, mbd, instanceWrapper);
        //初始化
        exposedObject = initializeBean(beanName, exposedObject, mbd);
 
        if (earlySingletonExposure) {
            //从二级缓存中查找
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                //返回二级缓存中的bean,这里就有可能是代理后的对象
                exposedObject = earlySingletonReference;
 
            }
        }
        return exposedObject;
    }

看看getEarlyBeanReference到底返回了什么样的一个单例工厂(但其实说是工厂,不如说是获取早期曝光对象的一个逻辑)

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        //从容器中寻找实现InstantiationAwareBeanPostProcessor接口的后置处理器
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            //遍历找到的所有符合要求的后置处理器
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                //如果后置处理器实现了SmartInstantiationAwareBeanPostProcessor接口
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    //调用SmartInstantiationAwareBeanPostProcessor的getEarlyBeanReference方法
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                }
            }
        }
        return exposedObject;
    }

在getEarlyBeanReference方法中,最终会返回一个经过AOP拦截后生成的代理对象。如果当前没有任何实现InstantiationAwareBeanPostProcessor接口的后置处理器,即当前bean没有被任何AOP拦截后,那直接返回传进来的bean。到这里,源码已经分析得差不多了。以A与B的循环依赖,画一下整个过程
spring如何解决循环依赖

从上面的分析可以看出,解决循环依赖的本质是借助于缓存。

多例下的循环依赖,每次注入的都是一个新的对象,完全用不到缓存,所以无法解决多例下的循环依赖。

在经过自然排序后,如果一开始就是构造器注入,也无法利用到缓存。set注入之所以能利用到缓存,是因为能够将实例化与属性赋值分离,给缓存利用留下余地。

对三级缓存的理解
在单线程的情况,也就是getBean仅支持串行操作的话,那么一级缓存其实已经够用了。

二级缓存将半成品与成品对象分离,使得多线程的情况下,不会拿到不完整的对象实例。而且支持多线程同时查询缓存,在一定程度上提升了性能。

三级缓存存放的是单例对象工厂,准确的说,是函数式接口实现,是生成对象的一段逻辑。如果该对象被代理,则工厂的getObject返回代理之后的对象,否则返回原对象。

这里可能有人有疑问,为什么需要三级缓存呢?在实例化阶段之后,直接将原对象或代理对象放入二级缓存不也行吗?

理论是可以的。

一般来说,在Bean的生命周期中,创建代理是在初始化完成后再做的。

而如果代理出现在循环依赖中,不能等到初始化完成后再做,否则B中注入的A就是原对象,不是代理对象。因此,需要在B的属性注入的前一刻完成对A的代理,而这个阶段,也必然是发生在A的初始化之前。

这个时候,大可以在A实例化之后,如果存在特定的后置处理器,也就是说存在代理,那么直接将A的代理对象放入二级缓存中,不管以后会不会出现循环依赖。事实上,在这个时期,也无法去检测到底之后会不会产生循环依赖,总不能去预知未来吧。如果出现循环依赖,则从二级缓存中获取A的代理对象,注入到B中,这个时候是可以的。如果不发生循环依赖,这个A的代理对象就是无用的,做的是无用功。

这个时候,再加上一层缓存呢?在A实例化之后,只往三级缓存中存放一个生成对象的逻辑。到底是生成代理对象还是原对象,由发生循环依赖时再做决定。当发生循环依赖时,例如当B中需要注入A时,会调用三级缓存中的工厂逻辑,生成A的代理对象,注入进B中。当没发生循环依赖时,A的代理对象还是在初始化完成之后再做,和Bean的生命周期中的处理一致。

所以,三级缓存的存在,是由于对代理的考虑。一方面能避免直接在二级缓存中存放代理对象而之后没发生循环依赖所做的无用功,另一方面也能够最大化的统一Bean的生命周期,可谓两全其美,一箭双雕。

版权声明:程序员胖胖胖虎阿 发表于 2022年11月13日 上午10:24。
转载请注明:spring如何解决循环依赖 | 胖虎的工具箱-编程导航

相关文章

暂无评论

暂无评论...