Spring：循环依赖 问题复现及解决

当Spring初始化bean的时候，如果bean之间出现了相互依赖，就会报循环依赖的异常：The dependencies of some of the beans in the application context form a cycle

问题复现

创建两个Bean，A和B，并且互相依赖

@SpringBootApplication
public class SpringbootApplication {

    public static void main(String[] args) {
        ConfigurableApplicationContext ac = SpringApplication.run(SpringbootApplication.class, args);
    }
}

@Component
public class BeanA {

    @Autowired
    private BeanB beanB;
}

@Component
public class BeanB {

    @Autowired
    private BeanA beanA;
}

解决方法

核心思想

spring的循环依赖问题类似于这种感觉，BeanA的构造方法需要BeanB，BeanB的构造方法需要BeanA。然后变成了先有鸡还是先有蛋的问题。

BeanA a = new BeanA(new BeanB(需要A));

要解决循环依赖，就要先分别new好循环对象，然后在通过set方法给对象注入需要依赖的对象。

BeanA a = new BeanA();
BeanB b = new BeanB();
a.setBeanB(b);
b.setBeanA(a);

@Lazy

打破循环的一个简单方法是让Spring懒洋洋地初始化其中一个bean。那就是：它不是完全初始化bean，而是创建一个代理将它注入另一个bean。注入的bean只有在第一次需要时才会完全创建。

@Component
public class BeanA {
    @Lazy
    @Autowired
    private BeanB beanB;
}

@Component
public class BeanB {
    @Lazy
    @Autowired
    private BeanA beanA;
}

@PostConstruct

这种方式要自己去理清楚初始化bean的顺序，而且要在bean里面添加跟业务无关的代码，不是很好。

@Component
public class BeanA {
    @Autowired
    private BeanB beanB;

    @PostConstruct
    private void init() {
        beanB.setBeanA(this);
    }
}

@Component
public class BeanB {
    private BeanA beanA;

    public void setBeanA(BeanA beanA) {
        this.beanA = beanA;
    }
}

使用ApplicationContextAware和InitializingBean进行setter注入

ApplicationContextAware可以获取spring容器
InitializingBean可以监听所有bean被初始化完成

@Component
public class BeanA {

    private BeanB beanB;

    public void invokeBeanB(){
        beanB.hello();
    }

    public void hello(){
        System.out.println("hello, I am BeanA");
    }
}

@Component
public class BeanB {

    private BeanA beanA;

    public void invokeBeanA() {
        beanA.hello();
    }

    public void hello() {
        System.out.println("hello, I am BeanA");
    }
}

@Component
public class CircularDependInit implements ApplicationContextAware, InitializingBean {

    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        BeanA beanA = applicationContext.getBean(BeanA.class);
        BeanB beanB  = applicationContext.getBean(BeanB.class);

        Field beanASetBeanB = BeanA.class.getDeclaredField("beanB");
        beanASetBeanB.setAccessible(true);
        beanASetBeanB.set(beanA, beanB);

        Field beanBSetBeanA = BeanB.class.getDeclaredField("beanA");
        beanBSetBeanA.setAccessible(true);
        beanBSetBeanA.set(beanB, beanA);
    }
}

循环依赖的坏处

 为什么spring要默认对循环依赖报错呢？因为循环依赖很容易造成无限递归导致栈溢出，所以循环依赖是不被推荐的，出现循环依赖的架构，大部分是代码设计的不合理。但有时候由于是项目的遗留问题，我们不想改变原有的架构，也要逼着解决循环依赖的问题。
 下面伪代码会出现循环依赖无限递归的问题

@Component
public class BeanA {

    @Autowired
    private BeanB beanB;

	// 只要调用了method方法就会无限递归
	public void method(){
		System.out.println("i am beanA")
		beanB.method(); // 写BeanA的人不知道BeanB也依赖了BeanA，于是调用了
	}
}

@Component
public class BeanB {

    @Autowired
    private BeanA beanA;
	
	// 只要调用了method方法就会无限递归
	public void method(){
		System.out.println("i am beanB")
		beanA.method(); // 写BeanB的人不知道BeanA也依赖了BeanB，于是调用了
	}
}

后续有时间在研究spring是怎么检测出循环依赖的
参考博客：https://blog.csdn.net/bingguang1993/article/details/88915576