Spirng循环依赖报错Isthereanunresolvablecircularreference？

　　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： @Component public class BrokenComponent {      @Autowired     private TolenComponent tolenComponent;     @Resource     private TubunComponent tubunComponent; }
　　TolenComponent： @Transactional @Component public class TolenComponent {      @Resource     private TubunComponent tubunComponent;  }
　　TubunComponent： public class TubunComponent {      private DenpaComponent denpaComponent;      public TubunComponent(DenpaComponent denpaComponent) {         this.denpaComponent = denpaComponent;     } }
　　TwConfig： @Configuration public class TwConfig {      @Bean     public TubunComponent tubunComponent(DenpaComponent denpaComponent) {         return new TubunComponent(denpaComponent);     } }
　　DenpaComponent： @Component public 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 容器加载过程中比较重要的类/属性
　　类名称
　　方法
　　作用
　　DefaultListableBeanFactory
　　preInstantiateSingletons
　　Trigger initialization of all non-lazy singleton beans.../ 触发所有非懒加载的单例bean进行初始化
　　AbstractBeanFactory
　　getBean/doGetBean
　　从容器中获取bean
　　DefaultSingletonBeanRegistry
　　getSingleton
　　从缓存中获取单例实例，没有则走单例的创建流程
　　DefaultSingletonBeanRegistry
　　beforeSingletonCreation
　　创建单例之前会将单例放在set集合（singletonsCurrentlyInCreation）中，有检查bean是否被循环依赖的作用
　　DefaultSingletonBeanRegistry
　　beforeSingletonCreation
　　创建单例之后会将单例从set集合（singletonsCurrentlyInCreation）中移除
　　AbstractAutowireCapableBeanFactory
　　createBean/doCreateBean
　　创建单例bean
　　AbstractAutowireCapableBeanFactory
　　populateBean
　　对bean进行属性赋值（往往是二级缓存中的bean）
　　AbstractAutowireCapableBeanFactory
　　initializeBean
　　对属性赋值之后的bean进行初始化，加载RootBeanDefinition信息，这一步做完才是一个完整的可用的beanpublic 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 InitDestroyAnnotationBeanPostProcessor 		implements InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable {               ... 	@Override 	public 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 InstantiationAwareBeanPostProcessorAdapter 		implements MergedBeanDefinitionPostProcessor, PriorityOrdered, BeanFactoryAware {         ... 	@Override 	public 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 的组合不会报错。
　　偏偏使用了会报错的一种组合......