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

protected boolean isPrototypeCurrentlyInCreation(String beanName) {
	Object curVal = this.prototypesCurrentlyInCreation.get();
	return (curVal != null &&
	　　(curVal.equals(beanName) || (curVal instanceof Set && ((Set<?>) curVal).contains(beanName))));
}

try {
        //创建原型bean之前添加标记
	beforePrototypeCreation(beanName);
        //创建原型bean
	prototypeInstance = createBean(beanName, mbd, args);
}
finally {
        //创建原型bean之后删除标记
	afterPrototypeCreation(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");
	    }
//将初始化后的对象提前已ObjectFactory对象注入到容器中
   addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}

Object sharedInstance = getSingleton(beanName);
                 //已经存在则返回
		if (sharedInstance != null && args == null) {
			if (logger.isTraceEnabled()) {
				if (isSingletonCurrentlyInCreation(beanName)) {
					logger.trace("Returning eagerly cached instance of singleton bean ‘" + beanName +
							"‘ that is not fully initialized yet - a consequence of a circular reference");
				}
				else {
					logger.trace("Returning cached instance of singleton bean ‘" + beanName + "‘");
				}
			}
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

@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);
					his.singletonFactories.remove(beanName);
				}
			 }
		      }
	         }
	    }
	}
	return singletonObject;
}

//创建单例bean
if (mbd.isSingleton()) {
	sharedInstance = getSingleton(beanName, () -> {
	try {
		return createBean(beanName, mbd, args);
	}
	catch (BeansException ex) {
	// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
	destroySingleton(beanName);
	throw ex;
	}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
                        //创建bean实例，仅仅调用构造方法，但是尚未设置属性
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
...

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");
			}
                         //加入三级缓存
			addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
		}

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

Object exposedObject = bean;
try {
       //属性填充
	populateBean(beanName, mbd, instanceWrapper);
	exposedObject = initializeBean(beanName, exposedObject, mbd);
}

//属性填充

applyPropertyValues(beanName, mbd, bw, pvs);

//得到需要注入的名字
String propertyName = pv.getName();
Object originalValue = pv.getValue();
//查找bean
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);

//进入解决引用方法
public Object resolveValueIfNecessary(Object argName, @Nullable Object value) {
	// We must check each value to see whether it requires a runtime reference
	// to another bean to be resolved.
	if (value instanceof RuntimeBeanReference) {
		RuntimeBeanReference ref = (RuntimeBeanReference) value;
                //解决引用
		return resolveReference(argName, ref);
	}

else {
        //从bean工厂获取引用bean
	bean = this.beanFactory.getBean(refName);
	this.beanFactory.registerDependentBean(refName, this.beanName);
}

if (newSingleton) {
        //添加一级缓存  从三级缓存和二级缓存中移除
	addSingleton(beanName, singletonObject);
}

if (earlySingletonExposure) {
	Object earlySingletonReference = getSingleton(beanName, false);
	if (earlySingletonReference != null) {
		if (exposedObject == bean) {
			exposedObject = earlySingletonReference;
		}
		else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
			String[] dependentBeans = getDependentBeans(beanName);
			Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
			for (String dependentBean : dependentBeans) {
			    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 " +
					"‘getBeanNamesForType‘ with the ‘allowEagerInit‘ flag turned off, for example.");
					}
				}
			}
		}