精华内容
下载资源
问答
  • A依赖于B,B依赖于C,C依赖于A <beans> <!--A依赖于B B加载完再加载A--> <bean class="com.skr.pojo.A" name="a" depends-on="b"></bean> <!--B依赖于C C加载完再加载B--> <...

    A依赖于B,B依赖于C,C依赖于A

    <beans>
      <!--A依赖于B B加载完再加载A-->
      <bean class="com.skr.pojo.A" name="a" depends-on="b"></bean>
      <!--B依赖于C C加载完再加载B-->
      <bean class="com.skr.pojo.B" name="b" depends-on="c"></bean>
      <!--C依赖于A A加载完再加载C-->
      <bean class="com.skr.pojo.C" name="c" depends-on="a"></bean>
    </beans>
    

    此时说如果让Spring容器创建A的对象就会报如下错误

    Exception in thread "main" org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'c' defined in class path resource
    [applicationContext1.xml]: Circular depends-on relationship between 'c' and 'a'
    

    即不能创建C的实例,A和C是循环的依赖关系

    展开全文
  • Spring如何解决循环依赖问题

    万次阅读 多人点赞 2020-12-09 02:23:10
    1、什么循环依赖:类与类之间的依赖关系形成了闭环,就导致循环依赖问题的产生。 2、循环依赖问题在Spring中主要三种情况: (1)通过构造方法进行依赖注入时产生的循环依赖问题。 (2)通过setter方法进行...

    一、循环依赖问题全景图

     

    二、什么是循环依赖问题?

    1、什么是循环依赖:

    类与类之间的依赖关系形成了闭环,就会导致循环依赖问题的产生。

    比如下图中A类依赖了B类,B类依赖了C类,而最后C类又依赖了A类,这样就形成了循环依赖问题。

    2、循环依赖问题案例分析:

    (1)演示代码:

    public class ClassA {
    	private ClassB classB;
    
    	public ClassB getClassB() {
    		return classB;
    	}
    
    	public void setClassB(ClassB classB) {
    		this.classB = classB;
    	}
    }
    public class ClassB {
    	private ClassA classA;
    
    	public ClassA getClassA() {
    		return classA;
    	}
    
    	public void setClassA(ClassA classA) {
    		this.classA = classA;
    	}
    }

    (2)配置文件:

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">
    
    	<bean id="classA" class="ioc.cd.ClassA">
    		<property name="classB" ref="classB"></property>
    	</bean>
    	<bean id="classB" class="ioc.cd.ClassB">
    		<property name="classA" ref="classA"></property>
    	</bean>
    </beans>
    

    (3)测试代码:

    	@Test
    	public void test() throws Exception {
    		// 创建IoC容器,并进行初始化
    		String resource = "spring/spring-ioc-circular-dependency.xml";
    		ApplicationContext context = new ClassPathXmlApplicationContext(resource);
    		// 获取ClassA的实例(此时会发生循环依赖)
    		ClassA classA = (ClassA) context.getBean(ClassA.class);
    	}
    

    3、通过Spring IOC流程的源码分析循环依赖问题:

     

    三、循环依赖问题的类型

    循环依赖问题在Spring中主要有三种情况:

    • (1)通过构造方法进行依赖注入时产生的循环依赖问题。
    • (2)通过setter方法进行依赖注入且是在多例(原型)模式下产生的循环依赖问题。
    • (3)通过setter方法进行依赖注入且是在单例模式下产生的循环依赖问题。

    在Spring中,只有第(3)种方式的循环依赖问题被解决了,其他两种方式在遇到循环依赖问题时都会产生异常。其实也很好解释:

    • 第(1)种构造方法注入的情况下,在new对象的时候就会堵塞住了,其实也就是”先有鸡还是先有蛋“的历史难题。
    • 第(2)种setter方法(多例)的情况下,每一次getBean()时,都会产生一个新的Bean,如此反复下去就会有无穷无尽的Bean产生了,最终就会导致OOM问题的出现。

     

    四、如何解决循环依赖问题?

    1、Spring解决的单例模式下的setter方法依赖注入引起的循环依赖问题,主要是通过两个缓存来解决的,请看下图:

     

    五、Spring三大缓存介绍

    Spring中有三个缓存,用于存储单例的Bean实例,这三个缓存是彼此互斥的,不会针对同一个Bean的实例同时存储。如果调用getBean,则需要从三个缓存中依次获取指定的Bean实例。 读取顺序依次是一级缓存 ==> 二级缓存 ==> 三级缓存。

    1、一级缓存:Map<String, Object> singletonObjects:

    (1)第一级缓存的作用:

    • 用于存储单例模式下创建的Bean实例(已经创建完毕)。
    • 该缓存是对外使用的,指的就是使用Spring框架的程序员。

    (2)存储什么数据?

    • K:bean的名称
    • V:bean的实例对象(有代理对象则指的是代理对象,已经创建完毕)

    2、第二级缓存:Map<String, Object> earlySingletonObjects:

    (1)第二级缓存的作用:

    • 用于存储单例模式下创建的Bean实例(该Bean被提前暴露的引用,该Bean还在创建中)。
    • 该缓存是对内使用的,指的就是Spring框架内部逻辑使用该缓存。
    • 为了解决第一个classA引用最终如何替换为代理对象的问题(如果有代理对象)

    3、第三级缓存:Map<String, ObjectFactory<?>> singletonFactories:

    (1)第三级缓存的作用:

    • 通过ObjectFactory对象来存储单例模式下提前暴露的Bean实例的引用(正在创建中)。
    • 该缓存是对内使用的,指的就是Spring框架内部逻辑使用该缓存。
    • 此缓存是解决循环依赖最大的功臣

    (2)存储什么数据?

    • K:bean的名称
    • V:ObjectFactory,该对象持有提前暴露的bean的引用

    (3)为什么第三级缓存要使用ObjectFactory?

    如果仅仅是解决循环依赖问题,使用二级缓存就可以了,但是如果对象实现了AOP,那么注入到其他bean的时候,并不是最终的代理对象,而是原始的。这时就需要通过三级缓存的ObjectFactory才能提前产生最终的需要代理的对象。

    (4)什么时候将Bean的引用提前暴露给第三级缓存的ObjectFactory持有?时机就是在第一步实例化之后,第二步依赖注入之前,完成此操作。

     

    六、解决构造函数相互注入造成的循环依赖:

    前面说Spring可以自动解决单例模式下通过setter()方法进行依赖注入产生的循环依赖问题。而对于通过构造方法进行依赖注入时产生的循环依赖问题没办法自动解决,那针对这种情况,我们可以使用@Lazy注解来解决。

    也就是说,对于类A和类B都是通过构造器注入的情况,可以在A或者B的构造函数的形参上加个@Lazy注解实现延迟加载。@Lazy实现原理是,当实例化对象时,如果发现参数或者属性有@Lazy注解修饰,那么就不直接创建所依赖的对象了,而是使用动态代理创建一个代理类。

    比如,类A的创建:A a=new A(B),需要依赖对象B,发现构造函数的形参上有@Lazy注解,那么就不直接创建B了,而是使用动态代理创建了一个代理类B1,此时A跟B就不是相互依赖了,变成了A依赖一个代理类B1,B依赖A。但因为在注入依赖时,类A并没有完全的初始化完,实际上注入的是一个代理对象,只有当他首次被使用的时候才会被完全的初始化。

     

    展开全文
  • Spring 如何解决循环依赖问题

    万次阅读 多人点赞 2018-03-31 21:35:03
    什么循环依赖? what? (1)循环依赖--&gt;循环引用。---&gt;即2个或以上bean 互相持有对方,最终形成闭环。 eg:A依赖B,B依赖C,C又依赖A。【注意:这里不是函数的循环调用【是个死循环,除非...

    (一)Spring  IOC容器---对象循环依赖

    1. 什么是循环依赖?  what?

       (1)循环依赖-->循环引用。--->即2个或以上bean 互相持有对方,最终形成闭环。

       eg:A依赖B,B依赖C,C又依赖A。【注意:这里不是函数的循环调用是个死循环,除非有终结条件】,是对象相互依赖关系

    2.  Spring中循环依赖的场景?where?

         ①:构造器的循环依赖。【这个Spring解决不了

    StudentA有参构造是StudentB。StudentB的有参构造是StudentC,StudentC的有参构造是StudentA ,这样就产生了一个循环依赖的情况,

    我们都把这三个Bean交给Spring管理,并用有参构造实例化

    1. public class StudentA {  
    2.   
    3.     private StudentB studentB ;  
    4.   
    5.     public void setStudentB(StudentB studentB) {  
    6.         this.studentB = studentB;  
    7.     }  
    8.   
    9.     public StudentA() {  
    10.     }  
    11.       
    12.     public StudentA(StudentB studentB) {  
    13.         this.studentB = studentB;  
    14.     }  
    15. }  
    [java]  view plain  copy
    1. public class StudentB {  
    2.   
    3.     private StudentC studentC ;  
    4.   
    5.     public void setStudentC(StudentC studentC) {  
    6.         this.studentC = studentC;  
    7.     }  
    8.       
    9.     public StudentB() {  
    10.     }  
    11.   
    12.     public StudentB(StudentC studentC) {  
    13.         this.studentC = studentC;  
    14.     }  
    15. }  
    [java]  view plain  copy
    1. public class StudentC {  
    2.   
    3.     private StudentA studentA ;  
    4.   
    5.     public void setStudentA(StudentA studentA) {  
    6.         this.studentA = studentA;  
    7.     }  
    8.   
    9.     public StudentC() {  
    10.     }  
    11.    
    12.     public StudentC(StudentA studentA) {  
    13.         this.studentA = studentA;  
    14.     }  
    [html]  view plain  copy
    1. <bean id="a" class="com.zfx.student.StudentA">  
    2.     <constructor-arg index="0" ref="b"></constructor-arg>  
    3. </bean>  
    4. <bean id="b" class="com.zfx.student.StudentB">  
    5.     <constructor-arg index="0" ref="c"></constructor-arg>  
    6. </bean>  
    7. <bean id="c" class="com.zfx.student.StudentC">  
    8.     <constructor-arg index="0" ref="a"></constructor-arg>  
    9. </bean>   

    下面是测试类:

    [java]  view plain  copy
    1. public class Test {  
    2.     public static void main(String[] args) {  
    3.         ApplicationContext context = new ClassPathXmlApplicationContext("com/zfx/student/applicationContext.xml");  
    4.         //System.out.println(context.getBean("a", StudentA.class));  
    5.     }  
    6. }  
    执行结果报错信息为:
    [java]  view plain  copy
    1. Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException:   
    2.     Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?  

         ②【setter循环依赖】field属性的循环依赖【setter方式 单例,默认方式-->通过递归方法找出当前Bean所依赖的Bean,然后提前缓存【会放入Cach中】起来。通过提前暴露 -->暴露一个exposedObject用于返回提前暴露的Bean。】

    setter方式注入:


    图中前两步骤得知:Spring是先将Bean对象实例化【依赖无参构造函数】--->再设置对象属性的

     这就不会报错了:

    原因:Spring先用构造器实例化Bean对象----->将实例化结束的对象放到一个Map中,并且Spring提供获取这个未设置属性的实例化对象的引用方法。结合我们的实例来看,,当Spring实例化了StudentA、StudentB、StudentC后,紧接着会去设置对象的属性,此时StudentA依赖StudentB,就会去Map中取出存在里面的单例StudentB对象,以此类推,不会出来循环的问题喽。

    3.  如何检测是否有循环依赖?how to  find?

       可以 Bean创建的时候给其打个标记,如果递归调用回来发现正在创建中的话--->即可说明循环依赖。

       

    4.怎么解决的?  todo what?

     Spring的循环依赖的理论依据其实是基于Java的引用传递,当我们获取到对象的引用时对象的field或zh属性是可以延后设置的(但是构造器必须是在获取引用之前)。

       Spring的单例对象初始化主要分为三步: 


        ①:
    createBeanInstance:实例化,其实也就是 调用对象的构造方法实例化对象

        ②:populateBean填充属性,这一步主要是多bean的依赖属性进行填充

        ③:initializeBean调用spring xml中的init() 方法。

    从上面讲述的单例bean初始化步骤我们可以知道,循环依赖主要发生在第一、第二步。也就是构造器循环依赖field循环依赖。

    那么我们要解决循环引用也应该从初始化过程着手,对于单例来说,在Spring容器整个生命周期内,有且只有一个对象,所以很容易想到这个对象应该存在Cache中,Spring为了解决单例的循环依赖问题,使用了三级缓存

      

    调整配置文件,将构造函数注入方式改为 属性注入方式 即可

    3.源码怎么实现的? how?

     (1)三级缓存源码主要 指:

    /** Cache of singleton objects: bean name --> bean instance */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
    
    /** Cache of singleton factories: bean name --> ObjectFactory */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
    
    /** Cache of early singleton objects: bean name --> bean instance */
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

    这三级缓存分别指:

     singletonFactories : 单例对象工厂的cache 
     earlySingletonObjects :提前暴光的单例对象的Cache 。【用于检测循环引用,与singletonFactories互斥

     singletonObjects:单例对象的cache

    我们在创建bean的时候,首先想到的是从cache中获取这个单例的bean,这个缓存就是singletonObjects。主要调用方法就就是:

    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
            synchronized (this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                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 != NULL_OBJECT ? singletonObject : null);
    }

    上面的代码需要解释两个参数:

    • isSingletonCurrentlyInCreation()判断当前单例bean是否正在创建中,也就是没有初始化完成(比如A的构造器依赖了B对象所以得先去创建B对象, 或则在A的populateBean过程中依赖了B对象,得先去创建B对象,这时的A就是处于创建中的状态。)
    • allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象

    分析getSingleton()的整个过程,Spring首先从一级缓存singletonObjects中获取。如果获取不到,并且对象正在创建中,就再从二级缓存earlySingletonObjects中获取。如果还是获取不到且允许singletonFactories通过getObject()获取,就从三级缓存singletonFactory.getObject()(三级缓存)获取,如果获取到了则:

    this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
    • 1
    • 2

    从singletonFactories中移除,并放入earlySingletonObjects中。其实也就是从三级缓存移动到了二级缓存。

    从上面三级缓存的分析,我们可以知道,Spring解决循环依赖的诀窍就在于singletonFactories这个三级cache。这个cache的类型是ObjectFactory,定义如下:

    public interface ObjectFactory<T> {
        T getObject() throws BeansException;
    }
    • 1
    • 2
    • 3

    这个接口在下面被引用

    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);
            }
        }
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    这里就是解决循环依赖的关键,这段代码发生在createBeanInstance之后,也就是说单例对象此时已经被创建出来(调用了构造器)。这个对象已经被生产出来了,虽然还不完美(还没有进行初始化的第二步和第三步),但是已经能被人认出来了(根据对象引用能定位到堆中的对象),所以Spring此时将这个对象提前曝光出来让大家认识,让大家使用。

    这样做有什么好处呢?让我们来分析一下“A的某个field或者setter依赖了B的实例对象,同时B的某个field或者setter依赖了A的实例对象”这种循环依赖的情况。A首先完成了初始化的第一步,并且将自己提前曝光到singletonFactories中,此时进行初始化的第二步,发现自己依赖对象B,此时就尝试去get(B),发现B还没有被create,所以走create流程,B在初始化第一步的时候发现自己依赖了对象A,于是尝试get(A),尝试一级缓存singletonObjects(肯定没有,因为A还没初始化完全),尝试二级缓存earlySingletonObjects(也没有),尝试三级缓存singletonFactories,由于A通过ObjectFactory将自己提前曝光了,所以B能够通过ObjectFactory.getObject拿到A对象(虽然A还没有初始化完全,但是总比没有好呀),B拿到A对象后顺利完成了初始化阶段1、2、3,完全初始化之后将自己放入到一级缓存singletonObjects中。此时返回A中,A此时能拿到B的对象顺利完成自己的初始化阶段2、3,最终A也完成了初始化,进去了一级缓存singletonObjects中,而且更加幸运的是,由于B拿到了A的对象引用,所以B现在hold住的A对象完成了初始化。

    知道了这个原理时候,肯定就知道为啥Spring不能解决“A的构造方法中依赖了B的实例对象,同时B的构造方法中依赖了A的实例对象”这类问题了!因为加入singletonFactories三级缓存的前提是执行了构造器,所以构造器的循环依赖没法解决


    展开全文
  • 循环依赖问题

    2018-09-25 20:26:09
    循环依赖的产生可能很多种情况,例如: A的构造方法中依赖了B的实例对象,同时B的构造方法中依赖了A的实例对象 A的构造方法中依赖了B的实例对象,同时B的某个field或者setter需要A的实例对象,以及反之 A的某个...

    循环依赖的产生和解决的前提

    循环依赖的产生可能有很多种情况,例如:

    • A的构造方法中依赖了B的实例对象,同时B的构造方法中依赖了A的实例对象
    • A的构造方法中依赖了B的实例对象,同时B的某个field或者setter需要A的实例对象,以及反之
    • A的某个field或者setter依赖了B的实例对象,同时B的某个field或者setter依赖了A的实例对象,以及反之

    当然,Spring对于循环依赖的解决不是无条件的,首先前提条件是针对scope单例并且没有显式指明不需要解决循环依赖的对象,而且要求该对象没有被代理过。同时Spring解决循环依赖也不是万能,以上三种情况只能解决两种,第一种在构造方法中相互依赖的情况Spring也无力回天。结论先给在这,下面来看看Spring的解决方法,知道了解决方案就能明白为啥第一种情况无法解决了。

    Spring对于循环依赖的解决

    Spring循环依赖的理论依据其实是Java基于引用传递,当我们获取到对象的引用时,对象的field或者或属性是可以延后设置的。
    Spring单例对象的初始化其实可以分为三步:

    • createBeanInstance, 实例化,实际上就是调用对应的构造方法构造对象,此时只是调用了构造方法,spring xml中指定的property并没有进行populate
    • populateBean,填充属性,这步对spring xml中指定的property进行populate
    • initializeBean,调用spring xml中指定的init方法,或者AfterPropertiesSet方法
      会发生循环依赖的步骤集中在第一步和第二步。

    三级缓存

    对于单例对象来说,在Spring的整个容器的生命周期内,有且只存在一个对象,很容易想到这个对象应该存在Cache中,Spring大量运用了Cache的手段,在循环依赖问题的解决过程中甚至使用了“三级缓存”。

    “三级缓存”主要是指

    /** Cache of singleton objects: bean name --> bean instance */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);
    /** Cache of singleton factories: bean name --> ObjectFactory */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);
    /** Cache of early singleton objects: bean name --> bean instance */
    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);
    

    从字面意思来说:singletonObjects指单例对象的cache,singletonFactories指单例对象工厂的cache,earlySingletonObjects指提前曝光的单例对象的cache。以上三个cache构成了三级缓存,Spring就用这三级缓存巧妙的解决了循环依赖问题。

    解决方法

    回想上篇文章中关于Bean创建的过程,首先Spring会尝试从缓存中获取,这个缓存就是指singletonObjects,主要调用的方法是:

    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
       Object singletonObject = this.singletonObjects.get(beanName);
       if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
          synchronized (this.singletonObjects) {
             singletonObject = this.earlySingletonObjects.get(beanName);
             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 != NULL_OBJECT ? singletonObject : null);}
    

    首先解释两个参数:

    • isSingletonCurrentlyInCreation 判断对应的单例对象是否在创建中,当单例对象没有被初始化完全(例如A定义的构造函数依赖了B对象,得先去创建B对象,或者在populatebean过程中依赖了B对象,得先去创建B对象,此时A处于创建中)
    • allowEarlyReference 是否允许从singletonFactories中通过getObject拿到对象

    分析getSingleton的整个过程,Spring首先从singletonObjects(一级缓存)中尝试获取,如果获取不到并且对象在创建中,则尝试从earlySingletonObjects(二级缓存)中获取,如果还是获取不到并且允许从singletonFactories通过getObject获取,则通过singletonFactory.getObject()(三级缓存)获取。如果获取到了则

    this.earlySingletonObjects.put(beanName, singletonObject);
    this.singletonFactories.remove(beanName);
    

    则移除对应的singletonFactory,将singletonObject放入到earlySingletonObjects,其实就是将三级缓存提升到二级缓存中!

    Spring解决循环依赖的诀窍就在于singletonFactories这个cache,这个cache中存的是类型为ObjectFactory,其定义如下:

    public interface ObjectFactory<T> {
        T getObject() throws BeansException;}
    

    在bean创建过程中,有两处比较重要的匿名内部类实现了该接口。一处是

    new ObjectFactory<Object>() {
       @Override   public Object getObject() throws BeansException {
          try {
             return createBean(beanName, mbd, args);
          }      catch (BeansException ex) {
             destroySingleton(beanName);
             throw ex;
          }   }
    

    在上文已经提到,Spring利用其创建bean(这样做真的很不明确呀...)

    另一处就是:

    addSingletonFactory(beanName, new ObjectFactory<Object>() {
       @Override   public Object getObject() throws BeansException {
          return getEarlyBeanReference(beanName, mbd, bean);
       }});
    

    此处就是解决循环依赖的关键,这段代码发生在createBeanInstance之后,也就是说单例对象此时已经被创建出来的。这个对象已经被生产出来了,虽然还不完美(还没有进行初始化的第二步和第三步),但是已经能被人认出来了(根据对象引用能定位到堆中的对象),所以Spring此时将这个对象提前曝光出来让大家认识,让大家使用。

    这样做有什么好处呢?让我们来分析一下“A的某个field或者setter依赖了B的实例对象,同时B的某个field或者setter依赖了A的实例对象”这种循环依赖的情况。A首先完成了初始化的第一步,并且将自己提前曝光到singletonFactories中,此时进行初始化的第二步,发现自己依赖对象B,此时就尝试去get(B),发现B还没有被create,所以走create流程,B在初始化第一步的时候发现自己依赖了对象A,于是尝试get(A),尝试一级缓存singletonObjects(肯定没有,因为A还没初始化完全),尝试二级缓存earlySingletonObjects(也没有),尝试三级缓存singletonFactories,由于A通过ObjectFactory将自己提前曝光了,所以B能够通过ObjectFactory.getObject拿到A对象(虽然A还没有初始化完全,但是总比没有好呀),B拿到A对象后顺利完成了初始化阶段1、2、3,完全初始化之后将自己放入到一级缓存singletonObjects中。此时返回A中,A此时能拿到B的对象顺利完成自己的初始化阶段2、3,最终A也完成了初始化,长大成人,进去了一级缓存singletonObjects中,而且更加幸运的是,由于B拿到了A的对象引用,所以B现在hold住的A对象也蜕变完美了!一切都是这么神奇!!

    知道了这个原理时候,肯定就知道为啥Spring不能解决“A的构造方法中依赖了B的实例对象,同时B的构造方法中依赖了A的实例对象”这类问题了!

    总结

    Spring通过三级缓存加上“提前曝光”机制,配合Java的对象引用原理,比较完美地解决了某些情况下的循环依赖问题!


    转载 ---
    作者:LNAmp
    链接:https://www.jianshu.com/p/6c359768b1dc
     

    展开全文
  • ioc循环依赖问题

    2021-03-26 15:36:07
    ico循环依赖问题什么循环依赖Spring循环依赖的场景循环依赖的处理机制 什么循环依赖 循环依赖就是循环引用,两个或者两个以上的Bean互相引用对方,最终形成闭环。 例如:A依赖于B,B依赖于C,C依赖于A 注意:...
  • Spring IoC循环依赖问题

    2020-08-27 14:43:33
    Spring IoC循环依赖问题 文章内容输出来源:拉勾教育Java高薪训练营 什么循环依赖 循环依赖其实就是循环引用,也就是两个或者两个以上的 Bean 互相持有对方,最终形成闭环。比如A 依赖于B,B依赖于C,C又依赖于A。...
  • 什么循环依赖 最近学习了一下spring的循环依赖问题,这里总结一下。首先,我们应该知道什么是spring的依赖问题,想要明白这个问题,我们就要先明白spring的创建bean的过程。这里我简单说一下,spring在启动的时候...
  • Spring IOC循环依赖问题

    2020-06-16 15:56:51
    文章目录Spring IOC循环依赖问题什么循环依赖循环依赖处理机制无法解决的循环依赖多例 prototype 原型 Bean 循环依赖 (无法解决)单例 Bean 构造器参数循环依赖(无法解决)Spring循环依赖的解决方法 Spring IOC...
  • spring循环依赖问题

    2017-05-23 11:26:25
    spring循环依赖
  • spring如何解决循环依赖问题

    千次阅读 多人点赞 2021-03-01 15:49:35
    其实一个bean持有自己类型的属性也产生循环依赖。 setter singleton循环依赖 使用 SingleSetterBeanA依赖SingleSetterBeanB,SingleSetterBeanB依赖SingleSetterBeanA。 @Data public class SingleSetterBeanA { ...
  • 什么循环依赖? 其实就是循环引用,也就是两个或则两个以上的bean互相持有对方,最终形成闭环。比如A依赖于B,B依赖于C,C又依赖于A。 怎么产生的? Spring的单例对象的初始化主要分为三步: (1)...
  • 需要用的springBean的生命周期和AOP的源码知识,迷茫的猿友可以自行上网查阅。 spring解决了单例的循环依赖,但当循环依赖的bean中出现@Async时,就抛出异常
  • 在Spring中循环依赖场景两种: 构造器的循环依赖; setter的循环依赖 其中构造器的循环依赖是无法解决的,只能抛出BeanCurrentlyInCreationException异常;对于setter的循环依赖,spring采用提前暴露对象的方法...
  • 循环依赖 循环依赖、循环调用 循环依赖是针对成员变量---单例才可以解决setter方法循环依赖,多例是无法解决循环依赖 构造方法循环依赖----无法解决,只有将构造依赖改为setter方法依赖 setter方法循环依赖---...
  • spring解决循环依赖问题 文章目录spring解决循环依赖问题循环依赖概念Spring 出现循环依赖需要满足三个条件:Spring 创建对象分为三个过程:案例 循环依赖概念 spring循环依赖其实就是循环引用,也就是两个或则两个...
  • 解决Maven项目相互依赖/循环依赖/双向依赖的问题 转自:https://blog.csdn.net/leolu007/article/details/53079875 添加新随笔很​多​时​候​随​着​项​目​的​膨​胀​,模​块​​越​来​越​多​,如​...
  • Spring的循环依赖问题

    2019-07-15 11:03:22
    1. 什么循环依赖循环依赖其实就是循环引用,也就是两个或则两个以上的bean互相持有对方,最终形成闭环。比如A依赖于B,B依赖于C,C又依赖于A。如下图: 注意,这里不是函数的循环调用,是对象的相互依赖...
  • 循环依赖

    2018-12-21 17:05:00
    什么循环依赖循环依赖就是循环引用,就是两个或者多个bean相互之间的持有对方,比如TestA引用TestB,TestB引用TestC,TestC引用TestA,这样它们最终反映为一个环。这里需要强调一点,此情形不是循环调用,循环...
  • Spring中的循环依赖问题

    千次阅读 2016-06-23 16:44:56
    最近在研究Spring IOC容器,遇到了对象的循环依赖问题,通过看源码才明白Spring是如何优雅的解决单例循环依赖问题。Spring将对象依赖分成属性依赖和构造依赖,构造依赖问题无法解决,只能抛出...
  • 其中,构造器的循环依赖问题⽆法解决,只能拋出BeanCurrentlyInCreationException异常,在解决 属性循环依赖时,Spring 采⽤的是提前暴露对象的⽅法。 循环依赖处理机制 prototype原型bean循环依赖(⽆法解决
  • 前言 本文配合下面两文食用味道更加 Spring启动过程——源码分析1 Spring启动过程——源码分析2 循环依赖什么?...为什么Sprng会有循环依赖问题呢? 思考 想知道为什么spring为什么有这样的问题 前...
  • SpringBoot项目启动报循环依赖异常 今天,我启动项目项目报循环依赖异常了,为了说明我这里简化了。 我的代码是这样(模拟)的 @Component publicclassTestA{ @Autowired privateTestBtestB; @Async(...
  • 本文描述了 Spring 如何解决循环依赖问题,附图!
  • 什么循环依赖? 顾名思义,循环依赖就是A依赖B,B又依赖A,两者之间的依赖关系形成了一个圆环,通常是由于不正确的编码所导致。Spring只能解决属性循环依赖问题,不能解决构造函数循环依赖问题,因为这个问题无解...
  • 主要介绍了带@Transactional和@Async的循环依赖问题的解决,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 394,536
精华内容 157,814
关键字:

循环依赖会带来什么问题