@Service
public class AServiceImpl implements AService {
    @Autowired
    private BService bService;
    ...
}
@Service
public class BServiceImpl implements BService {
    @Autowired
    private AService aService;
    ...
}

@Service
public class A {
    public A(B b) {
    }
}
@Service
public class B {
    public B(A a) {
    }
}

Caused by: org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.beforeSingletonCreation(DefaultSingletonBeanRegistry.java:339)
	at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:215)
	at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:318)
	at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:199)

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

@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Service
public class A {
    @Autowired
    private B b;
}
@Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
@Service
public class B {
    @Autowired
    private A a;
}

// 在單例Bean內(nèi)注入
    @Autowired
    private A a;

org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'mytest.TestSpringBean': Unsatisfied dependency expressed through field 'a'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'a': Unsatisfied dependency expressed through field 'b'; nested exception is org.springframework.beans.factory.UnsatisfiedDependencyException: Error creating bean with name 'b': Unsatisfied dependency expressed through field 'a'; nested exception is org.springframework.beans.factory.BeanCurrentlyInCreationException: Error creating bean with name 'a': Requested bean is currently in creation: Is there an unresolvable circular reference?
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor$AutowiredFieldElement.inject(AutowiredAnnotationBeanPostProcessor.java:596)
	at org.springframework.beans.factory.annotation.InjectionMetadata.inject(InjectionMetadata.java:90)
	at org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor.postProcessProperties(AutowiredAnnotationBeanPostProcessor.java:374)

    @Lazy
    @Autowired
    private A a;

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	...
	// 從上至下 分表代表這“三級(jí)緩存”
	private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); //一級(jí)緩存
	private final Map<String, Object> earlySingletonObjects = new HashMap<>(16); // 二級(jí)緩存
	private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16); // 三級(jí)緩存
	...
	/** Names of beans that are currently in creation. */
	// 這個(gè)緩存也十分重要：它表示bean創(chuàng)建過程中都會(huì)在里面呆著~
	// 它在Bean開始創(chuàng)建時(shí)放值，創(chuàng)建完成時(shí)會(huì)將其移出~
	private final Set<String> singletonsCurrentlyInCreation = Collections.newSetFromMap(new ConcurrentHashMap<>(16));
	/** Names of beans that have already been created at least once. */
	// 當(dāng)這個(gè)Bean被創(chuàng)建完成后，會(huì)標(biāo)記為這個(gè) 注意：這里是set集合 不會(huì)重復(fù)
	// 至少被創(chuàng)建了一次的  都會(huì)放進(jìn)這里~~~~
	private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));
}

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
	...
	@Override
	@Nullable
	public Object getSingleton(String beanName) {
		return getSingleton(beanName, true);
	}
	@Nullable
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		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;
	}
	...
	public boolean isSingletonCurrentlyInCreation(String beanName) {
		return this.singletonsCurrentlyInCreation.contains(beanName);
	}
	protected boolean isActuallyInCreation(String beanName) {
		return isSingletonCurrentlyInCreation(beanName);
	}
	...
}

// 它可以將創(chuàng)建對(duì)象的步驟封裝到ObjectFactory中 交給自定義的Scope來選擇是否需要?jiǎng)?chuàng)建對(duì)象來靈活的實(shí)現(xiàn)scope。  具體參見Scope接口
@FunctionalInterface
public interface ObjectFactory<T> {
	T getObject() throws BeansException;
}

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 {
		...
		// Eagerly check singleton cache for manually registered singletons.
		// 先去獲取一次，如果不為null，此處就會(huì)走緩存了~~
		Object sharedInstance = getSingleton(beanName);
		...
		// 如果不是只檢查類型，那就標(biāo)記這個(gè)Bean被創(chuàng)建了~~添加到緩存里 也就是所謂的  當(dāng)前創(chuàng)建Bean池
		if (!typeCheckOnly) {
			markBeanAsCreated(beanName);
		}
		...
		// Create bean instance.
		if (mbd.isSingleton()) {
			// 這個(gè)getSingleton方法不是SingletonBeanRegistry的接口方法  屬于實(shí)現(xiàn)類DefaultSingletonBeanRegistry的一個(gè)public重載方法~~~
			// 它的特點(diǎn)是在執(zhí)行singletonFactory.getObject();前后會(huì)執(zhí)行beforeSingletonCreation(beanName);和afterSingletonCreation(beanName);  
			// 也就是保證這個(gè)Bean在創(chuàng)建過程中，放入正在創(chuàng)建的緩存池里  可以看到它實(shí)際創(chuàng)建bean調(diào)用的是我們的createBean方法~~~~
			sharedInstance = getSingleton(beanName, () -> {
				try {
					return createBean(beanName, mbd, args);
				} catch (BeansException ex) {
					destroySingleton(beanName);
					throw ex;
				}
			});
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
		}
	}
	...
}
// 抽象方法createBean所在地  這個(gè)接口方法是屬于抽象父類AbstractBeanFactory的   實(shí)現(xiàn)在這個(gè)抽象類里
public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory {
	...
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args) throws BeanCreationException {
		...
		// 創(chuàng)建Bean對(duì)象，并且將對(duì)象包裹在BeanWrapper 中
		instanceWrapper = createBeanInstance(beanName, mbd, args);
		// 再從Wrapper中把Bean原始對(duì)象（非代理~~~）  這個(gè)時(shí)候這個(gè)Bean就有地址值了，就能被引用了~~~
		// 注意：此處是原始對(duì)象，這點(diǎn)非常的重要
		final Object bean = instanceWrapper.getWrappedInstance();
		...
		// earlySingletonExposure 用于表示是否”提前暴露“原始對(duì)象的引用，用于解決循環(huán)依賴。
		// 對(duì)于單例Bean，該變量一般為 true   但你也可以通過屬性allowCircularReferences = false來關(guān)閉循環(huán)引用
		// isSingletonCurrentlyInCreation(beanName) 表示當(dāng)前bean必須在創(chuàng)建中才行
		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");
			}
			// 上面講過調(diào)用此方法放進(jìn)一個(gè)ObjectFactory，二級(jí)緩存會(huì)對(duì)應(yīng)刪除的
			// getEarlyBeanReference的作用：調(diào)用SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference()這個(gè)方法  否則啥都不做
			// 也就是給調(diào)用者個(gè)機(jī)會(huì)，自己去實(shí)現(xiàn)暴露這個(gè)bean的應(yīng)用的邏輯~~~
			// 比如在getEarlyBeanReference()里可以實(shí)現(xiàn)AOP的邏輯~~~  參考自動(dòng)代理創(chuàng)建器AbstractAutoProxyCreator  實(shí)現(xiàn)了這個(gè)方法來創(chuàng)建代理對(duì)象
			// 若不需要執(zhí)行AOP的邏輯，直接返回Bean
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}
		Object exposedObject = bean; //exposedObject 是最終返回的對(duì)象
		...
		// 填充屬于，解決@Autowired依賴~
		populateBean(beanName, mbd, instanceWrapper);
		// 執(zhí)行初始化回調(diào)方法們~~~
		exposedObject = initializeBean(beanName, exposedObject, mbd);
		// earlySingletonExposure：如果你的bean允許被早期暴露出去 也就是說可以被循環(huán)引用  那這里就會(huì)進(jìn)行檢查
		// 此段代碼非常重要~~~~~但大多數(shù)人都忽略了它
		if (earlySingletonExposure) {
			// 此時(shí)一級(jí)緩存肯定還沒數(shù)據(jù)，但是呢此時(shí)候二級(jí)緩存earlySingletonObjects也沒數(shù)據(jù)
			//注意，注意：第二參數(shù)為false  表示不會(huì)再去三級(jí)緩存里查了~~~
			// 此處非常巧妙的一點(diǎn)：：：因?yàn)樯厦娓魇礁鳂拥膶?shí)例化、初始化的后置處理器都執(zhí)行了，如果你在上面執(zhí)行了這一句
			//  ((ConfigurableListableBeanFactory)this.beanFactory).registerSingleton(beanName, bean);
			// 那么此處得到的earlySingletonReference 的引用最終會(huì)是你手動(dòng)放進(jìn)去的Bean最終返回，完美的實(shí)現(xiàn)了"偷天換日" 特別適合中間件的設(shè)計(jì)
			// 我們知道，執(zhí)行完此doCreateBean后執(zhí)行addSingleton()  其實(shí)就是把自己再添加一次  **再一次強(qiáng)調(diào)，完美實(shí)現(xiàn)偷天換日**
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
				// 這個(gè)意思是如果經(jīng)過了initializeBean()后，exposedObject還是木有變，那就可以大膽放心的返回了
				// initializeBean會(huì)調(diào)用后置處理器，這個(gè)時(shí)候可以生成一個(gè)代理對(duì)象，那這個(gè)時(shí)候它哥倆就不會(huì)相等了 走else去判斷吧
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				} 
				// allowRawInjectionDespiteWrapping這個(gè)值默認(rèn)是false
				// hasDependentBean：若它有依賴的bean 那就需要繼續(xù)校驗(yàn)了~~~(若沒有依賴的 就放過它~)
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					// 拿到它所依賴的Bean們~~~~ 下面會(huì)遍歷一個(gè)一個(gè)的去看~~
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
					// 一個(gè)個(gè)檢查它所以Bean
					// removeSingletonIfCreatedForTypeCheckOnly這個(gè)放見下面  在AbstractBeanFactory里面
					// 簡單的說，它如果判斷到該dependentBean并沒有在創(chuàng)建中的了的情況下,那就把它從所有緩存中移除~~~  并且返回true
					// 否則（比如確實(shí)在創(chuàng)建中） 那就返回false 進(jìn)入我們的if里面~  表示所謂的真正依賴
					//（解釋：就是真的需要依賴它先實(shí)例化，才能實(shí)例化自己的依賴）
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					// 若存在真正依賴，那就報(bào)錯(cuò)（不要等到內(nèi)存移除你才報(bào)錯(cuò)，那是非常不友好的） 
					// 這個(gè)異常是BeanCurrentlyInCreationException，報(bào)錯(cuò)日志也稍微留意一下，方便定位錯(cuò)誤~~~~
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}
		return exposedObject;
	}
	// 雖然是remove方法 但是它的返回值也非常重要
	// 該方法唯一調(diào)用的地方就是循環(huán)依賴的最后檢查處~~~~~
	protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName) {
		// 如果這個(gè)bean不在創(chuàng)建中  比如是ForTypeCheckOnly的  那就移除掉
		if (!this.alreadyCreated.contains(beanName)) {
			removeSingleton(beanName);
			return true;
		}
		else {
			return false;
		}
	}
}

if (exposedObject == bean) {
	exposedObject = earlySingletonReference;
}

protected <T> T doGetBean(...){
	... 
	// 標(biāo)記beanName a是已經(jīng)創(chuàng)建過至少一次的~~~ 它會(huì)一直存留在緩存里不會(huì)被移除（除非拋出了異常）
	// 參見緩存Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256))
	if (!typeCheckOnly) {
		markBeanAsCreated(beanName);
	}
	// 此時(shí)a不存在任何一級(jí)緩存中，且不是在創(chuàng)建中  所以此處返回null
	// 此處若不為null，然后從緩存里拿就可以了(主要處理FactoryBean和BeanFactory情況吧)
	Object beanInstance = getSingleton(beanName, false);
	...
	// 這個(gè)getSingleton方法非常關(guān)鍵。
	//1、標(biāo)注a正在創(chuàng)建中~
	//2、調(diào)用singletonObject = singletonFactory.getObject();（實(shí)際上調(diào)用的是createBean()方法）  因此這一步最為關(guān)鍵
	//3、此時(shí)實(shí)例已經(jīng)創(chuàng)建完成  會(huì)把a(bǔ)移除整整創(chuàng)建的緩存中
	//4、執(zhí)行addSingleton()添加進(jìn)去。（備注：注冊(cè)bean的接口方法為registerSingleton，它依賴于addSingleton方法）
	sharedInstance = getSingleton(beanName, () -> { ... return createBean(beanName, mbd, args); });
}protected <T> T doGetBean(...){
	... 
	// 標(biāo)記beanName a是已經(jīng)創(chuàng)建過至少一次的~~~ 它會(huì)一直存留在緩存里不會(huì)被移除（除非拋出了異常）
	// 參見緩存Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256))
	if (!typeCheckOnly) {
		markBeanAsCreated(beanName);
	}
	// 此時(shí)a不存在任何一級(jí)緩存中，且不是在創(chuàng)建中  所以此處返回null
	// 此處若不為null，然后從緩存里拿就可以了(主要處理FactoryBean和BeanFactory情況吧)
	Object beanInstance = getSingleton(beanName, false);
	...
	// 這個(gè)getSingleton方法非常關(guān)鍵。
	//1、標(biāo)注a正在創(chuàng)建中~
	//2、調(diào)用singletonObject = singletonFactory.getObject();（實(shí)際上調(diào)用的是createBean()方法）  因此這一步最為關(guān)鍵
	//3、此時(shí)實(shí)例已經(jīng)創(chuàng)建完成  會(huì)把a(bǔ)移除整整創(chuàng)建的緩存中
	//4、執(zhí)行addSingleton()添加進(jìn)去。（備注：注冊(cè)bean的接口方法為registerSingleton，它依賴于addSingleton方法）
	sharedInstance = getSingleton(beanName, () -> { ... return createBean(beanName, mbd, args); });
}

protected Object doCreateBean(){
	...
	// 使用構(gòu)造器/工廠方法   instanceWrapper是一個(gè)BeanWrapper
	instanceWrapper = createBeanInstance(beanName, mbd, args);
	// 此處bean為"原始Bean"   也就是這里的A實(shí)例對(duì)象：A@1234
	final Object bean = instanceWrapper.getWrappedInstance();
	...
	// 是否要提前暴露（允許循環(huán)依賴）  現(xiàn)在此處A是被允許的
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
	// 允許暴露，就把A綁定在ObjectFactory上，注冊(cè)到三級(jí)緩存`singletonFactories`里面去保存著
	// Tips:這里后置處理器的getEarlyBeanReference方法會(huì)被促發(fā)，自動(dòng)代理創(chuàng)建器在此處創(chuàng)建代理對(duì)象（注意執(zhí)行時(shí)機(jī) 為執(zhí)行三級(jí)緩存的時(shí)候）
	if (earlySingletonExposure) {
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}
	...
	// exposedObject 為最終返回的對(duì)象，此處為原始對(duì)象bean也就是A@1234,下面會(huì)有用處
	Object exposedObject = bean; 
	// 給A@1234屬性完成賦值，@Autowired在此處起作用~
	// 因此此處會(huì)調(diào)用getBean("b")，so 會(huì)重復(fù)上面步驟創(chuàng)建B類的實(shí)例
	// 此處我們假設(shè)B已經(jīng)創(chuàng)建好了 為B@5678
	// 需要注意的是在populateBean("b")的時(shí)候依賴有beanA，所以此時(shí)候調(diào)用getBean("a")最終會(huì)調(diào)用getSingleton("a")，
	//此時(shí)候上面說到的getEarlyBeanReference方法就會(huì)被執(zhí)行。這也解釋為何我們@Autowired是個(gè)代理對(duì)象，而不是普通對(duì)象的根本原因
	populateBean(beanName, mbd, instanceWrapper);
	// 實(shí)例化。這里會(huì)執(zhí)行后置處理器BeanPostProcessor的兩個(gè)方法
	// 此處注意：postProcessAfterInitialization()是有可能返回一個(gè)代理對(duì)象的，這樣exposedObject 就不再是原始對(duì)象了  特備注意哦~~~
	// 比如處理@Aysnc的AsyncAnnotationBeanPostProcessor它就是在這個(gè)時(shí)間里生成代理對(duì)象的（有坑，請(qǐng)小心使用@Aysnc）
	exposedObject = initializeBean(beanName, exposedObject, mbd);
	... // 至此，相當(dāng)于A@1234已經(jīng)實(shí)例化完成、初始化完成（屬性也全部賦值了~）
	// 這一步我把它理解為校驗(yàn)：校驗(yàn)：校驗(yàn)是否有循環(huán)引用問題~~~~~
	if (earlySingletonExposure) {
		// 注意此處第二個(gè)參數(shù)傳的false，表示不去三級(jí)緩存里singletonFactories再去調(diào)用一次getObject()方法了~~~
		// 上面建講到了由于B在初始化的時(shí)候，會(huì)觸發(fā)A的ObjectFactory.getObject()  所以a此處已經(jīng)在二級(jí)緩存earlySingletonObjects里了
		// 因此此處返回A的實(shí)例：A@1234
		Object earlySingletonReference = getSingleton(beanName, false);
		if (earlySingletonReference != null) {
			// 這個(gè)等式表示，exposedObject若沒有再被代理過，這里就是相等的
			// 顯然此處我們的a對(duì)象的exposedObject它是沒有被代理過的  所以if會(huì)進(jìn)去~
			// 這種情況至此，就全部結(jié)束了~~~
			if (exposedObject == bean) {
				exposedObject = earlySingletonReference;
			}
			// 繼續(xù)以A為例，比如方法標(biāo)注了@Aysnc注解，exposedObject此時(shí)候就是一個(gè)代理對(duì)象，因此就會(huì)進(jìn)到這里來
			//hasDependentBean(beanName)是肯定為true，因?yàn)間etDependentBeans(beanName)得到的是["b"]這個(gè)依賴
			else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
				String[] dependentBeans = getDependentBeans(beanName);
				Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
				// A@1234依賴的是["b"]，所以此處去檢查b
				// 如果最終存在實(shí)際依賴的bean：actualDependentBeans不為空 那就拋出異常  證明循環(huán)引用了~
				for (String dependentBean : dependentBeans) {
					// 這個(gè)判斷原則是：如果此時(shí)候b并還沒有創(chuàng)建好，this.alreadyCreated.contains(beanName)=true表示此bean已經(jīng)被創(chuàng)建過，就返回false
					// 若該bean沒有在alreadyCreated緩存里，就是說沒被創(chuàng)建過(其實(shí)只有CreatedForTypeCheckOnly才會(huì)是此倉庫)
					if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
						actualDependentBeans.add(dependentBean);
					}
				}
				if (!actualDependentBeans.isEmpty()) {
					throw new BeanCurrentlyInCreationException(beanName,
							"Bean with name '" + beanName + "' has been injected into other beans [" +
							StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
							"] in its raw version as part of a circular reference, but has eventually been " +
							"wrapped. This means that said other beans do not use the final version of the " +
							"bean. This is often the result of over-eager type matching - consider using " +
							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}
}