Spring Bean IOC、AOP 循环依赖解读

本文转载自微信公众号「bugstack虫洞栈」，作者小傅哥  。转载本文请联系bugstack虫洞栈公众号。

目录

• 一、前言
• 二、面试题
• 三、什么是循环依赖?
  • 1. 问题描述
  • 2. 问题体现
  • 3. 问题处理
• 四、源码分析
  • 1. 说说细节
  • 2. 处理过程
  • 3. 依赖解析
• 五、总结
• 六、系列推荐

一、前言

延迟满足能给你带来什么?

大学有四年时间，但几乎所有人都是临近毕业才发现找一份好工作费劲，尤其是我能非常熟悉的软件开发行业，即使是毕业了还需要额外花钱到培训机构，在学一遍编程技术才能出去找工作。好像在校这几年压根就没学到什么!

就我个人而言可能是因为上学期间喜欢编程，也从师哥、师姐那里听到一些关于毕业后找工作的不容易，也了解了一些社会上对程序员开发技能的要求级别。也就是得到了这些消息，又加上自己乐于折腾，我给自己定了一个每天都能完成的小目标：

红尘世界几个王，我自不服迎头上。

日敲代码两百行，冲进世界五百强。

哈哈哈，就这么每天两百行代码，一个月就是6千行，一年就是6万行，三年后开始实习就有18万行，一个应届实习生有将近20万行代码的敲击量，几乎已经可以非常熟练的完成各类简单的工作，在加上实习中对整个项目流程真正的断链后，找一个正经的开发工作，还是很容易的。

而这时候找工作的容易，就来自于你一直以来的学习和沉淀，但如果你没经过这些努力，可能等毕业后就会变得非常慌乱，最后没办法，只能去一些机构再学习一遍。

二、面试题

谢飞机，小记!，以前感觉Spring没啥，看过一篇getBean，我的天!

谢飞机：面试官，最近我看了 Spring 的 getBean 发现这里好多东西，还有一个是要解决循环依赖的，这玩意面试有啥要问的吗?

面试官：有哇，Spring 是如何解决循环依赖的?

谢飞机：嗯，通过三级缓存提前暴露对象解决的。

面试官：可以哈，那这三个缓存里都存放了什么样的对象信息呢?

谢飞机：一级缓存存放的是完整对象，也叫成品对象。二级缓存存放的是半成品对象，就是那些属性还没赋值的对象。三级缓存存放的是 ObjectFactory 类型的 lambda 表达式，就是这用于处理 AOP 循环依赖的。

面试官：可以呀，谢飞机有所准备嘛!那如果没有三级缓存，只有二级或者一级，能解决循环依赖吗?

谢飞机：其实我看过资料了，可以解决，只不过 Spring 要保证几个事情，只有一级缓存处理流程没法拆分，复杂度也会增加，同时半成品对象可能会有空指针异常。而将半成品与成品对象分开，处理起来也更加优雅、简单、易扩展。另外 Spring 的两大特性中不仅有 IOC 还有 AOP，也就是基于字节码增强后的方法，该存放到哪，而三级缓存最主要，要解决的循环依赖就是对 AOP 的处理，但如果把 AOP 代理对象的创建提前，那么二级缓存也一样可以解决。但是，这就违背了 Spring 创建对象的原则，Spring 更喜欢把所有的普通 Bean 都初始化完成，在处理代理对象的初始化。

面试官：飞机，不错嘛，这次了解了不少。那问个简单的，你撸过循环依赖的解决方案?

谢飞机：哦哦，这没有，没实践过!!!确实应该搞一下，试试。

三、什么是循环依赖?

1. 问题描述

了解问题的本质再分析问题，往往更利于对问题有更深入的了解和研究。所以我们在分析 Spring 关于循环依赖的源码之前，先要了解下什么是循环依赖。

循环依赖分为三种，自身依赖于自身、互相循环依赖、多组循环依赖。

但无论循环依赖的数量有多少，循环依赖的本质是一样的。就是你的完整创建依赖于我，而我的完整创建也依赖于你，但我们互相没法解耦，最终导致依赖创建失败。

所以 Spring 提供了除了构造函数注入和原型注入外的，setter循环依赖注入解决方案。那么我们也可以先来尝试下这样的依赖，如果是我们自己处理的话该怎么解决。

2. 问题体现

public class ABTest { 
 
    public static void main(String[] args) { 
        new ClazzA(); 
    } 
 
} 
 
class ClazzA { 
 
    private ClazzB b = new ClazzB(); 
 
} 
 
class ClazzB { 
 
    private ClazzA a = new ClazzA(); 
 
} 

• 这段代码就是循环依赖最初的模样，你中有我，我中有你，运行就报错 java.lang.StackOverflowError
• 这样的循环依赖代码是没法解决的，当你看到 Spring 中提供了 get/set 或者注解，这样之所以能解决，首先是进行了一定的解耦。让类的创建和属性的填充分离，先创建出半成品Bean，再处理属性的填充，完成成品Bean的提供。

3. 问题处理

在这部分的代码中就一个核心目的，我们来自己解决一下循环依赖，方案如下：

public class CircleTest { 
 
    private final static Map singletonObjects = new ConcurrentHashMap<>(256); 
 
    public static void main(String[] args) throws Exception { 
        System.out.println(getBean(B.class).getA()); 
        System.out.println(getBean(A.class).getB()); 
    } 
 
    private static  T getBean(Class beanClass) throws Exception { 
        String beanName = beanClass.getSimpleName().toLowerCase(); 
        if (singletonObjects.containsKey(beanName)) { 
            return (T) singletonObjects.get(beanName); 
        } 
        // 实例化对象入缓存 
        Object obj = beanClass.newInstance(); 
        singletonObjects.put(beanName, obj); 
        // 属性填充补全对象 
        Field[] fields = obj.getClass().getDeclaredFields(); 
        for (Field field : fields) { 
            field.setAccessible(true); 
            Class fieldClass = field.getType(); 
            String fieldBeanName = fieldClass.getSimpleName().toLowerCase(); 
            field.set(obj, singletonObjects.containsKey(fieldBeanName) ? singletonObjects.get(fieldBeanName) : getBean(fieldClass)); 
            field.setAccessible(false); 
        } 
        return (T) obj; 
    } 
 
} 
 
class A { 
 
    private B b; 
 
    // ...get/set 
} 
 
class B { 
    private A a; 
 
  // ...get/set 
} 

• 这段代码提供了 A、B 两个类，互相有依赖。但在两个类中的依赖关系使用的是 setter 的方式进行填充。也就是只有这样才能避免两个类在创建之初不非得强依赖于另外一个对象。
• getBean，是整个解决循环依赖的核心内容，A 创建后填充属性时依赖 B，那么就去创建 B，在创建 B 开始填充时发现依赖于 A，但此时 A 这个半成品对象已经存放在缓存到singletonObjects 中了，所以 B 可以正常创建，在通过递归把 A 也创建完整了。

四、源码分析

1. 说说细节

通过上面的例子我们大概了解到，A和B互相依赖时，A创建完后填充属性B，继续创建B，再填充属性A时就可以从缓存中获取了，如下：

那这个解决循环依赖的事放到 Spring 中是什么样呢?展开细节!

虽然，解决循环依赖的核心原理一样，但要放到支撑起整个 Spring 中 IOC、AOP 特性时，就会变得复杂一些，整个处理 Spring 循环依赖的过程如下;

• 以上就是关于 Spring 中对于一个有循环依赖的对象获取过程，也就是你想要的说说细节
• 乍一看是挺多流程，但是这些也基本是你在调试代码时候必须经过的代码片段，拿到这份执行流程，再调试就非常方便了。

2. 处理过程

关于本章节涉及到的案例源码分析，已更新到 github：https://github.com/fuzhengwei/interview - interview-31

以下是单元测试中对AB依赖的获取Bean操作，重点在于进入 getBean 的源码跟进;

@Test 
public void test_alias() { 
    BeanFactory beanFactory = new ClassPathXmlApplicationContext("spring-config.xml"); 
    Bean_A bean_a = beanFactory.getBean("bean_a", Bean_A.class); 
    logger.info("获取 Bean 通过别名：{}", bean_a.getBean_b()); 
} 

org.springframework.beans.factory.support.AbstractBeanFactory.java

@Override 
public  T getBean(String name, Class requiredType) throws BeansException { 
 return doGetBean(name, requiredType, null, false); 
} 

• 从 getBean 进入后，获取 bean 的操作会进入到 doGetBean。
• 之所以这样包装一层，是因为 doGetBean 有很多不同入参的重载方法，方便外部操作。

doGetBean 方法

protected  T doGetBean( 
  final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly) 
  throws BeansException { 
  
  // 从缓存中获取 bean 实例 
 Object sharedInstance = getSingleton(beanName); 
  
   // mbd.isSingleton() 用于判断 bean 是否是单例模式 
   if (mbd.isSingleton()) { 
     // 获取 bean 实例 
    sharedInstance = getSingleton(beanName, new ObjectFactory