Spring循环依赖实现过程揭秘

/** * 一级缓存 * 用于保存beanName和创建bean实例之间的关系，是已经实例化和初始化完成的bean */ private final Map singletonObjects = new ConcurrentHashMap<>(256); /** * 二级缓存 * 用于保存beanName和创建bean实例之间的关系，与singletonObject的区别是这里面的bean是半成品，只完成实例化没有完成初始化; * 与singletonFactories的区别是，当一个单例bean被放到这里之后，那么当bean还在创建过程中就可以通过getBean方法获取到，可以方便进行循环依赖的检测。 */ private final Map earlySingletonObjects = new ConcurrentHashMap<>(16); /** * 三级缓存 * 用于保存beanName和和创建bean的工厂之间的关系，ObjectFactory就是一个Lambda表达式。 */ private final Map> singletonFactories = new ConcurrentHashMap<>(16); 

@Component public class A { @Autowired private B b; public B getB() { return b; } public void setB(B b) { this.b = b; } } @Component public class B { @Autowired private A a; public A getA() { return a; } public void setA(A a) { this.a = a; } } @Configuration @ComponentScan(basePackages = "com.mashibing.selfcycle") public class CycleConfig { } public class TestCycle { public static void main(String[] args) { final AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext(CycleConfig.class); ac.close(); } }

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean // 为避免后期循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂 // bean是实例化后的bean对象 addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) { // 默认最终公开的对象是bean,通过createBeanInstance创建出来的普通对象 Object exposedObject = bean; // mbd的systhetic属性：设置此bean定义是否是"synthetic"，一般是指只有AOP相关的pointCut配置或者Advice配置才会将 synthetic设置为true // 如果mdb不是synthetic且此工厂拥有InstantiationAwareBeanPostProcessor if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { // 遍历工厂内的所有后处理器 for (BeanPostProcessor bp : getBeanPostProcessors()) { // 如果bp是SmartInstantiationAwareBeanPostProcessor实例 if (bp instanceof SmartInstantiationAwareBeanPostProcessor) { SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp; // 让exposedObject经过每个SmartInstantiationAwareBeanPostProcessor的包装 exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName); } } } } 

	public Object resolveCandidate(String beanName, Class requiredType, BeanFactory beanFactory) throws BeansException { return beanFactory.getBean(beanName); } 

DefaultSingleBeanRegistry.java @Nullable protected Object getSingleton(String beanName, boolean allowEarlyReference) { // Quick check for existing instance without full singleton lock // 从单例对象缓存中获取beanName对应的单例对象 Object singletonObject = this.singletonObjects.get(beanName); // 如果单例对象缓存中没有，并且该beanName对应的单例bean正在创建中 if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) { //从早期单例对象缓存中获取单例对象（之所称成为早期单例对象，是因为earlySingletonObjects里 // 的对象的都是通过提前曝光的ObjectFactory创建出来的，还未进行属性填充等操作） singletonObject = this.earlySingletonObjects.get(beanName); // 如果在早期单例对象缓存中也没有，并且允许创建早期单例对象引用 if (singletonObject == null && allowEarlyReference) { // 如果为空，则锁定全局变量并进行处理 synchronized (this.singletonObjects) { // Consistent creation of early reference within full singleton lock singletonObject = this.singletonObjects.get(beanName); if (singletonObject == null) { singletonObject = this.earlySingletonObjects.get(beanName); if (singletonObject == null) { // 当某些方法需要提前初始化的时候则会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletonFactories ObjectFactory singletonFactory = this.singletonFactories.get(beanName); if (singletonFactory != null) { // 如果存在单例对象工厂，则通过工厂创建一个单例对象 singletonObject = singletonFactory.getObject(); // 记录在缓存中，二级缓存和三级缓存的对象不能同时存在 this.earlySingletonObjects.put(beanName, singletonObject); // 从三级缓存中移除 this.singletonFactories.remove(beanName); } } } } } } return singletonObject; } 

	protected void addSingleton(String beanName, Object singletonObject) { synchronized (this.singletonObjects) { // 将映射关系添加到单例对象的高速缓存中 this.singletonObjects.put(beanName, singletonObject); // 移除beanName在单例工厂缓存中的数据 this.singletonFactories.remove(beanName); // 移除beanName在早期单例对象的高速缓存的数据 this.earlySingletonObjects.remove(beanName); // 将beanName添加到已注册的单例集中 this.registeredSingletons.add(beanName); } }