循环依赖的处理流程

1
2
3
4
5
6
7
8
9

@Service
public class CyclicGoodsServiceImpl implements CyclicGoodsService {
	@Autowired
	private CyclicOrderService cyclicOrderService;
	@Override
	public CyclicOrderService getCyclicOrderService() {
		return cyclicOrderService;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

@Service
public class CyclicGoodsServiceImpl implements CyclicGoodsService {
	@Autowired
	private CyclicOrderService cyclicOrderService;

	@Override
	public CyclicOrderService getCyclicOrderService() {
		return cyclicOrderService;
	}
}

@Service
public class CyclicOrderServiceImpl implements CyclicOrderService {
	@Autowired
	private CyclicGoodsService cyclicGoodsService;

	@Override
	public CyclicGoodsService getCyclicGoodsService() {
		return cyclicGoodsService;
	}
}

@Slf4j
public class ApplicationContextTest {
    @Test
    public void testCyclicDependence(){
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext("top.wlz922.cyclic");
        CyclicGoodsService goodsService = context.getBean(CyclicGoodsService.class);
        CyclicOrderService orderService = context.getBean(CyclicOrderService.class);
        log.debug(goodsService.toString());
        log.debug(orderService.toString());
    }
}

1
2

19:34:42.334 [main] DEBUG top.wlz922.test.context.ApplicationContextTest 36 - top.wlz922.cyclic.CyclicGoodsServiceImpl@7fa98a66
19:34:42.335 [main] DEBUG top.wlz922.test.context.ApplicationContextTest 37 - top.wlz922.cyclic.CyclicOrderServiceImpl@15ff3e9e

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

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {

    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
	                          @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

		//转换beanName，这里传入进来的beanName可能是以&开头的，这里会截掉&
		final String beanName = transformedBeanName(name);
		Object bean;

		/*
		TODO 这里多级缓存用于解决循环依赖问题。
			注：循环依赖只能是属性见的依赖，不能是构造函数中参数的循环依赖。
		    从缓存（一级二级三级缓存依次获取，获取到就返回）中获取单例实例，如果获取到并且是无参构造函数，则将bean变量的值赋值。
		 */
		// Eagerly check singleton cache for manually registered singletons.
		Object sharedInstance = getSingleton(beanName);
		if (sharedInstance != null && args == null) {
			// 省略无关代码
			// 如果bean不是FactoryBean类型或者beanName以&开头，则直接返回。
			// 否则将bean强转为FactoryBean类型，并调用getObject()方法返回。
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		} 
		// 省略无关代码...
		return (T) bean;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    /** 一级缓存 里面存储的是bean实例，在bean实例化完成、依赖注入、代理生成等流程全部完成之后，会存储到这个容器中 */
    /** Cache of singleton objects: bean name to bean instance. */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
    
    /** 
     * 三级缓存，在单例bean刚刚创建完成时，会将其封装成一个ObjectFactory对象，存储到这个容器中。键值是beanName。
     * 从源码中可以看到，实际上是提供了一些通过BeanPostProcessor进行的扩展操作。这里不会执行，只是把这个扩展操作流程封装起来。
     * 实际上，这里封装的一个函数式接口，在这里可以通过BeanPostProcessor进行一些扩展操作，其节点是bean实例化之后，
     * 在真正getBean时，会触发调用。 */
    /** Cache of singleton factories: bean name to ObjectFactory. */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    /** 
     * 二级缓存 从三级缓存获取后，会将bean实例存储到二级缓存，并从三级缓存中移除。这里封装了一个函数式接口的匿名实例，
     *  依赖注入过程中通过getBean方法获取这个实例时，可以对其进行一些指定操作，比如说aop代理对象生成，就可能在这里触发。
     */
    /** Cache of early singleton objects: bean name to bean instance. */
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		/**
		 * 从一级缓存中取，如果有值，则返回。否则依次查找二级、三级缓存，如果最终从三级缓存中拿到值，
		 * 则将bean对象升级到二级缓存，并把原值从三级缓存中移除。
 		 */
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				singletonObject = this.earlySingletonObjects.get(beanName);
				if (singletonObject == null && allowEarlyReference) {
					ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
					if (singletonFactory != null) {
						singletonObject = singletonFactory.getObject();
						this.earlySingletonObjects.put(beanName, singletonObject);
						this.singletonFactories.remove(beanName);
					}
				}
			}
		}
		return singletonObject;
	}
}

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

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    			throws BeanCreationException {
		// 省略无关代码...
        // 创建bean实例
        if (instanceWrapper == null) {
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        // 省略代码：对一些注解支持的扫描、合并到BeanDefinition...
        // Eagerly cache singletons to be able to resolve circular references
        // even when triggered by lifecycle interfaces like BeanFactoryAware.
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isTraceEnabled()) {
                logger.trace("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            // 提前暴露bean实例的引用，这时候的bean是刚刚创建完成的，还没有进行属性的依赖注入、等流程处理。
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
    }
}

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

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		synchronized (this.singletonObjects) {
			if (!this.singletonObjects.containsKey(beanName)) {
				// 将这个bean的匿名对象，存储到三级缓存。匿名对象中封装了一个扩展点的操作。
				this.singletonFactories.put(beanName, singletonFactory);
				this.earlySingletonObjects.remove(beanName);
				this.registeredSingletons.add(beanName);
			}
		}
	}
}

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

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
		Object exposedObject = bean;
		// 获取早期的Bean对象的引用，这时候的Bean还没有完成依赖注入及其后面的流程。
		// 在这里获取引用时，支持一些扩展操作，其扩展内容是通过 getEarlyBeanReference() 实现的。
		// getEarlyBeanReference() 来自 BeanPostProcessor 的子接口 SmartInstantiationAwareBeanPostProcessor。
		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
			for (BeanPostProcessor bp : getBeanPostProcessors()) {
				if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
					SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
					exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
				}
			}
		}
		return exposedObject;
	}
}

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

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "Bean name must not be null");
		synchronized (this.singletonObjects) {
			// 省略无关代码...	
            //这里调用了外层传进来的匿名内部类，lambda表达式。
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
				
            // 省略无关代码...
            // 加入一级缓存
            if (newSingleton) {
                addSingleton(beanName, singletonObject);
            }
		}
		return singletonObject;
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			this.singletonObjects.put(beanName, singletonObject);
			this.singletonFactories.remove(beanName);
			this.earlySingletonObjects.remove(beanName);
			this.registeredSingletons.add(beanName);
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
                                  @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        // Fail if we're already creating this bean instance:
        // We're assumably within a circular reference.
        // 多例不支持循环引用。多例时，如果返回指定的原型bean是否正在创建中，则抛出异常。
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }
}

1
2
3
4
5
6

try {
    // 省略无关代码，如果这里有构造函数中的循环依赖，则抛出异常
}catch (BeansException ex) {
    throw new UnsatisfiedDependencyException(
            mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam), ex);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

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

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