Java Spring循环依赖原理与bean的生命周期图文案例详解

Java Spring是一套开源的JavaEE框架，它的核心是IoC（控制反转）和AOP（面向切面编程）。在Spring中，循环依赖是一个比较重要的概念，本文将详细讲解Java Spring循环依赖原理与bean的生命周期。

什么是循环依赖

在Spring容器中，当Bean A依赖于Bean B，并且Bean B又依赖于Bean A时，我们就称这种情况为循环依赖。

例如：

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

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

这两个类之间就存在循环依赖。这种情况下，如果不进行特殊处理，Spring容器将无法实例化Bean A和Bean B。

Spring中的循环依赖解决方案

Spring容器中默认情况下是无法解决循环依赖的。但是，Spring提供了两种解决循环依赖的方案：构造函数注入和setter方法注入。

构造函数注入

Spring容器在创建Bean时，会调用Bean的构造函数进行实例化。如果一个Bean依赖另一个Bean，你可以通过构造函数注入的方式解决循环依赖问题。

但是，如果两个Bean互相依赖，并且都是通过构造函数注入方式实现依赖注入，Spring容器就无法解决循环依赖问题，抛出BeanCurrentlyInCreationException。

例如：

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

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

@Configuration
public class AppConfig {
    @Bean
    public A a() {
        return new A(b());
    }

    @Bean
    public B b() {
        return new B(a());
    }
}

上述代码中存在循环依赖，而且通过构造函数注入的方式实现依赖注入，Spring容器将抛出BeanCurrentlyInCreationException异常。

setter方法注入

除了构造函数注入外，还可以通过setter方法注入的方式解决循环依赖问题。在Spring容器中，当一个Bean依赖另一个Bean时，容器会先实例化依赖的Bean，然后通过setter方法注入方式将依赖的Bean注入到主Bean中。

例如：

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

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

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

    @Bean
    public B b() {
        B b = new B();
        b.setA(a());
        return b;
    }
}

通过setter方法注入的方式解决循环依赖问题，可以避免BeanCurrentlyInCreationException异常的发生。

Bean的生命周期

在了解循环依赖的解决方案之前，需要先了解Spring中Bean的生命周期。Bean的生命周期可以分为以下5个步骤：

1. 实例化（Instantiation）：Spring容器根据Bean的定义信息创建Bean的实例。
2. 属性赋值（Population）：Spring容器将Bean的属性值通过setter方法或直接设置实例变量的方式赋值。
3. 初始化（Initialization）：当所有属性值完成注入后，Spring容器会调用Bean的初始化方法（如果定义了的话）。
4. 就绪（Ready）：在初始化方法调用后，Bean处于就绪状态，可以通过BeanFactory获取到实例。
5. 销毁（Destruction）：当容器关闭时，所有Bean实例都会被销毁，同时也会调用Bean的销毁方法（如果定义了的话）。

Spring循环依赖示例

下面通过一个实例来演示Spring中如何解决循环依赖问题。

首先，创建一个Person类，其中依赖于Dog类：

public class Person {
    private Dog dog;
    public Person(Dog dog) {
        this.dog = dog;
    }
    public void setDog(Dog dog) {
        this.dog = dog;
    }
    public void playWithDog() {
        System.out.println("play with " + dog.getName());
    }
}

在Person类中，通过构造函数注入方式依赖于Dog类。

接着，创建一个Dog类，其中依赖于Person类：

public class Dog {
    private Person person;
    public Dog() {}
    public void setPerson(Person person) {
        this.person = person;
    }
    public void playWithPerson() {
        System.out.println("play with " + person.getName());
    }
}

在Dog类中，通过setter方法注入方式依赖于Person类。

最后，创建一个配置类，将Person类和Dog类都注入到容器中：

@Configuration
public class AppConfig {
    @Bean
    public Person person() {
        return new Person(dog());
    }
    @Bean
    public Dog dog() {
        Dog dog = new Dog();
        dog.setPerson(person());
        return dog;
    }
}

在AppConfig中，先实例化Dog类，然后使用setter方法将Person类注入到Dog类中，最后再将Person类注入到容器中。

通过上述方式，就可以解决循环依赖问题。

综上所述，本文详细讲解了Java Spring循环依赖原理与bean的生命周期，同时提供了构造函数注入和setter方法注入两种解决循环依赖的方案，以及通过示例演示了Spring如何解决循环依赖问题。