1. 代码示例
- A.java
- B.java
2. 核心代码
- 这里直接看循环依赖相关的核心方法
2.1 AbstractBeanFactory#doGetBean()
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 1.从缓存中拿实例
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName);
// 2.如果缓存里面能拿到实例
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 3.该方法是FactoryBean接口的调用入口
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 4.如果singletonObjects缓存里面没有，则走下来
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
//如果是scope 是Prototype的，校验是否有出现循环依赖，如果有则直接报错
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 (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}
if (!typeCheckOnly) {
markBeanAsCreated(beanName);
}
try {
//父子BeanDefinition合并
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 dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
//实例化
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}
// 5.着重看，大部分是单例的情况
// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
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;
}
});
// 6.该方法是FactoryBean接口的调用入口
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 name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
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);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// Check if required type matches the type of the actual bean instance.
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isTraceEnabled()) {
logger.trace("Failed to convert bean '" + name + "' to required type '" +
ClassUtils.getQualifiedName(requiredType) + "'", ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
2.2 DefaultSingletonBeanRegistry#getSingleton(String beanName)
- 先从一级缓存拿，A第一次进来肯定拿不到，再从二级缓存中拿，二级缓存这时候也没有，就会从三级缓存中拿到对象工厂，还是nul，返回空对象singletonObject。
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//根据beanName从缓存中拿实例
//先从一级缓存拿
Object singletonObject = this.singletonObjects.get(beanName);
//如果bean还正在创建，还没创建完成，其实就是堆内存有了，属性还没有DI依赖注入
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
//从二级缓存中拿
singletonObject = this.earlySingletonObjects.get(beanName);
//如果还拿不到，并且允许bean提前暴露
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;
}
2.3 回到2.1步，DefaultSingletonBeanRegistry#getSingleton(String beanName, ObjectFactory<?> singletonFactory)
- 缓存里都拿不到A的实例，就会走到这个getSingleton()方法；
- createBean(beanName, mbd, args)这个方法会创建一个A的实例，通过这个ObjectFactory对象的getObject()方法就可以得到这个创建出来的A的实例；
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "Bean name must not be null");
synchronized (this.singletonObjects) {
//如果缓存中有，则直接返回
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//把beanName添加到singletonsCurrentlyInCreation Set容器中，在这个集合里面的bean都是正在实例化的bean
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<>();
}
try {
//如果这里有返回值，就代表这个bean已经结束创建了，已经完全创建成功
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//bean创建完成后singletonsCurrentlyInCreation要删除该bean
afterSingletonCreation(beanName);
}
if (newSingleton) {
System.out.println("====beanName==" + beanName + "===instance end====");
//创建对象成功时，把对象缓存到singletonObjects缓存中,bean创建完成时放入一级缓存
addSingleton(beanName, singletonObject);
}
}
return singletonObject;
}
}
- 把beanName添加到singletonsCurrentlyInCreation Set容器中，在这个集合里面的bean都是正在实例化的bean
- 这里会调到外部那个lamdba表达式，匿名类中createBean方法，该方法会创建完一个实例并返回，如果这里有返回值，就代表这个bean已经结束创建了，已经完全创建成功
- A实例已经通过createBean()方法创建成功，则从正在实例化的bean的缓存singletonsCurrentlyInCreation中移除
- A创建成功后，把A缓存到一级缓存singletonObjects中，后面会再次提到这个结论
//一级缓存添加
this.singletonObjects.put(beanName, singletonObject);
//三级缓存删除
this.singletonFactories.remove(beanName);
//二级缓存删除
this.earlySingletonObjects.remove(beanName);
2.4 AbstractAutowireCapableBeanFactory#doCreateBean()
- 进入createBean的核心代码
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//创建实例,,重点看，重要程度：5
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
//CommonAnnotationBeanPostProcessor 支持了@PostConstruct，@PreDestroy,@Resource注解
//AutowiredAnnotationBeanPostProcessor 支持 @Autowired,@Value注解
//BeanPostProcessor接口的典型运用，这里要理解这个接口
//对类中注解的装配过程
//重要程度5，必须看
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//是否 单例bean提前暴露
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//这里着重理解，对理解循环依赖帮助非常大，重要程度 5 添加三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//ioc di，依赖注入的核心方法，该方法必须看，重要程度：5
populateBean(beanName, mbd, instanceWrapper);
//bean 实例化+ioc依赖注入完以后的调用，非常重要，重要程度：5
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
//注册bean销毁时的类DisposableBeanAdapter
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
- 实例创建成功
- earlySingletonExposure是true，走下面的代码，添加三级缓存
- 只有A创建成功后，把A缓存到一级缓存singletonObjects中，所以这时候singletonObjects里拿不到A，会进入if，添加匿名类和beanName的对应关系到三级缓存。
//添加匿名类和beanName的对应关系到三级缓存
this.singletonFactories.put(beanName, singletonFactory);
//从二级缓存删除
this.earlySingletonObjects.remove(beanName);
- 这个匿名类就是A这个bean，只是这个bean没有属性，因为还没有执行到ioc依赖注入的方法populateBean()
- getEarlyBeanReference(beanName, mbd, bean)，循环所有SmartInstantiationAwareBeanPostProcessor类型的BeanPostProcessor类，返回bean
- 这个方法只是把你传进来的bean又返回给你了，什么都没做
- 三级缓存设置成功，走到ioc依赖注入方法，populateBean()
- 因为A类中依赖注入了B，所以会触发B的doGetBean() 方法，B开始从2.1步开始走一遍流程；
- 这个时候的A的实例化还没有完成，停留在populateBean()方法，等待B去实例化。
2.5 B类执行doGetBean()
- 按照2.1步到2.4步执行代码，过程和A一模一样；
- 走到2.4步的ioc依赖注入的populateBean()方法，触发A的doGetBean()；
- 这时是A的第二次doGetBean()，在执行到2.2步getSingleton(String beanName)方法时
- 三级缓存内可以拿到A，把A放入二级缓存，再从三级缓存中删除
- 这里A中的B是一个半成品，因为B的属性还没有注入
- sharedInstance!=null，进入if，得到bean
- 代码不会进入else，直接走到最后一行，return A对象
- A实例化完成，afterSingletonCreation()把beanName从singletonsCurrentlyInCreation中删除，addSingleton()添加一级缓存。
- 经过2轮doGetBean()，A中的B，B中的A都是实例化完成的Bean。
- 循环依赖过程结束。
2.6 流程
A实例化开始
调用A的无参构造函数
设置三级缓存A类对应的匿名对象
A类触发B的doGetBean()
B实例化开始
调用B的无参构造函数
设置三级缓存B类对应的匿名对象
B类触发A的doGetBean()
A实例化开始
从三级缓存中拿到A对应的匿名对象（这时后A中的B是还没有属性赋值的半成品）
B实例化结束
A实例化结束
2.7 缓存
- A第一次执行doGetBean，addSingletonFactory()
//添加到三级缓存
this.singletonFactories.put(beanName, singletonFactory);
//从二级缓存删除
this.earlySingletonObjects.remove(beanName);
- A第二次执行doGetBean，getSingleton()
//添加到二级缓存
this.earlySingletonObjects.put(beanName, singletonObject);
//从三级缓存删除
this.singletonFactories.remove(beanName);
- A创建后addSingleton()
//一级缓存添加
this.singletonObjects.put(beanName, singletonObject);
//三级缓存删除
this.singletonFactories.remove(beanName);
//二级缓存删除
this.earlySingletonObjects.remove(beanName);
- 最后所有的bean都会存在一级缓存中
3. 二级缓存的作用
- 提交获取singletonObject的效率
- 添加一个C类
- A同时依赖B和C
- B把A从三级缓存升级到二级缓存，当C再执行getSingleton(String beanName, boolean allowEarlyReference)时，可以直接从二级缓存中拿到A，不需要走三级缓存。
- 如果没有二级缓存，只有三级缓存，每次拿A都需要去循环所有BeanPostProcessor的类，来获取A。
4. 不支持有参构造函数
- createBeanInstance(beanName, mbd, args)中，如果有@Autowired注解的有参构造函数，如果函数是一个引用类型，就会触发这个引用类型的getBean操作
- 还没有走到添加三级缓存的代码，就提前doGetBean()了
- 所以在A第二次执行doGetBean()时，getSingleton(beanName)返回null，因为三级缓存里没有添加A
- 代码和第一次进来一样，又会执行到这个getSingleton()
- 又执行到beforeSingletonCreation(beanName)
- 又往singletonsCurrentlyInCreation内添加一次A，因为里面已经有A了，所以会返回false，进入if，抛出异常，所以有参构造函数不支持循环依赖。
- singletonsCurrentlyInCreation可以用来阻断非属性方式和非单例情况下的循环依赖。
- 有参构造函数参数没有值，对象是不能创建成功；
- A要实例化，但是入参B没有属性，A不能实例化成功；
- B的实例化又要依靠A，A的属性也不完整，B也不能实例化成功，所以会出现死锁。
5. 不支持多例
- 只有属性方式而且是单例的依赖注入才能循环依赖
总结
- 第一个getSingleton
- 根据beanName先从一级缓存拿，如果拿不到，而且是正在实例化的 bean，就从二级缓存中拿
- 如果二级缓存也拿不到，并且允许bean提前暴露，从三级缓存中拿到对象工厂
- 如果对象工厂不为空，获取对象，放到二级缓存，删除三级缓存
- 最后就是缓存中有对象就返回，没有就返回空对象
- 第二个getSingleton
- 缓存中没有，加入到singletonsCurrentlyInCreation正在实例化的 bean的集合中
- 创建bean（通过推断构造方法反射调用创建bean）
- 如果是单例的，允许循环依赖，是正在实例化的bean，addSingletonFactory就把这个正在实例化但是还没有属性的bean添加到三级缓存singletonFactories，从二级缓存删除（因为还没有执行到ioc依赖注入的方法populateBean）
- 三级缓存设置成功，走到ioc依赖注入方法，populateBean()，触发B的doGetBean()方法，等待B去实例化
- B也会执行到populateBean()方法，触发A的doGetBean()，第二次执行第一个getSingleton(String beanName)方法，这时候三级缓存内可以拿到A，把A放入二级缓存，再从三级缓存中删除
- 这里A中的B是一个半成品，因为B的属性还没有注入，最后B会通过InjectionMetadata对象inject方法完成属性和方法的注入
- bean创建完成后singletonsCurrentlyInCreation要删除该bean，添加一级缓存，三级和二级缓存删除
708
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
