1：前言

最近在项目中遇到了一次循环依赖报错的问题，虽然解决的很快，但是有些不明白的地方，特此记录。在此我把 bean 的结构和 注入方式单独拎出来进行演示

1.1：报错提示

1.2：错误日志

Exception encountered during context initialization – cancelling refresh attempt:org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘brokenComponent’: Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name ‘tubunComponent’ defined in class path resource [com/dev/config/sprngcache3/TwConfig.class]: Unsatisfied dependency expressed through method ‘tubunComponent’ parameter 0; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name ‘denpaComponent’: Unsatisfied dependency expressed through field ‘tolenComponent’; nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name ‘tolenComponent’: Injection of resource dependencies failed; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name ‘tubunComponent’:Requested bean is currently in creation:Is there an unresolvable circular reference?

1.3：stack overflow问题描述

Requested bean is currently in creation: Is there an unresolvable circular reference?

点击进入 stack overflow 问题描述

1.4：bean 依赖结构

BrokenComponent：

@Componentpublic class BrokenComponent { @Autowired private TolenComponent tolenComponent; @Resource private TubunComponent tubunComponent;}

TolenComponent：

@Transactional@Componentpublic class TolenComponent { @Resource private TubunComponent tubunComponent;}

TubunComponent：

public class TubunComponent { private DenpaComponent denpaComponent; public TubunComponent(DenpaComponent denpaComponent) { this.denpaComponent = denpaComponent; }}

TwConfig：

@Configurationpublic class TwConfig { @Bean public TubunComponent tubunComponent(DenpaComponent denpaComponent) { return new TubunComponent(denpaComponent); }}

DenpaComponent：

@Componentpublic class DenpaComponent { @Autowired private TolenComponent tolenComponent;}

除了 tubunComponent 是构造器注入，其他的bean 都是set 注入。分析bean依赖图可以发现确实是循环依赖的问题。

2：问题分析

由于本人对spring bean 的加载机制不是很清晰，这次特意花了几天时间做了梳理。

2.1：spring 的 bean 加载过程

2.2：spring 的三级缓存

解决了什么问题？

推荐博客：https://cloud.tencent.com/developer/article/1497692

2.3：Spring 容器加载过程中比较重要的类/属性

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {/** Cache of singleton objects: bean name to bean instance.（一级缓存，存放已初始化完毕的bean） */private final Map singletonObjects = new ConcurrentHashMap(256);/** Cache of singleton factories: bean name to ObjectFactory.（三级缓存，存放未进行过初始化的beanFactory） */private final Map singletonFactories = new HashMap(16);/** Cache of early singleton objects: bean name to bean instance. （二级缓存，存放已实例化，但未进行装配过属性的bean）*/private final Map earlySingletonObjects = new HashMap(16);/** Set of registered singletons, containing the bean names in registration order.（存放已注册了的单例集合 = singletonObjects.size + earlySingletonObjects）*/private final Set registeredSingletons = new LinkedHashSet(256);/** Names of beans that are currently in creation.（存放正在被创建的实例，用于检查是否有循环依赖） */private final Set singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap(16)); ….}

2.4：注册后处理器->BeanPostProcessor

作用：对通过 BeanFactory 创建的 bean 进行属性填充。

这是AbstractAutowireCapableBeanFactory#populateBean 方法中的某一段代码：

for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {if (filteredPds == null) {filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);}pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvsToUse == null) {return;}}pvs = pvsToUse;}}

我打出了所有要进行轮询校验的 BeanPostProcessor

brokenComponent 中有两个bean:

一个是通过@Resource 注解注入的，一个是通过@Autowire 进行注入的，奉劝各位同学千万不要两种混用啊！！！

2.4.1：CommonAnnotationBeanPostProcessor

/** * … *

The central element is the {@link javax.annotation.Resource} annotation * for annotation-driven injection of named beans, by default from the containing * Spring BeanFactory, with only {@code mappedName} references resolved in JNDI. * The {@link #setAlwaysUseJndiLookup “alwaysUseJndiLookup” flag} enforces JNDI lookups * equivalent to standard Java EE 5 resource injection for {@code name} references * and default names as well. The target beans can be simple POJOs, with no special * requirements other than the type having to match. * *

The JAX-WS {@link javax.xml.ws.WebServiceRef} annotation is supported too, * analogous to {@link javax.annotation.Resource} but with the capability of creating * specific JAX-WS service endpoints. This may either point to an explicitly defined * resource by name or operate on a locally specified JAX-WS service class. Finally, * this post-processor also supports the EJB 3 {@link javax.ejb.EJB} annotation, * analogous to {@link javax.annotation.Resource} as well, with the capability to * specify both a local bean name and a global JNDI name for fallback retrieval. * The target beans can be plain POJOs as well as EJB 3 Session Beans in this case. * … */public class CommonAnnotationBeanPostProcessor extends InitDestroyAnnotationBeanPostProcessorimplements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable { …@Overridepublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {InjectionMetadata metadata = findResourceMetadata(beanName, bean.getClass(), pvs);try {metadata.inject(bean, beanName, pvs);}catch (Throwable ex) {throw new BeanCreationException(beanName, “Injection of resource dependencies failed”, ex);}return pvs;} }

通过翻译及反复debug验证，这个类将对某个bean中所有被 @Resource 注解修饰的属性进行填充。

2.4.2：AutowiredAnnotationBeanPostProcessor

/** * {@link org.springframework.beans.factory.config.BeanPostProcessor} implementation * that autowires annotated fields, setter methods and arbitrary config methods. * Such members to be injected are detected through a Java 5 annotation: by default, * Spring’s {@link Autowired @Autowired} and {@link Value @Value} annotations. * *

Also supports JSR-330’s {@link javax.inject.Inject @Inject} annotation, * if available, as a direct alternative to Spring’s own {@code @Autowired}. * … * @see Autowired * @see Value */public class AutowiredAnnotationBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapterimplements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware { …@Overridepublic PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) {InjectionMetadata metadata = findAutowiringMetadata(beanName, bean.getClass(), pvs);try {metadata.inject(bean, beanName, pvs);}catch (BeanCreationException ex) {throw ex;}catch (Throwable ex) {throw new BeanCreationException(beanName, “Injection of autowired dependencies failed”, ex);}return pvs;}}

这个类将对某个bean中所有被 @Autowire@Value 注解修饰的属性进行填充。

2.4.3：@Autowire VS @Resource

1：无论使用@Resource 还是 @Resource，都不影响bean的初始化顺序。

2：@Resource修饰的属性 要优先于 @Autowire修饰的属性 进行初始化。

2.5：报错流程

1: getBean(“brokenComponent”) -> getSingleton(“brokenComponent”) -> beforeSingletonCreation(“brokenComponent”) -> createBean(“brokenComponent”) -> addSingletonFactory(“brokenComponent”) -> inject() ->2: getBean(“tubunComponent”,TubunComponent.class) -> getSingleton(“tubunComponent”) -> beforeSingletonCreation(“tubunComponent”) -> 3：getBean(“twConfig”) -> getSingleton(“twConfig”) -> beforeSingletonCreation(“twconfig”) -> addSingletonFactory(“twConfig”) -> afterSingletonCreation(“twConfig”)4：getBean(“denpaComponent”) -> getSingleton(“denpaComponent”) -> beforeSingletonCreation(“denpaComponent”) -> createBean(“denpaComponent”) ->addSingletonFactory(“denpaComponent”) -> inject() ->5：getBean(“tolenComponent”) -> getSingleton(“tolenComponent”) -> beforeSingletonCreation(“tolenComponent”) -> createBean(“tolenComponent”) ->addSingletonFactory(“tolenComponent”) -> inject() ->6：getBean(“tubunComponent”,TubunComponent.class) -> getSingleton(“tubunComponent”) -> beforeSingletonCreation(“tubunComponent”) -> 报错7：afterSingletonCreation(“tolenComponent”) -> afterSingletonCreation(“denpaComponent”) -> afterSingletonCreation(“tubunComponent”) -> afterSingletonCreation(“brokenComponent”)

可以看到 tubunComponent 进行了两次 getSingleton，经过循环依赖检查的时候报错了。

2.6：错误流程分析归纳

1：Spring 容器先加载 brokenComponent 这个 bean。

2：brokenComponent依赖了tubunComponent（@Resource修饰），因此优先填充 tubunComponent，因此去初始化tubunComponent 这个bean，并将tubunComponent 存放在 DefaultSingletonBeanRegistry.singletonsCurrentlyInCreation 集合中。

3：tubunComponent依赖了depenComponent，因此去初始化depenComponent 这个bean，并将depenComponent 存放在 DefaultSingletonBeanRegistry.singletonsCurrentlyInCreation 集合中。

4：depenComponent依赖了tolenComponent，因此去初始化depenComponent 这个bean，并将tolenComponent 存放在 DefaultSingletonBeanRegistry.singletonsCurrentlyInCreation 集合中。

5：tolenComponent依赖了tubunComponent，因此去初始化tubunComponent 这个bean，然而当将tubunComponent 存放在 DefaultSingletonBeanRegistry.singletonsCurrentlyInCreation 集合中时发现 tubunComponent 已经存在了，从而判断这几个bean 产生了循环依赖并跑出异常。

beforeSingletonCreation(String beanName) 方法源码：

/** * Callback before singleton creation. *

The default implementation register the singleton as currently in creation. * @param beanName the name of the singleton about to be created * @see #isSingletonCurrentlyInCreation */protected void beforeSingletonCreation(String beanName) {if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}}

2.7：解决方式

1：使用@Lazy 修饰。

2：这其实是一个操作不当造成的问题，因为spring的三级缓存已经解决了set注入导致的循环依赖，而这几个bean并不是全部都是使用构造器注入。

在 brokeComponent 中使用@Autowired修饰了tolenComponent，又用@Resource 修饰了tubunComponent，导致tubunComponent要优先于tolenComponent优先加载，而tolenComponent 又依赖了tubunComponent，因此报错。我们只需要让tolenComponent 优先于 tubunComponent 优先加载就可以了。

实验证明：

1：@Resource 修饰 tolenComponent + @Resource 修饰 tubunComponent 的组合不会报错。2：@Resource 修饰 tolenComponent + @Autowired 修饰 tubunComponent 的组合不会报错。3：@Autowired 修饰 tolenComponent + @Autowired 修饰 tubunComponent 的组合不会报错。

偏偏使用了会报错的一种组合……