SpringloC容器的依赖注入源码解析(8)—— 单例循环依赖的解决

本文涉及的产品
容器镜像服务 ACR,镜像仓库100个 不限时长
简介: 这一讨论的前提是要对Spring的doCreateBean方法有所了解,故将其源码放在这里,以供参考:

这一讨论的前提是要对Spring的doCreateBean方法有所了解,故将其源码放在这里,以供参考:

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {
   // Instantiate the bean.
   // bean实例包装类
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
      // 从未完成创建的包装Bean缓存中清理并获取相关中的包装Bean实例,毕竟是单例的,只能存一份
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
      //创建bean的时候,这里创建bean的实例有三种方法
      // 1.工厂方法创建
      // 2.构造方法的方式注入
      // 3.无参构造方法注入
      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.
   // 调用BeanDefinition属性合并完成后的BeanPostProcessor后置处理器
   synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
         try {
            // 被@Autowired、@Value标记的属性在这里获取
            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.
   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");
      }
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
   }
   // Initialize the bean instance.
   Object exposedObject = bean;
   try {
      populateBean(beanName, mbd, instanceWrapper);
      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 {
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }
   catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
   }
   return exposedObject;
}


对应的文章《SpringloC容器的依赖注入源码解析(7)—— doCreateBean之剩余逻辑(解决循环依赖的源头)》


现在有A依赖B,B也依赖A,假设A先创建,就会来到doCreateBean方法里,会经过各种包装,在被

instanceWrapper = createBeanInstance(beanName, mbd, args);


处理了之后生成一个没有任何属性的A的实例。


之后在调用


addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));


14.png

之前将A实例放入到ObjectFactory里面,然后调用addSingletonFactory将ObjectFactory添加到三级缓存里,此时只有三级缓存保存了A对应的ObjectFactory实例。


随后就会调用


populateBean(beanName, mbd, instanceWrapper);


给属性赋值,由于A依赖于B,在populate里会尝试获取实例B,由于B还没有被创建过,所以又递归的调用doCreateBean方法。


在doCreateBean方法里调用


instanceWrapper = createBeanInstance(beanName, mbd, args);


创建出实例B,将其对应的实例工厂放入到三级缓存中,此时三级缓存中就保存了A和B的实例,随后在B里又会执行

populateBean(beanName, mbd, instanceWrapper);


由于B依赖A,所以在populate里尝试获取A的实例,此时调用的是AbstractBeanFactory的doGetBean方法,在里面调用:

Object sharedInstance = getSingleton(beanName);

从三级缓存里获取A实例对应的ObjectFactory实例


15.png


这里getObject()调用的就是getEarlyBeanReference方法


16.png


获取到A实例之后就会将A实例放入二级缓存里,同时清空三级缓存里的A


此时就回到创建B的doCreateBean的

populateBean(beanName, mbd, instanceWrapper);


A被注入到B里面了,即当B执行完populateBean之后就已经获取到了A,此时B就会执行完剩余逻辑获得到一个完备的B,此时方法返回到doGetBean方法里


17.png


在getSingleton方法里面会最终调用

addSingleton(beanName, singletonObject);


在方法里会将实例B添加到一级缓存里,并将B从二三级缓存里移除,表示已经彻底完成了B实例的创建,之后返回B。


B之所以会被创建是因为A调用了


populateBean(beanName, mbd, instanceWrapper);

此时又回到这个地方,A内部已经赋值上了完备的B,之后步骤同上,调用addSingleton将A放入一级缓存里,此时循环依赖的支持完成。


整个的流程图如下图所示,大家可以基于前面的介绍看一下到底有没有掌握 ~:


18.png




相关文章
|
4月前
|
Java Linux Maven
java依赖冲突解决问题之容器加载依赖jar包如何解决
java依赖冲突解决问题之容器加载依赖jar包如何解决
|
2月前
|
存储 编译器 C++
【C++篇】揭开 C++ STL list 容器的神秘面纱:从底层设计到高效应用的全景解析(附源码)
【C++篇】揭开 C++ STL list 容器的神秘面纱:从底层设计到高效应用的全景解析(附源码)
59 2
|
4月前
|
设计模式 测试技术 PHP
深入解析 Laravel 中的依赖注入
【8月更文挑战第31天】
73 0
|
4月前
|
开发者 Java
Play Framework深度解析:依赖注入的神秘力量,如何助力Web应用架构优化?答案即将揭晓!
【8月更文挑战第31天】依赖注入(DI)是现代软件开发的关键技术,用于分离对象创建与依赖关系,提升代码的可维护性和可测试性。Play Framework是一款高性能Java Web框架,内置了基于Google Guice的DI支持。本文探讨Play Framework中DI的最佳实践,包括定义组件、构造函数注入、字段注入以及作用域控制和自定义绑定等高级特性,帮助开发者轻松构建结构清晰、可维护性高的Web应用。
54 0
|
4月前
|
Java 测试技术 数据库
容器镜像解析问题之解析 Java 应用依赖时识别 jar 包如何解决
容器镜像解析问题之解析 Java 应用依赖时识别 jar 包如何解决
30 0
|
6月前
|
存储 安全 Java
2024ide构建maven项目是总是卡在解析Maven依赖项目 加速方案
2024ide构建maven项目是总是卡在解析Maven依赖项目 加速方案
251 4
2024ide构建maven项目是总是卡在解析Maven依赖项目 加速方案
|
6月前
|
Linux 数据处理 开发者
Linux命令ldd:深入解析动态链接器依赖关系
`ldd`是Linux下分析可执行文件动态依赖的工具,它揭示了程序运行所需的共享库。通过模拟动态链接过程,`ldd`列出库文件路径,帮助理解程序环境和解决运行时问题。主要参数包括`-d`、`-r`、`-u`和`-v`。例如,`ldd my_program`展示`my_program`的依赖关系。注意,`ldd`不显示间接依赖,完整依赖树可能需借助其他工具。确保系统库完整且版本兼容是使用`ldd`时的关键。
|
7月前
|
消息中间件 运维 监控
|
7月前
|
算法 项目管理 开发者
【Conan 入门教程 】深入解析Conan中的依赖关系的定义方法(In-depth Analysis of Dependency Definition Methods in Conan)
【Conan 入门教程 】深入解析Conan中的依赖关系的定义方法(In-depth Analysis of Dependency Definition Methods in Conan)
293 0
|
7月前
|
编译器 Linux C语言
Valgrind兼容性解析:从核心依赖到错误诊断
Valgrind兼容性解析:从核心依赖到错误诊断
259 0

推荐镜像

更多