if (isPrototypeCurrentlyInCreation(beanName))?
{ ?throw new BeanCurrentlyInCreationException(beanName);}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    BeanWrapper instanceWrapper = null;
	
    if (instanceWrapper == null) {
        // ① 實例化對象
        instanceWrapper = this.createBeanInstance(beanName, mbd, args);
    }
    final Object bean = instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null;
    Class<?> beanType = instanceWrapper != null ? instanceWrapper.getWrappedClass() : null;
   
    // ② 判斷是否允許提前暴露對象，如果允許，則直接添加一個 ObjectFactory 到三級緩存
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        // 添加三級緩存的方法詳情在下方
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    // ③ 填充屬性
    this.populateBean(beanName, mbd, instanceWrapper);
    // ④ 執(zhí)行初始化方法，并創(chuàng)建代理
    exposedObject = initializeBean(beanName, exposedObject, mbd);
   
    return exposedObject;
}

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); // 添加至三級緩存
            this.earlySingletonObjects.remove(beanName); // 確保二級緩存沒有此對象
            this.registeredSingletons.add(beanName);
        }
    }
}
@FunctionalInterface
public interface ObjectFactory<T> {
	T getObject() throws BeansException;
}

protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
    Object exposedObject = bean;
    if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                // 如果需要代理，這里會返回代理對象；否則返回原始對象
                exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            }
        }
    }
    return exposedObject;
}

public abstract class AbstractAutoProxyCreator extends ProxyProcessorSupport
		implements SmartInstantiationAwareBeanPostProcessor, BeanFactoryAware {
    @Override
    public Object getEarlyBeanReference(Object bean, String beanName) {
        Object cacheKey = getCacheKey(bean.getClass(), beanName);
        // 記錄已被代理的對象
        this.earlyProxyReferences.put(cacheKey, bean);
        return wrapIfNecessary(bean, beanName, cacheKey);
    }
}

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) {
                    // Bean 工廠中獲取 Bean
                    singletonObject = singletonFactory.getObject();
                    // 放入到二級緩存中
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return singletonObject;
}

protected void addSingletonFactory(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(singletonFactory, "Singleton factory must not be null");
    synchronized (this.singletonObjects) {
        if (!this.singletonObjects.containsKey(beanName)) { // 判斷一級緩存中不存在此對象
            object o = singletonFactory.getObject(); // 直接從工廠中獲取 Bean
            this.earlySingletonObjects.put(beanName, o); // 添加至二級緩存中
            this.registeredSingletons.add(beanName);
        }
    }
}

@RestController
public class AccountController {
    private static final Logger LOG = LoggerFactory.getLogger(AccountController.class);
    private AccountService accountService;
    // 構(gòu)造函數(shù)依賴注入
    // 不管是否設(shè)置為required為true，都會出現(xiàn)循環(huán)依賴問題
    @Autowire
    // @Autowired(required = false)
    public AccountController(AccountService accountService) {
        this.accountService = accountService;
    }
    
}
@Service
public class AccountService {
    private static final Logger LOG = LoggerFactory.getLogger(AccountService.class);
    
    // 屬性值依賴注入
    @Autowired
    private AccountController accountController;
   } 

@RestController
public class AccountController {
    private static final Logger LOG = LoggerFactory.getLogger(AccountController.class);
    // 屬性值注入
    @Autowired
    private AccountService accountService;
    
}
@Service
public class AccountService {
    private AccountController accountController;
    // 構(gòu)造函數(shù)注入
    @Autowired
    public AccountService(AccountController accountController) {
        this.accountController = accountController;
    }
    
}

    // bean對象實例創(chuàng)建的核心實現(xiàn)方法
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    		throws BeanCreationException {
    		// 省略其他代碼
    		// 1. 調(diào)用構(gòu)造函數(shù)創(chuàng)建該bean對象，若不存在構(gòu)造函數(shù)注入，順利通過
    		instanceWrapper = createBeanInstance(beanName, mbd, args);
    		// 2. 在singletonFactories緩存中，放入該bean對象，以便解決循環(huán)依賴問題
    		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    		// 3. populateBean方法：bean對象的屬性賦值
    		populateBean(beanName, mbd, instanceWrapper); 		
    		// 省略其他代碼
    	return exposedObject;
    }