当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