Spring循环依赖-出现的原因,发现机制和解决方法
SpringBean依赖注入——循环依赖Spring循环依赖出现的原因循环依赖的现象就是Spring的容器在创建Bean的生命周期中,出现了相互依赖的场景,A->B->A,比如上面A的实例属性值是B的实例,B的实例属性值也是A的实例,这样A在进行初始化并且属性赋值的时候发现依赖B,就去实例化B,发现在给B初始化进行属性赋值的时候,也依赖A,这样就出现了最简单的循环依赖。针对上面的问题:
·
SpringBean依赖注入——循环依赖
Spring循环依赖出现的原因
循环依赖的现象就是Spring的容器在创建Bean的生命周期中,出现了相互依赖的场景,A->B->A,
比如上面A的实例属性值是B的实例,B的实例属性值也是A的实例,
这样A在进行初始化并且属性赋值的时候发现依赖B,就去实例化B,发现在给B初始化进行属性赋值的时候,也依赖A,
这样就出现了最简单的循环依赖。
针对上面的问题:首先我们要知道循环依赖只发生在作用域是单例的场景里面,
即scope=“singleton”,
如果作用域是原型,即scope=“prototype”,也会报错,为什么呢?
因为scope="prototype"时,这时候对应的Bean是在使用的时候才会被创建出来,
不会提前被Spring的容器提前创建, 创建出来其生命周期也不受Spring容器的管理。
如果循环依赖会直接报错,(singleton一般是用于无状态的bean,prototype一般用于有状态的bean)如下源码所示:
public abstract class AbstractBeanFactory
extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args,
boolean typeCheckOnly)
throws BeansException {
String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
//.......省略代码
}else {
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
// 这个操作就是判断如果bean是Prototype作用域的会直接报错
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 省略代码。。。。
}
}
}
Spring循环依赖发生的条件
- 首先是发生在Spring容器中
- 涉及到的Bean都是在项目启动要被Spring容器提前创建和管理的
Spring循环依赖发现机制
Spring容器在创建A时,会先去“当前创建bean”池中判断是否已经在池中,如果不存在,就创建bean,在创建之前
会把正在创建的A,放在一个“当前创建bean池”中,
这个池子里面的Bean都是正在创建中的Bean,然后创建A的时候发先依赖B,就去实例化创建B,
同时也会将B放在“当前创建bean”池中,然后发先创建B依赖A,就会去创建A,
但是这时候发现A已经在“当前创建bean”池中了,就知道发生了循环依赖,这就是循环依赖的发现机制
简要说一下这个“当前创建bean”池是个什么,看下面AbstractBeanFactory类的部分代码
下面就看一下isPrototypeCurrentlyInCreation()
public class DefaultSingletonBeanRegistry
extends SimpleAliasRegistry implements SingletonBeanRegistry {
/** Maximum number of suppressed exceptions to preserve. */
private static final int SUPPRESSED_EXCEPTIONS_LIMIT = 100;
/** 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);
/** Set of registered singletons, containing the bean names in registration order. */
private final Set<String> registeredSingletons = new LinkedHashSet<>(256);
// 这个就是上面说的“当前创建bean”池
/** Names of beans that are currently in creation. */
private final Set<String> singletonsCurrentlyInCreation =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
/** Names of beans currently excluded from in creation checks. */
private final Set<String> inCreationCheckExclusions =
Collections.newSetFromMap(new ConcurrentHashMap<>(16));
/** Collection of suppressed Exceptions, available for associating related causes. */
@Nullable
private Set<Exception> suppressedExceptions;
/** Flag that indicates whether we're currently within destroySingletons. */
private boolean singletonsCurrentlyInDestruction = false;
/** Disposable bean instances: bean name to disposable instance. */
private final Map<String, Object> disposableBeans = new LinkedHashMap<>();
/** Map between containing bean names: bean name to Set of bean names that the bean contains. */
private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);
/** Map between dependent bean names: bean name to Set of dependent bean names. */
private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);
/** Map between depending bean names: bean name to Set of bean names for the bean's dependencies. */
private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
// .......省略部分代码
/**
* Return whether the specified singleton bean is currently in creation
* (within the entire factory).
* @param beanName the name of the bean
*/
public boolean isSingletonCurrentlyInCreation(String beanName) {
return this.singletonsCurrentlyInCreation.contains(beanName);
}
// .....省略部分代码
}
从上面源代码我们不难不发现这个“当前创建bean”是个什么玩意儿了,是个存放了“当前创建bean”的name的set集合
Spring 循环依赖解决方案 ——三级缓存
// 一级缓存
/** 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);
- singletonObjects:一级缓存,里面放置的是已经完成所有创建动作的单例对象,也就是说这里存放的bean已经完成了所有创建的生命周期过程,在项目运行阶段当执行多次getBean()时就是从一级缓存中获取的。
- earlySingletonObjects:二级缓存,里面存放的只是进行了实例化的bean,还没有进行属性设置和初始化操作,也就是bean的创建还没有完成,还在进行中,这里是为了方便被别的bean引用
- singletonFactories:三级缓存,Spring中的每个bean创建都有自己专属的ObjectFactory工厂类,三级缓存缓存的就是对应的bean的工厂实例,可以通过该工厂实例的getObject()方法获取该bean的实例。
更多推荐
已为社区贡献5条内容
所有评论(0)