Spring解决循环依赖为什么需要三级缓存？

# 前言

什么是循环依赖呢？我们抛开Spring这个框架来聊下什么是循环依赖，循环依赖可能在我们平时的开发过程中是属于比较常见的。Spring容器最大的功能就是对bean的生命周期进行管理，每个bean在创建的过程中，需要得到一个完整的bean需要对bean的所有属性进行赋值，如果两个bean出现了相互依赖的情况，如果Spring没有处理循环依赖，那么出现的结果就是在bean的创建过程中出现相互依赖，导致这个bean永远无法创建出来，则就导致一直在相互创建，那么Spring是如何来解决循环依赖的呢？

# 什么情况下会循环依赖

1.先看如下demo: B和A相互循环依赖

@Component
public class B {
    @Autowired
    private A a;
}

@Component
public class A {
    @Autowired
    private B b;
}

1
2
3
4
5
6
7
8
9
10
11

启动项目：结果没有报错。

加入异步逻辑修改

@Component
public class A {
    @Autowired
    private B b;
   @Async
    public void test(){

    }
}

@Component
public class B {
    @Autowired
    private A a;
}
@EnableAsync
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(App.class);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

启动后：

解决方案：加入lazy注解：

@Component
public class B {
    @Autowired
    @Lazy
    private A a;
}
@Component
public class A {
    @Autowired
    private B b;
   @Async
    public void test(){

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

启动后：没有异常

上面发现使用@Async异步注解，循环依赖就会报错，有可能是因为有了@Async注解修饰的方法，其对应的类被代理了，那代理了就会报错么？我们继续尝试事务注解看看。

@Component
public class A {
    @Autowired
    private B b;
    @Transactional
    public void test(){

    }
}

@Component
public class B {
    @Autowired
    private A a;
}
@EnableTransactionManagement
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(App.class);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

启动后：正常，没有报错。

于是我们不经要问：

循环依赖本来不会报错，为何添加@Async异步注解后就会导致报错
为何添加@Transactional注解就不会报错
使用了@Async异步注解的循环依赖，为何可以使用@lazy注解解决

我们要想清楚上面的问题，就需要了解Bean的生命周期。

# Bean的生命周期

一个简单的Bean生命周期如下：

问题出现就属性赋值这里：

由图：我们知道，当B也依赖A时，需要去容器中找到A，A已经实例化了，只是还没属性赋值，所以，不应该再实例化，解决方案：在A创建的实例化后，用一个map存起来A来不就行了么？于是有了二级缓存

似乎上面已经可以解决循环依赖了，但细想一下我们会发现问题：

通过上面的逻辑，我们发现了问题所在，B赋值属性A时，如果从Map中直接获取，那么得到的是原生对象，如果后续A没有被代理，一切没问题，如果A被代理了，那么B得到的对象就不对了，怎么解决，如果我们将aop提前是不是解决了问题。

由于A对象的Aop方式提前了，那么B依赖的A就是代理对象了，A对象执行赋值后，后续到Aop这一步，会判断是否已经AOP过了，是的话就不会再Aop了，问题来了:如果C也跟A相互依赖，难道C去依赖A时，也要通过ObjectFactory获取A的代理对象么？如果是这样，A就存在2个代理对象了，A是单例的，因此这样不行，于是产生了一个新的缓存，我们称之为三级缓存。