spring 如何检测到循环依赖/如何解决循环依赖

spring针对循环依赖问题 不能完全解决 对于不能解决的只能检测到并抛出异常

1. spring针对构造器方法的 单实例对象和原型对象是无法解决循环依赖问题的

     先说结论,

　　针对单例对象 getSingleton方法中 有个beforeSingletonCreation 方法 这个方法是用来检测循环依赖的

　　原型对象 isPrototypeCurrentlyInCreation方法beforePrototypeCreation方法配合检测循环依赖

　　注: inCreationCheckExclusions和singletonsCurrentlyInCreation 是两个set

protected void beforeSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

　 以AB两个单例对象举例,

　　

Class A(){
    A(B b){
  }  
}

Class B(){
    B(A a){
  }  
}

　　对象A在实例化的时候(getBean方法),会先执行beforeSingletonCreation方法 吧自己的beanName放入set中,然后去执行实例化 解析构造器方法的时候发现 需要用到对象B ,所以去getBean(B) 

 　　B对象在一级缓存是没有的(因为是还未实例化),所以去创建单例B,会执行和A一样的操作,把自己的beanName放入set中,然后解析构造器的时候发现依赖A对象,去一级缓存获取是没有的(因为A对象实例化还未完成 未放入到一级缓存中)

　　所以去实例化A 放入set的时候 发现已经存在及会抛出异常

protected boolean isPrototypeCurrentlyInCreation(String beanName) {
        Object curVal = this.prototypesCurrentlyInCreation.get();
        return (curVal != null &&
                (curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
    }

protected void beforePrototypeCreation(String beanName) {
        Object curVal = this.prototypesCurrentlyInCreation.get();
        if (curVal == null) {
            this.prototypesCurrentlyInCreation.set(beanName);
        }
        else if (curVal instanceof String) {
            Set<String> beanNameSet = new HashSet<>(2);
            beanNameSet.add((String) curVal);
            beanNameSet.add(beanName);
            this.prototypesCurrentlyInCreation.set(beanNameSet);
        }
        else {
            Set<String> beanNameSet = (Set<String>) curVal;
            beanNameSet.add(beanName);
        }
    }

对象在实例化之前会先调用isPrototypeCurrentlyInCreation方法,如果set中没有继续执行,实例化的时候调用beforePrototypeCreation方法 放入set中,在之后的循环依赖中 查询到set中有自己的beanName 则抛出异常

那么spring对set方法注入 是如何解决循环依赖问题的呢,一样先说结论 是使用第三级缓存来解决的

1. 在实例化bean A的时候 先去查看一级缓存中是否有(执行的方法getSingleton)

并且会查询currentlyCreationSet中有没有

2. 处理一下depend-on依赖 或者检查一下是否是抽象等等安全性校验 

3.把单实例的A 的beanName放入currentlyCreationSet中

4. 实例化A对象因为是set注入 所以这时使用的空参构造 去反射出实例对象 得到一个早期对象(未进行属性注入的对象,未执行init方法调用,未进行后处理器处理,早期对象和处理后的对象的内存地址是一样的aop对象除外)

5. 早期实例A封装到objectFactory对象中,放入三级缓存

6. 进行依赖注入 依赖注入的时候发现依赖Bean B 再去执行getBean方法 重复执行1-6步 拿到一个B的早期对象objectFactory 放入到三级缓存

7. 处理B的依赖注入 发现B依赖了A  执行getbean方法 从1开始执行 去一级缓存查询没有 去currentlyCreationSet查询有A 去三级缓存中拿到A的早期实例 放入二级缓存清除三级缓存中的A早期实例并返回这个早期实例 B继续执行完成了B对象的实例 放入一级缓存中 清除掉二三级缓存相关数据

8. 继续执行A的实例化步骤 A完成实例化 存入一级缓存 清除二三级缓存相关数据 

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            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;
    }