Spring 为什么要用三级缓存来解决循环依赖（AOP），二级缓存不行吗

• 结论
• 解释
• 继续解释

  结论

  解决有代理对象的循环依赖不一定要三级缓存，用二级甚至一级也能解决，下面讨论下Spring为什么选择三级缓存这个方案。

  Spring最开始是没有三级缓存的，后面版本因为引入了AOP，有了代理对象，又因为存在循环依赖，为了保证依赖注入过程注入的是代理对象，且不完全打破Spring的设计原则（代理等这些后置处理器应当在初始化阶段完成），Spring选择稍微打破限制，引入三级缓存，提前对循环依赖的bean在依赖注入的时候就生成代理对象。

  解释

  Spring 现在的三级缓存如下：

  	/** 第一级缓存，存放可用的成品Bean。 */
  	private final Map singletonObjects = new ConcurrentHashMap<>(256);
  	/** 第三级缓存，存的是Bean工厂对象 */
  	private final Map> singletonFactories = new HashMap<>(16);
  	/** 第二级缓存，存放半成品的Bean，半成品的Bean是已创建了对象，但是未注入属性和进行初始化*/
  	private final Map earlySingletonObjects = new ConcurrentHashMap<>(16);
  

  Spring目前是通过二三级缓存配合，进行循环依赖的解决。

  首先，我们要明确Spring遵守的单例bean的创建流程，bean 先实例化，再属性赋值，依赖注入，再初始化。。。。这个基本过程。我们所说的代理对象其实就是初始化阶段，BeanPostProcessor后置处理器完成代理对象的。

  网上有很多地方说三级缓存是为了解决代理对象，这个说法并没有说到根本。

  如果我们单纯为了解决有代理的循环依赖，其实解决循环依赖用二级缓存甚至一级缓存就可以了，之所以用了三级缓存是Spring开发者的一种取舍造成的。

  对于如何解决带有AOP的循环依赖，有如下两种解决方案：

  1、无论这个bean有没有循环依赖，在依赖注入之前，就创建好这个bean的代理对象放入缓存，出现依赖注入的时候，直接从这个缓存拿取代理对象即可。

  2、不提前创建代理对象，当只有出现循环依赖的时候，才实时地创建代理对象。

  Spring 因为为了不完全违背bean的创建流程的定义（代理应当在属性赋值后的初始化过程中生成代理对象），只能勉为其难的提前进行。所以选择了上述的第二种方案。

  接下来，说一下为啥选择第二种方案要用三级缓存。

  spring 为了优雅，缓存尽量存储的是单一性质的元素，所以必须有第一级缓存，用来存放可用的成品Bean。

   private final Map singletonObjects = new ConcurrentHashMap<>(256);
  

  接下来，假如A 和 B 循环依赖，A 和 C也循环依赖，所以当创建A的bean的时候，避免B和C 拿到不同的代理对象，因此我们需要第二个缓存来存储B拿到的A的代理对象，当C去A代理对象的时候，就可以直接从第二个缓存中拿取了。

  为了实现只有出现循环依赖的时候才实时地创建代理对象这个过程，Spring 又引入了第三个缓存，第三个缓存的作用是当A在实例化的时候，就把自己放入第三个缓存，代码如下：

  if (earlySingletonExposure) {
  			if (logger.isTraceEnabled()) {
  				logger.trace("Eagerly caching bean '" + beanName +
  						"' to allow for resolving potential circular references");
  			}
  			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
  		}
  

  ，表示A正在创建当中，其中() -> getEarlyBeanReference(beanName, mbd, bean))的函数式接口就是用来实现创建代理对象的，

  protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
  		Object exposedObject = bean;
  		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
  				exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
  			}
  		}
  		return exposedObject;
  	}
  

  当B需要注入A的时候就会执行如下步骤：

  @Nullable
  	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  		// Quick check for existing instance without full singleton lock
  		Object singletonObject = this.singletonObjects.get(beanName);
  		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  			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) {
  							ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
  							if (singletonFactory != null) {
  								singletonObject = singletonFactory.getObject();
  								this.earlySingletonObjects.put(beanName, singletonObject);
  								this.singletonFactories.remove(beanName);
  							}
  						}
  					}
  				}
  			}
  		}
  		return singletonObject;
  	}
  

  先去第一级缓存拿，没有就去第二级缓存拿，二级没有的话，就去第三级缓存看看，当在第三级缓存发现有A的时候，说明此时A正在创建中，且未被其他bean引用，此时就会从三级缓存中取出beanFactory，beanFactory再执行getObject方法，getObjetc方法就前面的

  protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
  		Object exposedObject = bean;
  		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
  			for (SmartInstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().smartInstantiationAware) {
  				exposedObject = bp.getEarlyBeanReference(exposedObject, beanName);
  			}
  		}
  		return exposedObject;
  	}
  

  其中SmartInstantiationAwareBeanPostProcessor 是spring内部对于BeanPostProcessor的实现，大家可以自己点去看看，SmartInstantiationAwareBeanPostProcessor 的getEarlyBeanReference就是创建代理对象，并标记自己已经创建了代理对象（earlyProxyReferences）。

  	@Override
  	public Object getEarlyBeanReference(Object bean, String beanName) {
  		Object cacheKey = getCacheKey(bean.getClass(), beanName);
  		this.earlyProxyReferences.put(cacheKey, bean);
  		return wrapIfNecessary(bean, beanName, cacheKey);
  	}
  

  此时B相当于从三级缓存中拿到了A的代理对象，B为了后面的C和自己拿到的是同一个A的代理对象，他就需要把这个A代理对象放入第二级缓存。同时移除第三级缓存的A，表示A已经提前创建好了代理对象，不需要再从三级缓存里面获取新代理对象了。

  接下来，B的创建好后，A继续注入C，C直接从第二级拿到已经创建好了的A的代理对象。A在后面的初始化阶段执行applyBeanPostProcessorsAfterInitialization

  @Override
  	public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
  			throws BeansException {
  		Object result = existingBean;
  		for (BeanPostProcessor processor : getBeanPostProcessors()) {
  			Object current = processor.postProcessAfterInitialization(result, beanName);
  			if (current == null) {
  				return result;
  			}
  			result = current;
  		}
  		return result;
  	}
  @Override
  public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
  	if (bean != null) {
  		Object cacheKey = getCacheKey(bean.getClass(), beanName);
                  //判断是否提前创建了代理对象
  		if (this.earlyProxyReferences.remove(cacheKey) != bean) {
  			return wrapIfNecessary(bean, beanName, cacheKey);
  		}
  	}
  	return bean;
  }
  

  的时候，会判断之前是否提前创建了代理对象，这样就解决了带有AOP的循环依赖。

  当然，如果A没有循环依赖，那么就不会被其他bean从第三级缓存中取出来执行getEarlyBeanReference方法，这样A的AOP自然就留在了初始化阶段完成了，这样也就遵守了Spring定义的bean的创建过程。

  继续解释

  继续解释下为什么我说只用二级或者一级缓存也能解决带有AOP的循环依赖问题。

  假如不遵守Spring强烈要求bean的创建过程，我们可以直接在依赖注入前，就往第二级缓存存入A的代理对象（如果没有代理就直接存原始对象），这样B和C直接就可以从第二级缓存拿到A的代理对象，这样两个缓存就能解决了，但是这样做就是提前把代理对象都创建好了。

  如果我们更过分点，不遵守每一级缓存存入的是同一过程性质的bean，那么我们只需一级缓存，每个bean提前创建好代理对象就放入一级缓存，（此时一级缓存的bean还是未初始化的bean），接下来B直接从一级拿到A的代理对象，完成创建，B把自己完整的Bean也放入一级缓存，此时一级缓存的bean 就有中间态和完成态两种形态的bean, 最终A完成创建，一级缓存全是完成态Bean。这样做，只用一级缓存就能完成所有的过程，只是不优雅~~。

   
   建婚恋网站需要多少钱  dw网页设计案例  东台网站建设解决方案  网页设计怎么弄  手机网页制作工具  专业做网站价格