在Teradata的一次Java面试,说到了一个spring的循环依赖的问题:
A依赖B,B依赖C,C依赖A,这个会不会有问题。
按照面试人的说法,创建A之前创建B,创建B之前创建C,创建C正好创建A,
不屑一顾的说,这没问题啊,完全可以建立起来。
这段代码是spring创建bean的一个过程,从上面可以看出创建bean之前,他的依赖一定是创建好的,而不是先创建bean再创建依赖。
第一句代码,明确指出了,是否是循环依赖,抛出异常。
所以创建A时,必须先创建B,创建B必须创建C,创建C就必须先建立A。而A又处于创建中,
即:
所以要抛出异常:
Error creating bean with name 'beanName ': Requested bean is currently in creation: Is there an unresolvable circular reference?
现在想来真是无语,技术是用来探讨学习的。
A依赖B,B依赖C,C依赖A,这个会不会有问题。
按照面试人的说法,创建A之前创建B,创建B之前创建C,创建C正好创建A,
不屑一顾的说,这没问题啊,完全可以建立起来。
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
getBean(dependsOnBean);
registerDependentBean(dependsOnBean, beanName);
}
}
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; " +
"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
这段代码是spring创建bean的一个过程,从上面可以看出创建bean之前,他的依赖一定是创建好的,而不是先创建bean再创建依赖。
第一句代码,明确指出了,是否是循环依赖,抛出异常。
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
所以创建A时,必须先创建B,创建B必须创建C,创建C就必须先建立A。而A又处于创建中,
即:
if (isPrototypeCurrentlyInCreation(beanName))
所以要抛出异常:
Error creating bean with name 'beanName ': Requested bean is currently in creation: Is there an unresolvable circular reference?
现在想来真是无语,技术是用来探讨学习的。