Spring循环依赖（四）

已于 2022-05-10 17:39:23 修改
阅读量348 收藏
点赞数
分类专栏： Spring 文章标签： spring java
于 2022-03-23 17:52:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/summer_45/article/details/123692329
版权
本文详细阐述了Spring中循环依赖的原理，通过实例演示如何利用singletonObjects、earlySingletonObjects和singletonFactories三级缓存来避免循环依赖，以及AOP代理的时机选择。
摘要由CSDN通过智能技术生成

循环依赖

什么是循环依赖？

依赖：在Spring中，A类将其他的类当作属性时，就造成了A依赖其他类

定义：

​ 现有A、B两个类，如果A类将B类作为属性（并设置@Autowired），B类也将A类作为属性（并设置@Autowired），那么就造成了循环依赖 【A依赖于B，B依赖于A】

现象：

当A、B循环依赖：

  1. 创建beanA，发现依赖beanB

  2. 创建beanB，发现依赖beanA

  3. 创建beanA，发现依赖beanB

  4. 创建beanB，发现依赖beanA

    …// 循环

类型：

  • 单例bean循环依赖 —— 三级缓存解决

  • 原型bean循环依赖 —— 无法解决，直接报错

    • 因为它没有用到缓存池，所以无法解决

  • 构造器参数循环依赖 —— @Lazy注解解决

解决：

只有setter注入属性的方式可以解决，构造方法注入不能解决！【有可能导致构造器参数循环依赖】

关闭循环依赖

源码：

public class Main {
    public static void main(String[] args) {
        // 1. 执行this()
        AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
        // 禁止循环依赖
        applicationContext.setAllowCircularReferences(false);
        // 2. 注册配置类
        applicationContext.register(AppConfig.class);
        // 3. 刷新容器
        applicationContext.refresh();
    }
}

简单解决循环依赖

定义：

​ 在Spring中，有三个缓存池，其实用两个缓存池就可以简单的解决循环依赖问题，下面介绍用两个缓存池怎么简单解决。

缓存池组成：

缓存池作用
singletonObjects 一级缓存存放经历了 完整生命周期的bean
earlySingletonObjects 二级缓存存放 刚创建出来的、不完整的bean 【无属性】
singletonFactories 三级缓存存放 bean对应的函数
这里的函数支持调用BeanPostProcessor实现AOP动态代理

Spring解决循环依赖流程

开始

  1. A进入getBean()方法

  2. A开始createBean()

  3. 实例化纯净的BeanA

  4. 从三级缓存中拿A自己的回调方法 —— 出口

  5. 如果拿不到，将A的回调方法加入三级缓存

  6. 填充属性

    1. 填充属性发现依赖B，跑去创建beanB

      1. B进入getBean()方法

      2. B开始createBean()

      3. 实例化纯净的BeanB

      4. 从三级缓存中拿B自己的回调方法

      5. 如果拿不到，将B的回调方法加入三级缓存

      6. 填充属性

        1. 填充属性发现依赖A，跑去创建beanA

          1. A进入getBean()方法

          2. A开始createBean()

          3. 实例化纯净的BeanA

          4. 从三级缓存中拿A自己的回调方法，拿到了，调用回调

            1. 注意！此时是跑去了第一次A进入getBean()的时候

            2. 如果单例池、二级缓存没有A，并且有A的三级缓存函数，那么==将A加入二级缓存，并删除A的三级缓存==

            3. 调用回调，获取第3步实例化的那个纯净的BeanA

          5. 拿到BeanA了，返回给B

          6. 第二次A的 getBean() 退出

      7. B继续填充属性 【使B完整】

      8. 加入单例池，并删除二级缓存和三级缓存的B

      9. 调用初始化方法

      10. 拿到beanB了，返回给A

  7. A继续填充属性 【使A完整】

  8. 调用初始化方法

  9. 加入单例池，并删除二级缓存和三级缓存的A

结束

二级缓存和三级缓存分别解决循环依赖

  • 简易版二级缓存

  • 简易版三级缓存

A类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 循环依赖 实例A
 *
 * @author summer <995214902@qq.com>
 * @date 2022/3/18 19:23
 */
@Component
public class InstanceA {

    @Autowired
    private InstanceB instanceB;

    public InstanceA() {
        System.out.println("InstanceA实例化");
    }

}

B类

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

/**
 * 循环依赖 实例A
 *
 * @author summer <995214902@qq.com>
 * @date 2022/3/18 19:23
 */
@Component
public class InstanceB {

    @Autowired
    private InstanceA instanceA;

    public InstanceB() {
        System.out.println("InstanceB实例化");
    }

}

简易版二级缓存解决循环依赖

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;

import java.lang.reflect.Field;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;


/**
 * 二级缓存解决循环依赖
 *
 * @author summer <995214902@qq.com>
 * @date 2022/3/18 19:23
 */
public class MainStart {

    // 一级缓存
    public static Map<String, Object> singletonObjects = new ConcurrentHashMap<>();

    // 二级缓存： 为了将 成熟Bean和纯净Bean分离，避免读取到不完整得Bean
    public static Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();

    // 原料map
    private static Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

    /**
     * 读取bean定义，当然在spring中肯定是根据配置 动态扫描注册
     */
    public static void loadBeanDefinitions() {
        RootBeanDefinition aBeanDefinition = new RootBeanDefinition(InstanceA.class);
        RootBeanDefinition bBeanDefinition = new RootBeanDefinition(InstanceB.class);
        beanDefinitionMap.put("instanceA", aBeanDefinition);
        beanDefinitionMap.put("instanceB", bBeanDefinition);
    }

    public static void main(String[] args) throws Exception {
        // 加载了BeanDefinition
        loadBeanDefinitions();

        // 1.开始啦！！！ 循环创建Bean
        for (String key : beanDefinitionMap.keySet()) {
            // 调用getBean,先从A开始
            getBean(key);
        }

        InstanceA singleBeanA = (InstanceA) getBean("instanceA");
    }


    /**
     * 获取bean
     *
     * @param beanName bean名称
     * @return bean对象
     */
    public static Object getBean(String beanName) throws IllegalAccessException, InstantiationException {

        // 1. 调用getSingleton看看单例池有没有
        Object singleton = getSingleton(beanName);

        // 2. 单例池有直接返回，没有就直接往下走
        if (singleton != null) {
            return singleton;
        }

        // 4. 实例化一个bean
        RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
        Class<?> beanClass = beanDefinition.getBeanClass();
        // 5. 拿到纯净的bean
        Object instanceBean = beanClass.newInstance();


        /*
         * 如果是二级缓存，要实现AOP动态代理，就得在这里实现AOP动态代理
         * 因为循环依赖的出口要在属性赋值之前，而这个出口就是二级缓存【第六步】
         *
         * 而Spring希望AOP动态代理在bean实例化并初始化完成后，再进行代理，所以引入了三级缓存。
         */

        // 6. 添加二级缓存，解决循环依赖
        earlySingletonObjects.put(beanName,instanceBean);

        // 7. 属性赋值
        Field[] declaredFields = beanClass.getDeclaredFields();
        for (Field field : declaredFields) {
            Autowired annotation = field.getAnnotation(Autowired.class);
            // 8. 如果属性上有@Autowired，那我就给他注入
            if (annotation != null) {
                String name = field.getName();
                // 9. 递归入口获得属性
                Object fileObject = getBean(name);
                field.setAccessible(true);
                field.set(instanceBean, fileObject);
            }

        }

        // 12. 调用初始化函数
        // init-method

        // 13. 添加到一级缓存
        singletonObjects.put(beanName, instanceBean);

        // 14. remove 二级缓存
        earlySingletonObjects.remove(beanName);

        return instanceBean;
    }



    public static Object getSingleton(String beanName) {

        Object bean = singletonObjects.get(beanName);

        if (bean == null) {
            // 3. 从二级缓存中拿
            bean = earlySingletonObjects.get(beanName);
        }

        return bean;

    }

}

简易版三级缓存解决循环依赖

主流程

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.support.RootBeanDefinition;

import java.lang.reflect.Field;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;


/**
 * 三级缓存解决循环依赖
 *
 * @author summer <995214902@qq.com>
 * @date 2022/3/18 19:23
 */
public class MainStart {

    // 一级缓存
    public static Map<String, Object> singletonObjects = new ConcurrentHashMap<>();

    // 二级缓存： 将完整bean和纯净bean分开
    public static Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>();

    // 三级缓存：存储 bean 对应增强bean的方法 [AOP代理]
    public static Map<String, ObjectFactory> singletonFactories = new ConcurrentHashMap<>();

    // 标识正在创建的单例的set集合
    public static Set<String> singletonsCurrentlyInCreation = new HashSet<>();

    // 原料map
    private static Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

    
    public static void main(String[] args) throws Exception {
        // 加载了BeanDefinition
        loadBeanDefinitions();

        // 1.开始啦！！！ 循环创建Bean
        for (String key : beanDefinitionMap.keySet()) {
            // 调用getBean,先从A开始
            getBean(key);
        }

        InstanceA singleBeanA = (InstanceA) getBean("instanceA");
    }
    
    
    /**
     * 读取bean定义，模仿Spring动态扫描注册
     */
    public static void loadBeanDefinitions() {
        RootBeanDefinition aBeanDefinition = new RootBeanDefinition(InstanceA.class);
        RootBeanDefinition bBeanDefinition = new RootBeanDefinition(InstanceB.class);
        beanDefinitionMap.put("instanceA", aBeanDefinition);
        beanDefinitionMap.put("instanceB", bBeanDefinition);
    }

    
    /**
     * 获取bean
     *
     * @param beanName bean名称
     * @return bean对象
     */
    public static Object getBean(String beanName) throws Exception {

        // 1. 调用getSingleton看看单例池有没有
        Object singleton = getSingleton(beanName);

        // 2. 单例池有直接返回，没有就直接往下走
        if (singleton != null) {
            return singleton;
        }

        // 3. 将bean标识为正在创建
        singletonsCurrentlyInCreation.add(beanName);

        // 4. 实例化一个bean
        RootBeanDefinition beanDefinition = (RootBeanDefinition) beanDefinitionMap.get(beanName);
        Class<?> beanClass = beanDefinition.getBeanClass();
        // 5. 拿到纯净的bean
        Object instanceBean = beanClass.newInstance();

        if (!singletonFactories.containsKey(beanName)) {
            // 6. 三级缓存拿不到回调方法，将自己的回调方法getEarlyBeanReference() 放进去
            Object finalInstanceBean = instanceBean;
            singletonFactories.put(beanName, () -> getEarlyBeanReference(finalInstanceBean, beanName));
        }

        // 7. 属性赋值
        Field[] declaredFields = beanClass.getDeclaredFields();
        for (Field field : declaredFields) {
            Autowired annotation = field.getAnnotation(Autowired.class);
            // 8. 如果属性上有@Autowired，那我就给他注入
            if (annotation != null) {
                field.setAccessible(true);
                String name = field.getName();
                // 9. 递归入口获得属性
                Object fileObject = getBean(name);
                field.set(instanceBean, fileObject);
            }

        }


        // 10. 属性赋值结束，正常情况下会在初始化之后创建proxy，就是bean有可能会被代理，所以这情况还会拿到被代理的bean
        // 11. 由于递归完后，第一次的A还是原实例，所以要从二级缓存中拿到proxy
        if (earlySingletonObjects.containsKey(beanName)) {
            instanceBean = earlySingletonObjects.get(beanName);
        }

        // 12. 调用初始化函数
        // init-method

        // 13. 添加到一级缓存
        singletonObjects.put(beanName, instanceBean);


        // 14. remove 二级缓存和三级缓存
        earlySingletonObjects.remove(beanName);
        singletonFactories.remove(beanName);

        return instanceBean;
    }

    
    /**
     * 获取bean早期引用，Spring在这里进行BeanPostProcessor的调用 来实现AOP
     *
     * @param beanName bean名称
     * @return bean对象
     */
    private static Object getEarlyBeanReference(Object finalInstanceBean, String beanName) {
        // 看beanName符合什么规范，让 BeanPostProcessor 给他创建动态代理 【开挂】
        return finalInstanceBean;
    }


    public static Object getSingleton(String beanName) {
        // 1. 先从一级缓存中拿
        Object bean = singletonObjects.get(beanName);

        // 2. 如果当前bean拿不到，只有两种情况：
        // 一、刚好是一个新的类刚刚开始创建 二、我之前已经正在创建了，又要get一次，说明是循环依赖
        if (bean == null && singletonsCurrentlyInCreation.contains(beanName)) {
            // 3. 从二级缓存中拿
            bean = earlySingletonObjects.get(beanName);
            if (bean == null) {
                // 4. 从三级缓存中拿
                ObjectFactory factory = singletonFactories.get(beanName);
                if (factory != null) {
                    // 5. 拿到被动态代理的、纯净的bean
                    bean = factory.getObject();
                    // 6. 加入二级缓存，给被依赖的bean获取 【B】
                    earlySingletonObjects.put(beanName, bean);
                }
            }


        }

        return bean;

    }

}

ObjectFactory函数接口

/**
 * 循环依赖，函数接口
 * <p>
 * 函数接口很有意思
 * <p>
 * 它可以将一个函数作为参数传递，然后在你想要调用的时机调用这个函数
 *
 * @author summer <995214902@qq.com>
 * @date 2022/3/18 19:23
 */
@FunctionalInterface
public interface ObjectFactory<T> {

    /**
     * 返回此工厂管理的对象的实例，在这里可以增强bean
     *
     * @return 结果实例
     */
    T getObject();

}

Q

为什么二级缓存就能解决循环依赖，还要三级缓存？

​ 因为Spring希望在 bean实例化并初始化之后 再去实现AOP动态代理

  • 只用两级缓存的话，AOP动态代理必须放到属性赋值之前，不然没有循环依赖出口！

好处：解耦、便于实现AOP动态代理吧~

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-njvhSdau-1652175560946)(3%20%E5%BE%AA%E7%8E%AF%E4%BE%9D%E8%B5%96.assets/%E5%BE%AA%E7%8E%AF%E4%BE%9D%E8%B5%96%E8%AF%BE%E4%B8%8A%E5%9B%BE%E3%80%90%E6%9B%B4%E5%A4%9A%E8%AF%BE%E7%A8%8B%20zx-cc.net%E3%80%91.png)]

Spring中循环依赖解决

就是getBean()那里分析的

  1. 利用三级缓存存储 函数方法进行回调获取早期对象解决循环依赖

  2. 考虑AOP是否应该提前 【实例化后 AOP 还是 初始化后AOP】

    • 实例化后 —— getEarlyReference() 里面调用BeanPostProcessor

    • 初始化后 —— applyBeanPostProcessorsAfterInitialization() 里面调用BeanPostProcessor

就做了这两件事来解决循环依赖的问题

summer_45
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
循环依赖解析
勇心在馨
10-06 1296
一、什么是循环依赖 循环依赖就是循环引用，两个或者多个bean相互之间的持有对方，比如CircleA引用CircleB，CircleB引用CircleC，CircleC引用CircleA，则他们最终反映为一个环。 二、Spring是如何解决循环依赖 Spring容器循环依赖包括构造器循环依赖和setter循环依赖 1、构造器循环依赖 通过构造器注入形成的循环依赖，此依赖无法解决，只能抛出BeanCurrentlyInCreationException异常表示循环依赖。 Spring容器将每一个正
简单了解Spring循环依赖解决过程
08-25
Spring 循环依赖解决过程详解 Spring 框架中循环依赖是一个常见的问题，它指的是两个或多个 Bean 之间存在的相互依赖关系，例如 A 依赖 B，B 依赖 A，这种情况下，Spring 需要解决这个循环依赖关系，以便正确地实例...
循环依赖
weixin_30787531的博客
12-21 940
定义 什么是循环依赖？循环依赖就是循环引用，就是两个或者多个bean相互之间的持有对方，比如TestA引用TestB，TestB引用TestC，TestC引用TestA，这样它们最终反映为一个环。这里需要强调一点，此情形不是循环调用，循环调用是方法之间的环调用。循环引用如下图： 循环调用是无法解决的，除非有终结条件，否则就是死循环，最终导致内存溢出错误。 Spring如何解决循环依赖 ...
什么是循环依赖？
最新发布
常备不懈
06-23 734
循环依赖（Circular Dependency），也称为循环引用，是指两个或多个Bean之间相互依赖，形成一个环状依赖链。例如，Bean A依赖于Bean B，而Bean B又依赖于Bean A，这就形成了一个简单的循环依赖。
JAVA循环依赖
weixin_30273763的博客
02-20 108
最近看到一个问题：如果有两个类A和B，A类中有一个B的对象b，B类中有一个A的对象a，那么如何解决这两个类的相互依赖关系呢？ 示例代码1 public class Test{ public static void main(String[] args) { B testb = new B(); } } class A{ public B b; public ...
spring循环依赖策略解析
08-29
Spring循环依赖策略解析 在Spring框架中，循环依赖是指多个Bean之间的依赖关系形成一个闭环的情况。例如，A依赖B，B依赖C，C依赖A，这种情况下，如果A依赖B，那么在创建A的过程中会去创建B，在创建B的过程中又发现B...
Spring循环依赖的三种方式(推荐)
08-28
Spring 循环依赖的三种方式 Spring 循环依赖是指在 Spring 框架中，多个 Bean 之间存在相互依赖关系，从而形成一个循环依赖链。如果在日常开发中，我们使用 new 对象的方式来实例化 Bean，这种循环依赖可能会导致...
详解Spring循环依赖的解决方案
08-27
主要介绍了详解Spring循环依赖的解决方案，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
spring bean循环依赖时序图
09-09
spring bean循环依赖时序图详细的描述了spring的循环依赖关系，帮我们快速了解spring是如何优雅的进行处理的
什么是循环依赖
qq_33987908的博客
11-28 389
从一个类开始，依赖线路能回到该类，从而形成了一个依赖闭环，这就是循环依赖。 如A, B两个类形成的循环依赖： 相关代码： public class Test { public static void main(String[] args) { A a = new A(); } } class A { private A a = new A(); } class B { private A a = new A(); } 执行结果会抛出StackOverflowError 一个类也能形
讲一讲循环依赖
kyhoon
05-18 2941
什么是循环依赖，Spring中是如何解决循环依赖的
10-循环依赖
低调的烂笔头的博客
04-18 580
总结下 Spring 解决循环依赖的思路：在创建单例 Bean 时，会把该 Bean 的工厂函数的匿名类对象放入三级缓存中的 singletonFactories 中。然后在填充属性时，如果出现循环依赖依赖本 Bean，必然执行之前放入的工厂函数的匿名实现，如果该 Bean 无需 AOP 的话，工厂函数返回的就是原 Bean 对象；如果该 Bean有 AOP 的话，也有可能是被某些 BBP 处理 AOP 之后的代理对象，会放入二级缓存中的 earlySingletonObjects 中。
Spring对于循环依赖是如何解决的
常备不懈
04-06 205
随着项目的不断扩大，依赖关系的复杂度也在不断增加。在这种情况下，循环依赖问题就显得尤为突出。Spring框架作为一种广泛使用的Java企业级应用开发框架，为开发者提供了一套优雅的解决方案来应对循环依赖。在本篇文章中，我们将探讨Spring是如何解决循环依赖的。
Spring 循环依赖
Crystal---的博客
12-01 197
@Test public void testAOP() { ApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml"); LagouAopBean lagouBean = applicationContext.getBean(LagouAopBean.class); lagouBean.print(); } 1 Abstract.
【卷Spring系列】请说一下循环依赖
麦客子
12-06 180
读书破万卷，卷起来
Spring中的循环依赖
热门推荐
SuZhan0711
02-09 3万+
目录一、什么是循环依赖？二、Bean的生命周期2.1 Spring Bean 的生命周期2.2 Bean 的生成步骤三、三级缓存3.1三个缓存分别有什么作用四、思路分析4.1 为什么 Spring 中还需要 singletonFactories 呢？五、Spring解决了哪种情况下的循环依赖5.1 ObjectFactory六、getEarlyBeanReference方法七、总结 一、什么是循环依赖？ 例如，就是A对象依赖了B对象，B对象依赖了A对象。 // A依赖了B class A{ pub
spring 循环依赖
09-07
Spring循环依赖指的是在Spring中，多个Bean之间存在相互依赖的情况。具体来说，当一个Bean A依赖于另一个Bean B，同时Bean B也依赖于Bean A时，就形成了循环依赖。这种情况下，Spring需要解决Bean的创建和依赖注入的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值