1.什么是循环依赖：

这里给大家举个简单的例子，相信看了上一篇文章大家都知道了解了spring的生命周期创建流程。那么在Spring在生命周期的哪一步会出现循环依赖呢？

第一阶段：实例化阶段 Instantiation
第二阶段：属性赋值 Populate
第三阶段：初始化阶段 Initialization
第四阶段：销毁阶段 Destruction

首先在第一阶段实例化阶段，会出现循环依赖。

@Component
public class TestService {

   private OrderService orderService;
    
    public void TestService(OrderService orderService){
        this.orderService=orderService;
    }   
}

-----------------------------------
@Component
public class OrderService {

   private TestService testService;
    
    public void OrderService (TestService testService){
        this.testService=testService;
    }   
}

Spring在实例化阶段创建我们对象的时候，是通过反射调用我们的构造方法进行创建。如果你没有写无参构造方法，写了有参构造方法。那么spring就会调用你的有参构造方法进行创建对象。那么这个时候问题就来了，

1.首先TestService 它的有参对象是OrderService，这个时候spring就会对我的有参对象进行属性注入，它就会去创建我们的OrderService 。

2.在创建OrderService 的时候发现orderService的构造方法有参是TestService ，它又会去创建我们的TestService 。这个时候就会出现循环依赖，TestService 依赖OrderService ， OrderService 依赖TestService 。

其次在第二阶属性赋值阶段，也会出现循环依赖。

@Component
public class TestService {

    @Autowired
   private OrderService orderService;
  
}
-----------------------------------

@Component
public class OrderService {

    @Autowired
    private TestService testService;
}

Spring在调用我们构造方法进行创建对象后，就会进行属性赋值。

1. 当我们注入TestService 时，发现OrderService属性不在单例池中，就会去创建OrderService。
2. 创建OrderService时，发现OrderService也有属性需要注入，就会去注入TestService 。这个时候也会出现魂环依赖问题。那么对于Spring来说，它是怎么去解决这些循环依赖问题的呢？

---

2.解决思路：

下路就是循环依赖我画的简单流程图，如果要解决循环依赖。我们怎么去解决呢？

思路一： 既然每次都要查看单例池存不存在，那我实例化的时候就放入单例池中吗。这样不就可以解决循环依赖了吗。

假如你现在有两个线程，在实例化阶段完成后你就把TestService放入单例池中，这个时候线程二去单例池中获取TestService对象。线程二获取的是完整的spring对象吗？并不是，这个时候我们的TestService他没有走完我们的生命周期，线程二它获取的会是TestService的普通对象，如果在后面阶段TestService需要AOP呢，Spring给它生成了代理对象。这个时候线程二就拿不到TestService的代理对象了。

思路二：不能直接放入单例池中，那么我就搞一个Set 集合，每次实例化对象的时候就把BeanName存入集合当中，表示这个对象正在创建中。为了解决代理对象问题，我在生成一个map我们叫他earlySingletonObjects 。它用来存储我们的代理对象。

其实这样就可以解决循环依赖的问题了，但是Spring在这方面没有这样实现。而是采用了另一种方法。因为这样违背了Spring设计原则。
Spring结合AOP跟Bean的生命周期，是在Bean创建完全之后通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来完成的，在这个后置处理的postProcessAfterInitialization方法中对初始化后的Bean完成AOP代理。如果出现了循环依赖，那没有办法，只有给Bean先创建代理，但是没有出现循环依赖的情况下，设计之初就是让Bean在生命周期的最后一步完成代理而不是在实例化后就立马完成代理。

思路三：在实例化后，我在加入一个Map<String, ObjectFactory<?>> singletonFactories 的map，每次实例化之后就把当前类存入map中，等后面产生循环依赖时，我先从earlySingletonObjects 中去找，没有找到的话。我在去singletonFactories 中去找。

3.源码分析：

首先在我们spring中有三级缓存

	// 从上至下 分表代表这“三级缓存”
	//一级缓存 用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); 
	//二级缓存 提前曝光的单例对象的cache，存放原始的 bean 对象（尚未填充属性），用于解决循环依赖
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); 
	// 三级缓存 单例对象工厂的cache，存放 bean 工厂对象，用于解决循环依赖
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); 

1. 在构造Bean对象之后，将对象提前曝光到三级缓存中，这时候曝光的对象仅仅是构造完成，还没注入属性和初始化。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
           ''''''
            throws BeanCreationException {            
         // 这里就是调用你的构造方法，进行创建对象
         		if (instanceWrapper == null) {
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		Object bean = instanceWrapper.getWrappedInstance();
         '''''''
        // mbd.isSingleton() 判断对象是否是单例的
        // 当前对象是否允许循环依赖 this.allowCircularReferences 默认是true
        // isSingletonCurrentlyInCreation(beanName) 当前对象是否在创建中
        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");
            }
            // 循环依赖-添加到三级缓存中。value是lambda表达式，这个时候并未执行
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
        ……
    }   
}     

2. 提前曝光的对象被放入Map<String, ObjectFactory<?>> singletonFactories缓存中，这里并不是直接将Bean放入缓存，而是包装成ObjectFactory对象再放入。

	protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(singletonFactory, "Singleton factory must not be null");
		synchronized (this.singletonObjects) {
		// 一级缓存
			if (!this.singletonObjects.containsKey(beanName)) {
			 // 添加到三级缓存中
				this.singletonFactories.put(beanName, singletonFactory);
				// 从二级缓存中移除，因为在spring中bean是单例的，防止后面出现bug导致不是单例
				this.earlySingletonObjects.remove(beanName);
				// 将当前bean加入到set当中
				this.registeredSingletons.add(beanName);
			}
		}
	}

3. 为什么要包装一层ObjectFactory对象？

这里也就是Spring为什么采用第三级缓存的主要原因。

如果创建的Bean有对应的代理，那其他对象注入时，注入的应该是对应的代理对象；但是Spring无法提前知道这个对象是不是有循环依赖的情况，而正常情况下（没有循环依赖情况），Spring都是在创建好完成品Bean之后才创建对应的代理。这时候Spring有两个选择：
1.不管有没有循环依赖，都提前创建好代理对象，并将代理对象放入缓存，出现循环依赖时，其他对象直接就可以取到代理对象并注入。
2.不提前创建好代理对象，在出现循环依赖被其他对象注入时，才实时生成代理对象。这样在没有循环依赖的情况下，Bean就可以按着Spring设计原则的步骤来创建。

Spring选择了第二种方式，那怎么做到提前曝光对象而又不生成代理呢？
Spring就是在对象外面包一层ObjectFactory，提前曝光的是ObjectFactory对象，在被注入时才在ObjectFactory.getObject方式内实时生成代理对象，并将生成好的代理对象放入到第二级缓存Map<String, Object> earlySingletonObjects。

	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;
	}

为了防止对象在后面的初始化（init）时重复代理，在创建代理时，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);
	}

在这里spring会创建对象，判断你是否需要代理，是否创建代理对象。

	protected Object wrapIfNecessary(Object bean, String beanName, Object cacheKey) {
		if (StringUtils.hasLength(beanName) && this.targetSourcedBeans.contains(beanName)) {
			return bean;
		}
		if (Boolean.FALSE.equals(this.advisedBeans.get(cacheKey))) {
			return bean;
		}
		if (isInfrastructureClass(bean.getClass()) || shouldSkip(bean.getClass(), beanName)) {
			this.advisedBeans.put(cacheKey, Boolean.FALSE);
			return bean;
		}

		// Create proxy if we have advice.
		Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(bean.getClass(), beanName, null);
		if (specificInterceptors != DO_NOT_PROXY) {
			this.advisedBeans.put(cacheKey, Boolean.TRUE);
			Object proxy = createProxy(
					bean.getClass(), beanName, specificInterceptors, new SingletonTargetSource(bean));
			this.proxyTypes.put(cacheKey, proxy.getClass());
			return proxy;
		}

		this.advisedBeans.put(cacheKey, Boolean.FALSE);
		return bean;
	}

也可以理解为三级缓存的ObjectFactory其实在做的是一种缓存机制，当我们后面初始化需要代理时，Spring就会先从这个缓存中去拿代理对象，拿得到就不创建代理对象，而是使用这个代理对象。

4. 注入属性和初始化

Spring会调用populateBean（）进行属性注入，然后该对象在单例池中，就直接从单例池拿，不在就进行对象的创建并注入。

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
        ……
        // Initialize the bean instance.
        Object exposedObject = bean;
        try {
        // 注入属性
            populateBean(beanName, mbd, instanceWrapper);
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            }
            else {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }
        ……
    }        
}    

在进行对象创建过程中会调用getSingleton方法从缓存中获取注入对象

// 获取要注入的对象
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		// 先从单例池一级缓存中拿，看能不能获取bean
		Object singletonObject = this.singletonObjects.get(beanName);
		// 如果单例池拿的是空，并且正在创建中
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			// 那么就在从二级缓存中去拿
			singletonObject = this.earlySingletonObjects.get(beanName);
			// 如果二级缓存中没有，就加锁在进行判断
			if (singletonObject == null && allowEarlyReference) {
				synchronized (this.singletonObjects) {
					// 如果一级缓存还是没有
					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) {
							   // 三级缓存获取到了，（这时三级缓存会执行lambad表达式并创建普通对象或者代理对象）
								singletonObject = singletonFactory.getObject();
								// 把获取到的对象放入二级缓存中
								this.earlySingletonObjects.put(beanName, singletonObject);
								// 从三级缓存删除该对象，防止lambad表达式重复执行，防止出现bug让spring不能保证单例
								this.singletonFactories.remove(beanName);
							}
						}
					}
				}
			}
		}
		return singletonObject;
	}

5.放入已完成创建的单例缓存中
最终Spring会通过addSingleton方法将最终生成的可用的Bean放入到单例缓存里。

	/**
	 * Add the given singleton object to the singleton cache of this factory.
	 * <p>To be called for eager registration of singletons.
	 * @param beanName the name of the bean
	 * @param singletonObject the singleton object
	 */
	protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
			// 将创建好的bean放入一级缓存，单例池中
			this.singletonObjects.put(beanName, singletonObject);
			// 删除三级缓存
			this.singletonFactories.remove(beanName);
			// 删除二级缓存
			this.earlySingletonObjects.remove(beanName);
			// 放入已注册实例的Set集合当中
			this.registeredSingletons.add(beanName);
		}
	}

---

总结：

1.Spring有哪三级缓存

	// 从上至下 分表代表这“三级缓存”
	//一级缓存 用于存放完全初始化好的 bean，从该缓存中取出的 bean 可以直接使用
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); 
	//二级缓存 提前曝光的单例对象的cache，存放原始的 bean 对象（尚未填充属性），用于解决循环依赖
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); 
	// 三级缓存 单例对象工厂的cache，存放 bean 工厂对象，用于解决循环依赖
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); 

2.只要二级缓存，不要三级缓存可不可以。

其实我试验过，用二级缓存也可以达到和三级缓存同样的效果。只不过为了不违背Spring设计原则，Spring采用了三级缓存。
Spring结合AOP跟Bean的生命周期，是在Bean创建完全之后通过AnnotationAwareAspectJAutoProxyCreator这个后置处理器来完成的，在这个后置处理的postProcessAfterInitialization方法中对初始化后的Bean完成AOP代理。如果出现了循环依赖，那没有办法，只有给Bean先创建代理，但是没有出现循环依赖的情况下，设计之初就是让Bean在生命周期的最后一步完成代理而不是在实例化后就立马完成代理。

3. Spring三级缓存完整流程思路

1. 实例化普通对象UserService （对象U），将普通对象U加入Set集合（判断是不是在创建中），将对象U加入三级缓存

2. U注入属性OrderService（对象O），发现O不在创建中，实例化普通对象OrderService （对象O））将对象O加入Set集合（用于判断是不是在创建中），将对象O加入三级缓存。

3. O注入属性U，发现对象U在创建中（循环依赖），在一级缓存中找（没找到），在二级缓存中找（没找到），在三级缓存中（找到了），创建对象U的代理对象。将代理对象加入二级缓存，并在三级缓存中进行remove，将U的代理对象注入给O

4. 注入完属性后，就进行初始化等操作，完成对象的创建。将O注入到一级缓存中，从二级，三级缓存删除O对象。

5. O对象创建完成后，U对象就注入属性O的代理对象，U在完成初始化等操作，最后将U注入到一级缓存中，从二级，三级缓存删除O对象。

---