文档章节

Spring5.0源码深度解析之SpringBean循环依赖问题解决方案

须臾之余
 须臾之余
发布于 08/01 01:18
字数 1733
阅读 11
收藏 0

Spring循环依赖

什么是Spring的循环依赖?循环依赖会存在哪些问题?

示例:AService依赖BService; BService依赖AService

@Service
public class AService {
    //
    @Autowired
    public BService bService;
}
@Service
public class BService {
    @Autowired
    public AService aService;
}

上面演示的例子就是循环注入

如果改为多例的化,运行时就会报错,循环引用异常,找不到对象

@Scope("prototype")

Spring中的循环依赖问题在单例的情况下,Spring是已经帮我们解决好了,多例没有解决循环依赖问题。

为啥,多例的情况下 Spring没有去解决循环依赖问题?

因为在多例的情况下,设置的多例的对象没有明确哪一个,就会产生循环依赖问题。

Spring多例我们要:如何解决循环依赖问题?

我们可以自己去:明确指定引用那个对象

@Service
@Scope("prototype")
public class AService {
   // @Autowired
    public BService bService;
    // 为什么Aservice在创建的时候 为什么Bservice比ASERVICE 先创建
    public AService() {
        System.out.println("AService被Java的反射技术创建");
    }
    public void setbService(BService bService) {
        this.bService = bService;
    }

}
@Service
@Scope("prototype")
public class BService {
   // @Autowired
    public AService aService;

    public void setaService(AService aService) {
        this.aService = aService;
    }
}
public class SpringApp {
    public static void main(String[] args) {
//        1. ioc容器在创建的时候所有的单例对象是不是会被创建
       AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);
//        // 对例子情况 当你在调用的时候才获取
        AService aSerivce = applicationContext.getBean("AService", AService.class);
        BService bSerivce = applicationContext.getBean("BService", BService.class);
        aSerivce.setbService(bSerivce);
        bSerivce.setaService(aSerivce);
        // 循环引用异常 找不到对象
        /**
         * 思考问题? 如果我们的项目对象必须要是多例? 而且必须要循环引用  明确的指定引用那个对象
         */
        String[] beanDefinitionNames = applicationContext.getBeanDefinitionNames();
        for (int i = 0; i < beanDefinitionNames.length; i++) {
            System.out.println(beanDefinitionNames[i]);
        }

SpringBean循环依赖三级缓存概念

思考问题:单例对象在什么时候创建?

在IOC容器被创建的时候创建

多例的情况下,是在getbean()调用的情况下创建。多例对象每次用完就会去销毁掉。

SpringBean Aservice对象被创建流程步骤源码分析

AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(MyConfig.class);

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Instantiate all remaining (non-lazy-init) singletons.
beanFactory.preInstantiateSingletons();

public Object getBean(String name) throws BeansException {
    return this.doGetBean(name, (Class)null, (Object[])null, false);
}

public Object getSingleton(String beanName) {
    return this.getSingleton(beanName, true);
}

获取缓存对象:

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);    //根据BeanName去集合中查,查到就返回这个对象,【】【】【】一级缓存对象集合【】【】【】缓存完整对象【】【】完整对象表示对象已经创建完了,并且对象属性已经赋值了。
    if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
        Map var4 = this.singletonObjects;
        synchronized(this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);    //查询二级缓存中是否有缓存对象
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);    //查询三级缓存,三级缓存中有的化,将三级缓存中的数据放入二级缓存中
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

一级缓存没有找到,就去找二级缓存中找

singletonObject == null && this.isSingletonCurrentlyInCreation(beanName) //一级缓存没有,并且singletonsCurrentlyInCreation判断是否之前标记为该对象开始创建

if (isPrototypeCurrentlyInCreation(beanName)) { //我们对象是单例的,所有不进入
   throw new BeanCurrentlyInCreationException(beanName);
}

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 + "'");
         }
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
            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;
            }
            afterSingletonCreation(beanName);
         }
         if (newSingleton) {
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

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

标识为该对象开始创建

最终调用

正真去创建我们的Bean对象:

既然要创建对象,先反射走无参构造函数,对象先实例化完成,在赋值

执行这个方法,输出构造函数打印的语句,说明底层通过Java反射机制初始化的

在这之前,我们的对象属于婴儿对象,因为它的属性还没有赋值。都是称为婴儿对象。

那么什么时候赋值呢?

populateBean(beanName, mbd, instanceWrapper);//这里给对象属性赋值

在给对象属性赋值之前:

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(singletonFactory, "Singleton factory must not be null");
   synchronized (this.singletonObjects) {
      if (!this.singletonObjects.containsKey(beanName)) {    //【】【】如果一级缓存没有该对象的情况下,会将该对象存放在三级缓存中
         this.singletonFactories.put(beanName, singletonFactory);    //【】【】存放在三级缓存中,对象实例化完成,但是没有赋值,婴儿对象【】【】
         this.earlySingletonObjects.remove(beanName);
         this.registeredSingletons.add(beanName);
      }
   }
}

A对象坚持依赖B对象,这时候B对象也需要被创建

A对象已经存放在三级缓存中,这时候要去创建B对象

此时B对象也要走A对象流程

看下调用链

也将B对象放入三级缓存

总结下:

AService在创建的时候,提前曝光存放到三级缓存中,AService发现依赖BService,这时候Bservice提前曝光存放到三级缓存中去。

此时BService又依赖AService,此时BService经过赋值是完整对象,但是Aservice还是婴儿对象,没有完全创建完毕。

就会去把BService对象注册到一级缓存中,同时会把之前缓存BService对象的二级缓存清除掉

AService对象依赖BService,BService此时已经创建成功了,那么AService在设置属性后,就直接把BService赋值给AService。

开始注册AService对象

总结:

 SpringBean中 Aservic对象被创建流程步骤源码分析:

  1. doGetBean创建我们bean对象
  2. getSingleton (beanName) 获取缓存对象

注意:完整对象概念:对象已经实例化成功并且所有属性都已经赋值

  • singletonObjects 一级缓存完整对象
  • earlySingletonObjects 二级缓存 缓存婴儿对象
  • singletonFactories 三级缓存存放婴儿对象

理解概念:

  1. 完整对象表示该对象实例化完成并且所有的属性已经赋值。
  2. 婴儿对象(提前对象)对象已经实例化完成但是属性没有赋值的。

singletonObject ==null&&this.singletonsCurrentlyInCreation.contains(beanName);

{

才能够查询二级缓存

}
singletonsCurrentlyInCreation :标记为该对象开始创建

  1. getSingleton(String beanName, ObjectFactory<?> singletonFactory)

this.singletonsCurrentlyInCreation.add(beanName) 表示该对象已经开始创建

  1. createBean() →doCreateBean
  2. addSingletonFactory  将婴儿对象(不完整对象也就是只是实例化完成但是属性没有赋值的) 存放三级缓存中。
  3. A对象已经存放到三级缓存中,开始给对象属性赋值的时候 需要创建B对象。

A对象检查发现依赖B对象 这时候B对象也需要被创建

本文参考:

蚂蚁课堂

http://www.mayikt.com/

 

© 著作权归作者所有

须臾之余
粉丝 125
博文 68
码字总数 178724
作品 0
吉安
程序员
私信 提问
Spring5对比Spring3.2源码之容器的基本实现

最近看了《Spring源码深度解析》,该书是基于Spring3.2版本的,其中关于第二章容器的基本实现部分,目前spring5的实现方式已有较大改变。 Spring3.2的实现: 容器的基础XmlBeanFactory已经被...

Ilike_Java
2018/10/17
145
0
通过循环依赖问题彻底理解SpringIOC的精华

前言 你可能会有如下问题: 1、想看Spring源码,但是不知道应当如何入手去看,对整个Bean的流程没有概念,碰到相关问题也没有头绪如何下手 2、看过几遍源码,没办法彻底理解,没什么感觉,没...

Java填坑之路
2018/11/19
0
0
掰弯Wicket: 让wicketstuff-restannotations与wicket-spri

啊哈,掰弯Wicket这个题目有点吓人啊,真实的情况是为了让已经带有Spring属性的wicket与rest化,吾想破了脑壳,找遍了google,花了大半天才找到解决方法,详细情况看我娓娓道来~ 起因 公司的...

奋斗到天明
2015/11/19
88
2
Spring 的 getBean 方法源码解析

文本将从以下几个方面介绍 相关文章 FactoryBean 接口 BeanFactory 接口 BeanFactory 接口 和 FactoryBean 接口的区别 getBean 方法的源码解析 Spring 循环依赖的解决方式 相关文章 Spring 中...

TSMYK
2018/12/16
338
0
Spring Boot Thymeleaf 解析出错

 原因就是Spring Boot 默认依赖的是低版本的Thymeleaf,低版本的Thymeleaf不能解析HTML5格式的HTML代码,而是把HTML当成XML解析,所有标签必须闭合!  但是!我试过把标签都闭合之后还是会...

SoneWinstone
2016/12/21
371
0

没有更多内容

加载失败,请刷新页面

加载更多

经典系统设计面试题解析:如何设计TinyURL(二)

原文链接:https://www.educative.io/courses/grokking-the-system-design-interview/m2ygV4E81AR 编者注:本文以一道经典的系统设计面试题:《如何设计TinyURL》的参考答案和解析为例,帮助...

APEMESH
今天
7
0
使用logstash同步MySQL数据到ES

概述   在生成业务常有将MySQL数据同步到ES的需求,如果需要很高的定制化,往往需要开发同步程序用于处理数据。但没有特殊业务需求,官方提供的logstash就很有优势了。   在使用logstas...

zxiaofan666
今天
10
0
X-MSG-IM-分布式信令跟踪能力

经过一周多的鏖战, X-MSG-IM的分布式信令跟踪能力已基本具备, 特点是: 实时. 只有要RX/TX就会实时产生信令跟踪事件, 先入kafka, 再入influxdb待查. 同时提供实时sub/pub接口. 完备. 可以完整...

dev5
今天
7
0
OpenJDK之CyclicBarrier

OpenJDK8,本人看的是openJDK。以前就看过,只是经常忘记,所以记录下 图1 CyclicBarrier是Doug Lea在JDK1.5中引入的,作用就不详细描述了,主要有如下俩个方法使用: await()方法,如果当前线...

克虏伯
今天
8
0
实战项目-学成在线(八)

在前后端分离架构中,服务层被拆分成了很多的微服务,微服务的信息如何管理?Spring Cloud中提供服务注册中心来管理微服务信息。 注册中心作用: 1、微服务数量众多,要进行远程调用就需要知...

lianbang_W
今天
7
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部