spring怎么解决循环以来 • Worktile社区

不及物动词

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

循环依赖在Spring框架中指的是两个或多个Bean之间相互依赖，形成了一个闭环。正常情况下，Spring容器无法解决循环依赖问题，但是Spring提供了几种解决循环依赖的方法。

构造器注入
使用构造器注入可以解决循环依赖问题。通过将依赖的Bean作为构造器参数传递给其他Bean，而不是通过属性注入的方式，从而避免了循环依赖的问题。

public class BeanA {
    private BeanB b;
    
    public BeanA(BeanB b) {
        this.b = b;
    }
}

public class BeanB {
    private BeanA a;
    
    public BeanB() {}
    
    public void setA(BeanA a) {
        this.a = a;
    }
}

setter注入
使用setter方法注入可以解决循环依赖问题。在BeanB的setter方法中注入BeanA，同时在BeanA的setter方法中注入BeanB。

public class BeanA {
    private BeanB b;
    
    public void setB(BeanB b) {
        this.b = b;
    }
}

public class BeanB {
    private BeanA a;

    public void setA(BeanA a) {
        this.a = a;
    }
}

使用注解 @Lazy
在启动Spring容器时，可以使用 @Lazy 注解来延迟加载Bean，从而避免循环依赖的问题。

@Lazy
public class BeanA {
    private BeanB b;
    
    public void setB(BeanB b) {
        this.b = b;
    }
}

@Lazy
public class BeanB {
    private BeanA a;

    public void setA(BeanA a) {
        this.a = a;
    }
}

使用代理对象
在循环依赖的情况下，可以使用代理对象来解决问题。Spring容器创建一个代理对象来代替原始的Bean，当需要使用该Bean时，代理对象会初始化原始Bean并提供相关的依赖注入。

public class BeanA {
    private BeanB b;

    public void setB(BeanB b) {
        this.b = b;
    }
}

public class BeanB {
    private BeanA a;

    public void setA(BeanA a) {
        this.a = a;
    }
}

@Configuration
public class AppConfig {
    @Bean
    public BeanA beanA() {
        return new BeanA();
    }
    
    @Bean
    public BeanB beanB(BeanA beanA) {
        BeanB beanB = new BeanB();
        beanB.setA(beanA);
        return beanB;
    }
}

以上是解决循环依赖问题的几种常用方法。根据具体的项目需求和实际情况，可以选择合适的方法来解决循环依赖问题。

1年前 0条评论

worktile

Worktile官方账号

Spring使用依赖注入（DI）和面向切面编程（AOP）的概念来解决循环依赖的问题。下面是Spring解决循环依赖的机制：

提前暴露中间对象：当Spring容器初始化一个bean时，会在对象创建的过程中将当前对象放入到一个早期引用（early reference）中。当其他bean需要引用当前bean时，会使用这个早期引用代替实际的bean。
构造函数注入：Spring倾向于使用构造函数注入来解决循环依赖。当发现循环依赖时，Spring会尽可能地提前创建一个不完整的bean，并将其暴露给其他bean进行初始化。这样，在其他bean初始化时，早期引用可以被注入到构造函数中。
BeanPostProcessor接口：Spring提供了BeanPostProcessor接口，允许开发人员在bean的实例化和依赖注入过程中实施自定义逻辑。通过实现BeanPostProcessor接口，可以在实例化bean之前和之后拦截bean实例化的过程，从而对依赖关系进行处理，从而解决循环依赖问题。
代理模式：Spring使用代理模式来解决循环依赖。当发现循环依赖时，Spring会创建一个代理对象，该代理对象负责管理循环依赖的解析。实际的bean对象在代理对象的内部。当其他bean需要引用该bean时，实际上是从代理对象获取的。
单例模式：Spring的默认作用域是单例模式，每个bean在容器中只有一个实例。这种单例模式的特性有助于解决循环依赖问题，因为同一个实例可以被多个bean共享，从而避免了循环依赖的问题。

综上所述，Spring使用提前暴露中间对象、构造函数注入、BeanPostProcessor接口、代理模式和单例模式等机制来解决循环依赖问题。这些机制有效地处理了各种场景下的循环依赖，提高了Spring容器的灵活性和可维护性。

1年前 0条评论

fiy

Worktile&PingCode市场小伙伴

Spring解决循环依赖的关键是使用了三级缓存和前置处理器。当我们在Spring容器中声明一个Bean时，Spring会根据依赖注入的方式来创建Bean实例。如果Bean A依赖于Bean B，同时Bean B又依赖于Bean A，则会发生循环依赖问题。下面将详细讲解Spring是如何解决循环依赖的。

1. Spring的三级缓存

Spring通过使用三级缓存来解决循环依赖的问题，这三级缓存分别是singletonObjects、earlySingletonObjects和singletonFactories。

singletonObjects：存放已经创建完成的单例Bean实例。当一个Bean创建完成后，会被放入singletonObjects中，后续如果有其他Bean依赖它，可以直接从该缓存中获取。
earlySingletonObjects：存放正在创建中的Bean实例。当一个Bean创建的过程中，如果出现循环依赖情况，会将该Bean放入earlySingletonObjects中。
singletonFactories：存放创建Bean的工厂对象。当一个Bean创建的过程中，如果出现循环依赖情况，会将该Bean对应的工厂对象放入singletonFactories中。

2. Spring的前置处理器

Spring使用前置处理器来处理循环依赖的问题。在Bean创建的过程中，Spring会在不同的阶段使用不同的前置处理器来处理循环依赖。

BeanDefinitionRegistryPostProcessor：在Bean定义阶段，Spring会先进行Bean的注册，这个阶段会使用到BeanDefinitionRegistryPostProcessor。这个处理器可以用来解决部分循环依赖问题。
InstantiationAwareBeanPostProcessor：在Bean实例化之前，Spring会通过这个处理器来处理循环依赖。当一个Bean需要依赖其他的Bean时，会通过这个处理器来判断是否需要提前暴露Bean的代理对象。
SmartInstantiationAwareBeanPostProcessor：在Bean实例化阶段，Spring会使用这个处理器来处理循环依赖。这个处理器可以判断是否需要提前暴露Bean的代理对象。

3. Spring解决循环依赖的流程

下面是Spring解决循环依赖的流程：

根据Bean的定义信息，创建Bean实例，但不会进行属性注入。
将创建的Bean实例放入earlySingletonObjects缓存中。
开始对Bean进行属性注入，这时会检查Bean是否有循环依赖问题。
如果发现Bean有循环依赖问题，则会创建一个ObjectFactory（实现了SmartInstantiationAwareBeanPostProcessor接口），并将其放入singletonFactories缓存中。
继续对Bean进行属性注入，如果注入的属性依赖于其他的Bean，则会递归创建依赖的Bean实例。
如果创建的Bean实例依赖于其他的Bean，则会从singletonObjects缓存中获取依赖的Bean实例。
如果如果singletonObjects缓存中没有依赖的Bean实例，则会从earlySingletonObjects缓存中获取正在创建的Bean实例。
如果earlySingletonObjects缓存中也没有正在创建的Bean实例，则会调用ObjectFactory的getObject()方法来创建Bean实例。
创建完成后，会将Bean实例放入singletonObjects缓存中。
如果有其他的Bean依赖于该Bean实例，可以直接从singletonObjects缓存中获取。

通过使用三级缓存和前置处理器，Spring能够解决循环依赖的问题。但是，循环依赖的处理过程较为复杂，可能会导致性能问题。所以，尽量避免出现循环依赖的情况，减少程序的复杂性。

1年前 0条评论