Spring 循环依赖解决

主题

记录一下spring如何解决循环依赖的问题

首先推荐一下几篇文章

https://www.iflym.com/index.php/code/201208280001.html

这里有3篇文章..写的挺不错的.但是还有略有难懂.我想最简单易懂的记录下我的理解.

3个MAP

BeanFactory中有3个map

/** Cache of singleton objects: bean name to bean instance. */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

/** Cache of singleton factories: bean name to ObjectFactory. */
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

/** Cache of early singleton objects: bean name to bean instance. */
private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

第一个map singletonObjects就是最终结果.BF加工完成的bean都会被丢到这里(同时情况其他2个map)

第二个map singletonFactories是一个中间过程map. 当一个bean被new,但是还没有populate他的属性,就是说还没加工完成,属性都没设置,初始化方法(init-method,afterProperties,或者BeanPostProcessor还没处理它的时候).这个bean会被丢到这个map里.也就是说,每个bean首先会被加到这个map里.当然完全初始化完成的时候就会被remove,丢到第一个map里.

第三个map earlySingletonObjects是专门用于处理循环依赖的.因为A,B循环依赖的时候,需要把A提早暴露出来set到B的属性里.所以这个map的名字也挺能看出作用的.earlySingleton..那意思就是提早暴露的单例.当A引用B再引用A的时候就会把A从singletonFactories中remove,丢到earlySingletonObjects中.(完全初始化完成以后还是会被丢到第一个map里,所以这里也相当于一个中间状态)

流程

首先有BF中3个重要方法会涉及到这3个map..

 /**
     * Return the (raw) singleton object registered under the given name.
     * <p>Checks already instantiated singletons and also allows for an early
     * reference to a currently created singleton (resolving a circular reference).
     * @param beanName the name of the bean to look for
     * @param allowEarlyReference whether early references should be created or not
     * @return the registered singleton object, or <code>null</code> if none found
     */
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                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 != NULL_OBJECT ? singletonObject : null);
    }





/**  
* Add the given singleton factory for building the specified singleton
     * if necessary.
     * <p>To be called for eager registration of singletons, e.g. to be able to
     * resolve circular references.
     * @param beanName the name of the bean
     * @param singletonFactory the factory for the singleton object
     */
    protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        synchronized (this.singletonObjects) {
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }












/**
     * Add the given singleton object to the singleton cache of this factory.
     * <p>To be called for eager registration of singletons.
     * @param beanName the name of the bean
     * @param singletonObject the singleton object
     */
    protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

然后我们来按首先加载bean A的顺序来屡一下过程, 假设配置是这样的

 首先假设BF要加载bean A(先加载B也可以...原理一样..这里假设先加载A)

BF就会掉getSingleton,这个时候allowEarlyReference是true.但是很可惜,3个map都是空的,任何bean都没有..所以啥都没,返回是null.

然后就会去创建A

L588: 这个时候A已经new了.但是还没有到L594的初始化属性.这个时候就会调用addSingletonFactory.这个时候Bean A就会被丢到singletonFactories中去..

然后到了L594这个时候因为A类里有类B的对象需要注入.所以BF会去doGetBean B.然后流程和之前创建A一样..做到populateBean B之前.这个时候singletonFactories中有A和B 2个对象.

然后到了L594去populate B的属性..BF又会去doGetBean A.

这个时候就和第一次创建A的时候有区别了.因为A已经在singletonFactories中了,所以getSingleton方法中会把A从singletonFactories remove掉,丢到earlySingletonObjects中去.同时返回A这个对象.

然后B拿到了还没初始化完成(属性还没设置)的A设置到自己的属性中去.并完成自己的populate..然后B完全初始化以后.会调用ddSingleton方法.把Bean B从singletonFactories中remove掉,丢到singletonObjects中去,标志着B完成初始化,可以被使用了.

B ok了以后,回到A的populate方法.因为属性都已经populate了.所以A也初始化完成了.和B的结束过程一样.也需要丢到singletonObjects中去.只是是从earlySingletonObjects中remove,而不是像B一样从singletonFactories中remove.

至此A,B 2个对象都加工完成.

问题

这么操作会不会有什么问题?

会有的.

1.循环依赖需要单例的bean是通过非构造方法注入的.因为需要在earlySingletonObjects中缓存new了但是还没加工完成bean.

如果需要通过构造方法注入,那Bean就还没new完..所以会出现A需要等B先new.而B需要等A先new.那就无限循环了.

2.A,B不可以被wrap..我们知道BeanPostProcessor等特殊的bean可以替换掉原始的bean.返回其他bean替换掉原本的bean.比如postProcessBeforeInitialization方法.

  

假设我有个BPP对A处理,返回新的bean.如上图

那就会出现B中的A是个原始没被代理(还没经过postProcessBeforeInitialization方法处理)的bean..但是最终BF中的加工完成的A又是经过代理的Bean.这样就会有问题.

spring会检测并报错

exposedObject = initializeBean(beanName, exposedObject, mbd); 这一行中

经过initializeBean处理的bean叫做exposedObject, 它和原本populateBean方法中set到B中的A这个bean(方法里就是bean这个变量名)可能会不一致.如果出现这种情况

就会进入else if线路..检测出A前后变化了..而B中却有原始的A..并且B已经加工完成...对于这样的情况.就会throw BeanCurrentlyInCreationException这个异常..