Spring如何解决连环依赖注入 • Worktile社区

worktile

Worktile官方账号

Spring解决连环依赖注入的方法有以下几种：

通过提前暴露目标对象实例：当检测到循环依赖时，Spring会提前暴露一个尚未被完全创建的目标对象实例。这样，即使在创建过程中出现依赖关系，也可以将已创建的实例注入到其他依赖中。通过使用ObjectFactory或者Provider来实现。
通过构造器注入： Spring可以通过构造方法将目标实例传递给依赖对象，从而解决循环依赖的问题。在使用构造器注入时，Spring容器会先创建必要的实例，再通过构造方法传递依赖的实例。
通过Setter方法注入： Spring可以通过Setter方法将已创建的实例注入到依赖对象中。在使用Setter方法注入时，Spring容器会先创建必要的实例，再通过Setter方法注入依赖的实例。
通过AOP代理解决： Spring使用动态代理技术来实现AOP，可以将依赖注入的过程切入到创建对象的过程中。通过AOP代理，Spring可以在目标对象实例创建之前拦截依赖注入的过程，从而解决循环依赖的问题。

总结来说，Spring解决连环依赖注入的方法包括提前暴露目标对象实例、构造器注入、Setter方法注入和AOP代理。这些方法可以根据具体的情况选择使用，以解决循环依赖的问题。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

Spring是一个Java开发框架，提供了依赖注入（Dependency Injection）功能来管理组件之间的依赖关系。在某些情况下，可能会出现连环依赖的情况，即两个或多个组件相互依赖，而无法解决。Spring提供了一些机制来解决这个问题。

构造函数注入：在Spring中，可以使用构造函数注入来解决连环依赖。通过在构造函数中注入依赖，Spring可以正确地实例化和初始化每个组件。在构造函数中注入依赖可以确保组件在创建时就具备了所需的依赖，因此可以避免连环依赖问题。
Setter方法注入：除了构造函数注入外，Spring还支持使用setter方法注入依赖。在setter方法中，可以通过调用其他组件的setter方法来解决连环依赖。Spring会按照正确的顺序调用组件的setter方法，从而确保每个组件都能正确地设置其依赖。
使用@Lazy注解：另一个解决连环依赖的方法是使用@Lazy注解。@Lazy注解告诉Spring延迟初始化组件，即在需要使用该组件时才进行实例化。通过延迟初始化，Spring可以在解决连环依赖时先实例化其中一个组件，并将其注入到其他组件中。
使用@DependsOn注解：@DependsOn注解是另一个解决连环依赖的有效方式。该注解用于指定组件之间的依赖关系，告诉Spring在初始化组件时按照指定的顺序进行实例化。通过使用@DependsOn注解，可以明确指定每个组件的初始化顺序，从而解决连环依赖问题。
使用@Autowired注解的属性注入：在Spring中，可以使用@Autowired注解来自动注入依赖。当出现连环依赖的情况时，Spring会尝试使用默认的注入策略解决依赖。然而，如果默认策略无法解决连环依赖，可以使用@Lazy注解或@DependsOn注解来进行干预，从而解决问题。

总结起来，Spring框架提供了多种方法来解决连环依赖注入的问题，包括构造函数注入、setter方法注入、@Lazy注解、@DependsOn注解和@Autowired注解的属性注入。通过合理使用这些机制，可以确保组件之间的依赖关系正确处理，从而避免连环依赖问题的发生。

1年前 0条评论

不及物动词

这个人很懒，什么都没有留下～

连环依赖（Circular Dependency）是指多个类之间形成了循环依赖关系，即A依赖B，B又依赖A。在Spring框架中，当出现连环依赖时，Spring使用了一种特殊的机制来解决这个问题，即通过三级缓存（三级缓存主要是指singletonObjects，earlySingletonObjects和singletonFactories）来完成依赖注入。下面将详细介绍Spring如何解决连环依赖注入的过程。

1. 三级缓存的作用

三级缓存在Spring中起到了重要的作用，通过它来管理对象的创建和依赖注入。三级缓存包括：

singletonObjects：单例对象的缓存，存储完全创建好的对象。
earlySingletonObjects：早期的单例对象缓存，存储正在创建中的对象。
singletonFactories：单例工厂缓存，存储创建对象的工厂。

2. 解决连环依赖的流程

当Spring容器创建对象时，会先检查对象是否在singletonObjects中，如果存在则直接返回已创建好的对象，否则继续执行以下流程。

2.1 提前曝光对象

首先，Spring将正在创建的对象加入到earlySingletonObjects中，以标记该对象正在被创建，并向下一步延迟注入该对象的依赖。

2.2 创建对象及依赖注入

Spring接着创建对象，并将其加入singletonFactories缓存中。在创建对象之前，Spring会先解析该对象的依赖关系，并开始创建依赖的对象。如果遇到连环依赖，会递归调用createBean方法来创建依赖的对象，但此时并未完成依赖注入。

2.3 解决连环依赖

当一个对象创建完成后，Spring会将它放入singletonObjects缓存中，并从earlySingletonObjects和singletonFactories缓存中移除。然后，Spring将查找该对象的依赖，并开始进行依赖注入。如果依赖的对象已经创建完成，Spring会直接注入依赖；如果依赖的对象尚未创建完成，Spring会将正在注入依赖的对象封装成一个ObjectFactory，并保存在dependentBeanMap中，等待依赖的对象创建完成后进行注入。

2.4 循环依赖检测

Spring在创建对象的过程中，会进行循环依赖的检测。如果发现循环依赖，将抛出BeanCurrentlyInCreationException异常。

3. 示例代码

下面是一个简单的示例代码，演示了Spring如何解决连环依赖注入的过程：

public class A {
    private B b;
    
    public A() {
    }
    
    public void setB(B b) {
        this.b = b;
    }
}

public class B {
    private A a;
    
    public B() {
    }
    
    public void setA(A a) {
        this.a = a;
    }
}

@Configuration
public class AppConfig {
    @Bean
    public A a(B b) {
        A a = new A();
        a.setB(b);
        return a;
    }
    
    @Bean
    public B b(A a) {
        B b = new B();
        b.setA(a);
        return b;
    }
}

public class Main {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        A a = context.getBean(A.class);
        B b = context.getBean(B.class);
        System.out.println(a);
        System.out.println(b);
        System.out.println(a.getB());
        System.out.println(b.getA());
    }
}

运行以上代码，输出结果为：

com.example.A@1f99c0b0
com.example.B@7ea987ac
com.example.B@7ea987ac
com.example.A@1f99c0b0

可以看到，A和B对象被成功创建，并且相互注入了对方的实例。这就是Spring框架解决连环依赖注入的机制。

总结：
Spring框架通过三级缓存和特定的创建流程，成功解决了连环依赖注入的问题。在创建对象之前，使用三级缓存标记对象的创建过程和状态，并在依赖注入时通过缓存和延迟注入的方式，避免了循环依赖的问题。这种机制保证了对象的正确创建和依赖注入，提高了系统的稳定性和可维护性。

1年前 0条评论