Spring循环依赖的解决方案详解

什么是Spring循环依赖

循环依赖是指两个或两个以上的bean互相依赖，形成一个“环”。Spring容器的依赖注入机制默认是无法处理循环依赖的。发现循环依赖后会抛出BeanCurrentlyInCreationException异常。

根本原因分析

Spring循环依赖的根本原因是因为bean的创建过程中先创建了一个半成品bean，即只实例化了对象，但是还没有执行构造方法、注入属性等行为。

在这种情况下，第二个bean依赖于第一个bean，但是第一个bean还没有完成完整的创建。所以第二个bean即便注入了第一个bean，依然不能使用它。

换一种说法，就是一个bean的创建需要依赖其他的bean，而这些bean可能还没创建好，或者依赖到自己。

例如：

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循环依赖的解决方案

Spring提供了三种解决循环依赖的方案：通过构造函数注入、setter方法注入、通过aop方式进行代理注入。

构造器注入

构造器注入是指将循环依赖的bean都通过构造器参数传递进去。

Spring容器在进行bean的创建过程中，会在对象实例化之后，对属性进行赋值。而使用构造器注入的方式，可以将循环依赖的bean直接传递进去，解决循环依赖的问题。

示例：

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(B b) {
        return new A(b);
    }
    @Bean
    public B b(A a) {
        return new B(a);
    }
}

在这个例子中，创建A对象时需要传入B对象，而B对象需要一个A对象作为构造器参数。这时候，Spring容器会先创建B对象，将A对象传递进去，然后再创建A对象。

setter方法注入

setter方法注入是指通过setter方法来解决循环依赖。

Spring容器在进行bean的创建过程中，先实例化对象，然后调用setter方法进行赋值。使用setter方法注入的方式，可以先实例化bean对象，然后通过调用setter方法来设置循环依赖的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();
        ...
        return a;
    }
    @Bean
    public B b() {
        B b = new B();
        ...
        return b;
    }
}

在这个例子中，创建A对象时不需要传入B对象，而是使用默认构造函数进行创建。在b对象创建后，通过调用A对象的setter方法来设置B属性。

aop方式进行代理注入

aop方式进行代理注入是指通过Spring的AOP框架，在循环依赖的bean中间加入一个代理类来解决循环依赖。

Spring容器在进行bean的创建过程中，会将循环依赖的bean进行预处理，然后通过代理对象的方式进行注入。这种方式是通过使用cglib来创建代理对象，实现了循环依赖的解决。

示例：

public class A {
    private B b;
    public void setB(B b) {
        this.b = b;
    }
    public void sayHello() {
        System.out.println("Hello, I am A!");
    }
    ...
}

public class B {
    private A a;
    public void setA(A a) {
        this.a = a;
    }
    public void sayHello() {
        System.out.println("Hello, I am B!");
    }
    ...
}

@Configuration
public class AppConfig {
    @Bean
    public A a() {
        return new A();
    }
    @Bean
    public B b() {
        return new B();
    }
    @Bean
    public BeanFactoryPostProcessor beanFactoryPostProcessor() {
        return new BeanFactoryPostProcessor() {
            @Override
            public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
                DefaultListableBeanFactory defaultBeanFactory = (DefaultListableBeanFactory) beanFactory;
                BeanDefinition bd = defaultBeanFactory.getBeanDefinition("a");
                bd.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_NAME);
            }
        };
    }
}

通过上述代码，我们可以看到AppConfig中定义了BeanFactoryPostProcessor的bean，这个bean的作用是在BeanFactory初始化完成后，对Bean进行一些相关处理。

在这个例子中，我们将a的autowireMode属性设为"AUTOWIRE_BY_NAME"，这样在创建a对象时，会增加一个cglib代理类，代理a对象的属性B。

总结

Spring循环依赖是一种常见的问题，为了解决这个问题，Spring提供了三种解决方案，即通过构造函数注入、setter方法注入、通过aop方式进行代理注入。选择哪种方式，可以根据实际情况进行选择。虽然Spring提供了解决方案，但是循环依赖是一种设计上的问题，不建议在设计中出现循环依赖的情况。