Sping 解决循环依赖

循环依赖代码示例：

@Component
public class AService{
    @AutoWired
    public BService bService;
    @AutoWired
    public CService cService;

    public void test(){
          System.out.println(bService);
    }
}

@Component
public class BService{
    @AutoWired
    public AService aService;
}

@Component
public class CService{
    @AutoWired
    public AService aService;
}

---

AService创建生命周期

AService出现了循环依赖，才需要提前aop

0. creatingSet("aService")。

1. 创建一个AService普通对象 -->存入三级缓存singletonFactories<aService, lambda表达式>。

• singletonFactories：三级缓存存放的map。
• 存的lambda表达式：主要作用是判断返回代理对象还是普通对象。用于打破循环依赖。

2. 填充bService属性-->去单例池中找BService对象-->创建BService的Bean对象。

3. 填充其他属性。

4. 其他操作。

5. 初始化后（AOP）--> AService代理对象（如果需要aop）-->二级缓存中取一次完整的单例bean。

6. 放入单例池singletonObjects。

---

BService创建生命周期

1. 创建一个BService普通对象。

2. 填充aService属性-->去单例池中找AService对象-->creatingSet-->出现了循环依赖-->从二级缓存earlySingletonObjects拿暂存对象-->从三级缓存singletonFactories拿表达式-->执行lambda表达式-->普通对象/需要aop则获得AService代理对象-->存入二级缓存earlySingletonObjects并且移除三级缓存。

lmbda添加到三级缓存.png 获取单例bean主要源码.png

• 提前aop时，会用earlyProxyReferenes.put(cacheKey, bean)；存入标识。cacheKey是bean.getClass();

  
  提前aop.png

3. 填充其他属性。

4. 其他操作。

5. 初始化后（AOP）--> BService代理对象（如果需要aop）-->二级缓存中取一次完整的单例bean。

• 正常aop时会根据CacheKey获取 earlyProxyReferenes 里的bean判断是否有进行提前aop，如果已经提前aop，则不需要再aop

  
  未提前正常进行aop.png

6. 放入单例池singletonObjects。

---

CService创建生命周期

基本逻辑同BService一致，主要为了说明如果没有二级缓存时，会出现多次创建同一个（AService）不完整bean的问题。

1. 创建一个CService普通对象。

2. 填充aService属性-->去单例池中找AService对象-->creatingSet-->出现了循环依赖-->从二级缓存earlySingletonObjects拿暂存对象-->从三级缓存singletonFactories拿表达式-->执行lambda表达式-->普通对象/需要aop则获得AService代理对象-->存入二级缓存earlySingletonObjects并且移除三级缓存。

• 如果这里没有二级缓存，则会重新进行aop，并且重新创建一个不完整的AService。

3. 填充其他属性。

4. 其他操作。

5. 初始化后（AOP）--> CService代理对象（如果需要aop）-->二级缓存中取一次完整的单例bean。

6. 放入单例池singletonObjects。

---

总结

单例池：singletonObjects

1.保存生成的bean对象。
2.保证生成的bean是单例bean。

二级缓存：earlySingletonObjects

1.保存未生成完整的普通对象或者代理对象，暂存，后面步骤会完善对象。
2.保证不完整的bean对象是单例的，不重复创建多个不完整的bean。

三级缓存：singletonFactories

1.打破循环依赖，一开始并不知道会不会出现循环依赖，直接存放lambda表达式。
2.存放的lambda表达式主要用于判断是否需要aop，需要返回普通对象还是代理对象。
3.让解决循环依赖的步骤更方便。

是否提前Aop Map：earlyProxyReferenes

1.提前aop时，会用earlyProxyReferenes.put(cacheKey, bean)；存入标识。cacheKey是bean.getClass();
2.正常aop时会根据CacheKey获取 earlyProxyReferenes 里的bean判断是否有进行提前aop，如果已经提前aop，则不需要再aop。

---

其他问题

问题1：使用异步注解@Async

1. 会生成一个新的代理对象，与aop生成的代理对象不一致，导致报错，无法解决循环依赖问题。
2. 因为提前aop生成代理对象是有进行存储并且判断是否已生成代理对象，而异步也有代理逻辑，需要生成代理对象，并没有进行判断。

    @Async
    public void test(){
          System.out.println(bService);
    }

bean发生改变则报错.png

3. aop与异步生成代理对象方法：

   
   初始化后创建代理对象.png

• 上图438行，aop进行生成代理对象时的processor 实现有进行判断，正是上诉的第五步。
  而异步生成代理对象时的processor实现则没有。

  
  异步的processor.png

---

问题2：使用构造方法方式注入

构造方法方式代码示例：

@Component
public class AService{
    
    public BService bService;

    public AService(BService bService){
        this.bService = bService;
    }

    public void test(){
          System.out.println(bService);
    }
}

@Component
public class BService{
    
    public AService aService;

    public BService(AService aService){
        this.aService = aService;
    }
}

• 构建方法时循环依赖时是没办法通过Spring 容器去获取bean的，所以无法bean创建出来。

---

解决问题

问题1：

1. 在依赖BService时增加@Lazy注解，增加该注解后，赋值bService时，并不会真正的从Spring容器中去找到BService对象赋值给它，而是生成一个代理对象直接赋值给它。
2. 在test方法中真正使用到该对象方法时，才会去Spring Bean容器中看有没有这个对象。如果有，直接拿来用。
3. 如果Spring容器中没有BService没有才会去创建BService，这个时候BService依赖的AService的创建生命周期已经完成了，AService已经存在了，所以不会出现循环依赖了。

@Component
public class AService{
    @AutoWired
    @Lazy
    public BService bService;

    @Async
    public void test(){
          System.out.println(bService);
    }
}

问题2：

• 解决思路同问题1，使用@Layz注解。

@Component
public class AService{
    
    public BService bService;
    @Layz
    public AService(BService bService){
        this.bService = bService;
    }

    public void test(){
          System.out.println(bService);
    }
}