Java面试大厂名企高频真题---Spring bean 循环依赖

心已赠人 2024-04-01 13:32 86阅读 0赞

### **要求** ###

掌握单例 set 方式循环依赖的原理

掌握其它循环依赖的解决方法

**循环依赖的产生**

首先要明白，bean 的创建要遵循一定的步骤，必须是创建、注入、初始化三步，这些顺序不能乱

![73340750b0f24f11845f5c34d9bc73ea.png][]

*  set 方法（包括成员变量）的循环依赖如图所示
    
    可以在【a 创建】和【a set 注入 b】之间加入 b 的整个流程来解决
 *  【b set 注入 a】 时可以成功，因为之前 a 的实例已经创建完毕
 *  a 的顺序，及 b 的顺序都能得到保障![b007b10ef8fc4f3ba5d41c2060e299e2.png][]

构造方法的循环依赖如图所示，显然无法用前面的方法解决

![0881ed5652504914a308643916d09617.png][]

**构造循环依赖的解决**

*  思路1
    
    a 注入 b 的代理对象，这样能够保证 a 的流程走通
 *  后续需要用到 b 的真实对象时，可以通过代理间接访问![44cd5c86a8fd46e088db88816805f06f.png][]

*  思路2
    
    a 注入 b 的工厂对象，让 b 的实例创建被推迟，这样能够保证 a 的流程先走通
 *  后续需要用到 b 的真实对象时，再通过 ObjectFactory 工厂间接访问![09a8f58912a1404fa34bca157c2a239c.png][]

示例1：用 @Lazy 为构造方法参数生成代理

public class App60_1 {
    
        static class A {
            private static final Logger log = LoggerFactory.getLogger("A");
            private B b;
    
            public A(@Lazy B b) {
                log.debug("A(B b) {}", b.getClass());
                this.b = b;
            }
    
            @PostConstruct
            public void init() {
                log.debug("init()");
            }
        }
    
        static class B {
            private static final Logger log = LoggerFactory.getLogger("B");
            private A a;
    
            public B(A a) {
                log.debug("B({})", a);
                this.a = a;
            }
    
            @PostConstruct
            public void init() {
                log.debug("init()");
            }
        }
    
        public static void main(String[] args) {
            GenericApplicationContext context = new GenericApplicationContext();
            context.registerBean("a", A.class);
            context.registerBean("b", B.class);
            AnnotationConfigUtils.registerAnnotationConfigProcessors(context.getDefaultListableBeanFactory());
            context.refresh();
            System.out.println();
        }
    }

示例2：用 ObjectProvider 延迟依赖对象的创建

public class App60_2 {
    
        static class A {
            private static final Logger log = LoggerFactory.getLogger("A");
            private ObjectProvider<B> b;
    
            public A(ObjectProvider<B> b) {
                log.debug("A({})", b);
                this.b = b;
            }
    
            @PostConstruct
            public void init() {
                log.debug("init()");
            }
        }
    
        static class B {
            private static final Logger log = LoggerFactory.getLogger("B");
            private A a;
    
            public B(A a) {
                log.debug("B({})", a);
                this.a = a;
            }
    
            @PostConstruct
            public void init() {
                log.debug("init()");
            }
        }
    
        public static void main(String[] args) {
            GenericApplicationContext context = new GenericApplicationContext();
            context.registerBean("a", A.class);
            context.registerBean("b", B.class);
            AnnotationConfigUtils.registerAnnotationConfigProcessors(context.getDefaultListableBeanFactory());
            context.refresh();
    
            System.out.println(context.getBean(A.class).b.getObject());
            System.out.println(context.getBean(B.class));
        }
    }

示例3：用 @Scope 产生代理

public class App60_3 {
    
        public static void main(String[] args) {
            GenericApplicationContext context = new GenericApplicationContext();
            ClassPathBeanDefinitionScanner scanner = new ClassPathBeanDefinitionScanner(context.getDefaultListableBeanFactory());
            scanner.scan("com.itheima.app60.sub");
            context.refresh();
            System.out.println();
        }
    }

@Component
    class A {
        private static final Logger log = LoggerFactory.getLogger("A");
        private B b;
    
        public A(B b) {
            log.debug("A(B b) {}", b.getClass());
            this.b = b;
        }
    
        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

@Scope(proxyMode = ScopedProxyMode.TARGET_CLASS)
    @Component
    class B {
        private static final Logger log = LoggerFactory.getLogger("B");
        private A a;
    
        public B(A a) {
            log.debug("B({})", a);
            this.a = a;
        }
    
        @PostConstruct
        public void init() {
            log.debug("init()");
        }
    }

示例4：用 Provider 接口解决，原理上与 ObjectProvider 一样，Provider 接口是独立的 jar 包，需要加入依赖

<dependency>
        <groupId>javax.inject</groupId>
        <artifactId>javax.inject</artifactId>
        <version>1</version>
    </dependency>

public class App60_4 {
    
        static class A {
            private static final Logger log = LoggerFactory.getLogger("A");
            private Provider<B> b;
    
            public A(Provider<B> b) {
                log.debug("A({}})", b);
                this.b = b;
            }
    
            @PostConstruct
            public void init() {
                log.debug("init()");
            }
        }

static class B {
            private static final Logger log = LoggerFactory.getLogger("B");
            private A a;
    
            public B(A a) {
                log.debug("B({}})", a);
                this.a = a;
            }
    
            @PostConstruct
            public void init() {
                log.debug("init()");
            }
        }
        public static void main(String[] args) {
            GenericApplicationContext context = new GenericApplicationContext();
            context.registerBean("a", A.class);
            context.registerBean("b", B.class);
            AnnotationConfigUtils.registerAnnotationConfigProcessors(context.getDefaultListableBeanFactory());
            context.refresh();
    
            System.out.println(context.getBean(A.class).b.get());
            System.out.println(context.getBean(B.class));
        }
    }

#### 解决 set 循环依赖的原理 ####

**一级缓存**

**![3c76043bcef649209c59c486ff4faf28.png][]**

作用是保证单例对象仅被创建一次

第一次走 `getBean("a")` 流程后，最后会将成品 a 放入 singletonObjects 一级缓存

后续再走 `getBean("a")` 流程时，先从一级缓存中找，这时已经有成品 a，就无需再次创建

**一级缓存与循环依赖**

**![5e314afc991142d78db44939885ee7d1.png][]**

一级缓存无法解决循环依赖问题，分析如下

无论是获取 bean a 还是获取 bean b，走的方法都是同一个 getBean 方法，假设先走 `getBean("a")`

当 a 的实例对象创建，接下来执行 `a.setB()` 时，需要走 `getBean("b")` 流程，红色箭头 1

当 b 的实例对象创建，接下来执行 `b.setA()` 时，又回到了 `getBean("a")` 的流程，红色箭头 2

但此时 singletonObjects 一级缓存内没有成品的 a，陷入了死循环

**二级缓存![58eaaf4d8f754e1cacc5985ef6948af4.png][]**

解决思路如下：

再增加一个 singletonFactories 缓存

在依赖注入前，即 `a.setB()` 以及 `b.setA()` 将 a 及 b 的半成品对象（未完成依赖注入和初始化）放入此缓存

执行依赖注入时，先看看 singletonFactories 缓存中是否有半成品的对象，如果有拿来注入，顺利走完流程

对于上面的图

`a = new A()` 执行之后就会把这个半成品的 a 放入 singletonFactories 缓存，即 `factories.put(a)`

接下来执行 `a.setB()`，走入 `getBean("b")` 流程，红色箭头 3

这回再执行到 `b.setA()` 时，需要一个 a 对象，有没有呢？有！

`factories.get()` 在 singletonFactories 缓存中就可以找到，红色箭头 4 和 5

b 的流程能够顺利走完，将 b 成品放入 singletonObject 一级缓存，返回到 a 的依赖注入流程，红色箭头 6

**二级缓存与创建代理![51a756305af94f10b068a8aaceefd8cb.png][]**

二级缓存无法正确处理循环依赖并且包含有代理创建的场景，分析如下

spring 默认要求，在 `a.init` 完成之后才能创建代理 `pa = proxy(a)`

由于 a 的代理创建时机靠后，在执行 `factories.put(a)` 向 singletonFactories 中放入的还是原始对象

接下来箭头 3、4、5 这几步 b 对象拿到和注入的都是原始对象

**三级缓存![5b620a8a00324a149a814b8f8c775e70.png][]**

简单分析的话，只需要将代理的创建时机放在依赖注入之前即可，但 spring 仍然希望代理的创建时机在 init 之后，只有出现循环依赖时，才会将代理的创建时机提前。所以解决思路稍显复杂：

图中 `factories.put(fa)` 放入的既不是原始对象，也不是代理对象而是工厂对象 fa

当检查出发生循环依赖时，fa 的产品就是代理 pa，没有发生循环依赖，fa 的产品是原始对象 a

假设出现了循环依赖，拿到了 singletonFactories 中的工厂对象，通过在依赖注入前获得了 pa，红色箭头 5

这回 `b.setA()` 注入的就是代理对象，保证了正确性，红色箭头 7

还需要把 pa 存入新加的 earlySingletonObjects 缓存，红色箭头 6

`a.init` 完成后，无需二次创建代理，从哪儿找到 pa 呢？earlySingletonObjects 已经缓存，蓝色箭头 9

当成品对象产生，放入 singletonObject 后，singletonFactories 和 earlySingletonObjects 就中的对象就没有用处，清除即可

[73340750b0f24f11845f5c34d9bc73ea.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/2f0d7fa1f10543b0bd4c6dee0910ca3a.png
[b007b10ef8fc4f3ba5d41c2060e299e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/cd987f2b6f464240b89ae3c68ae4f62a.png
[0881ed5652504914a308643916d09617.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/5a4282fd6b3245a7a838bc1138796db1.png
[44cd5c86a8fd46e088db88816805f06f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/e18aa6dcc0f04c9da5f827b2ac7b29f8.png
[09a8f58912a1404fa34bca157c2a239c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/95443ea161f34903afd32ade58cd8ce1.png
[3c76043bcef649209c59c486ff4faf28.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/52e1d4d7bb1547f99eeb0e4d33d809ce.png
[5e314afc991142d78db44939885ee7d1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/3ba03d5fe6a94907ad5e1d759e8cb7d3.png
[58eaaf4d8f754e1cacc5985ef6948af4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/10286fbe8c0b47f9b514f3e9a6fafb88.png
[51a756305af94f10b068a8aaceefd8cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/ad85587ccfb2406499b7e12211c789c5.png
[5b620a8a00324a149a814b8f8c775e70.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/01/46e6213ab0494c7592ee49ad4a5d521f.png