Spring IOC源码分析（二）
在Spring完成将BeanDefinition注入IOC容器的任务之后，最主要的一步就是完成对ApplicationContext中的剩下的所有单例非懒加载Bean完成预实例化。对于原型Bean只有使用的时候才会被创建。
org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization：
// Instantiate all remaining (non-lazy-init) singletons.
//4.预实例化所有非懒加载的单例Bean
beanFactory.preInstantiateSingletons();
org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons：
/**
* ApplicationContext支持的预实例化
*/
@Override
public void preInstantiateSingletons() throws BeansException {
// Iterate over a copy to allow for init methods which in turn register new bean definitions.
// While this may not be part of the regular factory bootstrap, it does otherwise work fine.
List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
// Trigger initialization of all non-lazy singleton beans...
//1.触发所有非懒加载的单例Bean的初始化
for (String beanName : beanNames) {
//2.合并的BeanDefinition
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//3.判断是不是FactoryBean
if (isFactoryBean(beanName)) {
final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
@Override
public Boolean run() {
return ((SmartFactoryBean<?>) factory).isEagerInit();
}
}, getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
else {
//4.主要走这里
getBean(beanName);
}
}
}
}
上述源码展示ApplicationContext预实例化（单例非懒加载）的入口，通过遍历BeanDefinition的名称来获取Bean实例。
1.singleton
对于singleton bean，可能是FactoryBean，也可能是普通的Bean，但是从上述的入口可以看出来，最终都是调用org.springframework.beans.factory.support.AbstractBeanFactory#getBean来获取对应bean实例的，所以主要看该方法。
org.springframework.beans.factory.support.AbstractBeanFactory#getBean：
/**
* 根据beanName获取bean
*/
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
@Override
public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
return doGetBean(name, requiredType, null, false);
}
@Override
public Object getBean(String name, Object... args) throws BeansException {
return doGetBean(name, null, args, false);
}
public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
return doGetBean(name, requiredType, args, false);
}
getBean方法提供了几个重载的方法， 但它本身比较简单，就是调用了doGetBean，在Spring中一般doXXX格式的方法都是真正的做事的方法。
org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean：
/**
* 返回一个实例，可以是指定Bean的共享实例或独立实例
*/
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//转换beanName，为了解决FactoryBean的&符号
final String beanName = transformedBeanName(name);
Object bean;
// Eagerly check singleton cache for manually registered singletons.
//1.检查单例缓存中是否已经存在手动注册的Bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
}
}
//如果是普通的bean则直接返回，如果是FactoryBean，则返回FactoryBean所产生的对象
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// Create bean instance.
//7.单例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
try {
//匿名内部类，真实的创建singleton object
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);
}
//8.原型
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//9.其他的，如：request、session、global session、application、websocket
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope '" + scopeName + "' is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
return (T) bean;
}
这部分源码只贴了核心的部分，可以看到，首先会解析beanName，因为这里涉及到普通的Bean和FactoryBean，为了解析FactoryBean的转义符&；然后会从IOC的缓存中获取当前beanName的实例是否存在，如果存在，则直接返回实例，然后调用getObjectForBeanInstance方法，如果是Bean，则直接返回bean，如果是FactoryBean，则返回其getObject返回的对象，这里也是解决循环引用很重要的一个地方；最后判断bean的作用域，根据作用域走不同的解决方案，这里主要看单例。
org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton：
/**
* 如果给定的beanName，尚未注册，则创建注册
*/
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
Assert.notNull(beanName, "'beanName' must not be null");
synchronized (this.singletonObjects) {
//检查是否已经有了
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName,
"Singleton bean creation not allowed while singletons of this factory are in destruction " +
"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
//1.添加到正在创建的集合中
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
//2.回调匿名内部类的方法，获取单例对象
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
catch (IllegalStateException ex) {
// Has the singleton object implicitly appeared in the meantime ->
// if yes, proceed with it since the exception indicates that state.
singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
throw ex;
}
}
catch (BeanCreationException ex) {
if (recordSuppressedExceptions) {
for (Exception suppressedException : this.suppressedExceptions) {
ex.addRelatedCause(suppressedException);
}
}
throw ex;
}
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
//3.从正在创建的集合中移除
afterSingletonCreation(beanName);
}
//4.如果是新单例对象
if (newSingleton) {
//5.添加到单例工厂中进行缓存
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
从这个方法中，可以看到，首先会从一级缓存中获取实例，如果不存在，则添加到一个正在创建的集合中，这个也是解决循环引用的一部分；然后调用刚刚传入的匿名内部类的getObject方法，创建我们的实例；最后从正在创建的集合中移除，将新创建的实例放到一级缓存中（singletonObjects）。
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBean：
/**
* 这个类的核心方法：实现了AbstractBeanFactory的方法
* 负责创建Bean
*/
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
//1.解析BeanDefinition
//确保此时确实解析了bean类，如果动态解析的类无法存储在共享的合并bean定义中，则复制bean定义。
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// Prepare method overrides.
//2.准备方法覆盖，比如<lookup-method/>
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
//3.通过BeanPostProcessor返回代理Bean，这个BeanPostProcessor必须是非用户自定义的
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
//4.常规创建bean
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
这个方法用来创建实例，首先会解析BeanDefinition，设置BeanDefinition的一些相关属性；然后是通过BeanPostProcessor来返回一个代理Bean，实现短路操作；最后是真正的去创建Bean。
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#doCreateBean：
/**
* 真实的创建Bean，并执行回调
*/
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
//1.获取Java对象，包括工厂方法（实例工厂、静态工厂）、有参构造、默认构造
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//2.获取bean
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
// Allow post-processors to modify the merged bean definition.
// 3.执行后置处理器修改MergeBeanDefinition
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//4.是否需要提前曝光，用来解决循环依赖时使用
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//解决循环依赖，匿名内部类用于回调
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
//5.填充Bean，如属性等
//如果依赖其他的bean，则会初始化被依赖的bean
//循环依赖也是在这里处理的
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//6.执行回调方法，如Aware、init-method等
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);
}
}
if (earlySingletonExposure) {
//在检查到循环依赖的情况下，不为NULL
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<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
//说明被依赖的bean没有完全创建，也就是说循环依赖没有解决
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.");
}
}
}
}
// Register bean as disposable.
try {
//注册销毁方法，如DisposableBean、destroy-method等
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
这个方法用于真正的创建Bean实例，首先调用createBeanInstance方法通过反射创建Java对象；然后调用addSingletonFactory方法放入三级缓存（singletonFactories），用于解决循环引用的问题；然后调用populateBean方法进行依赖注入以及调用initializeBean方法进行初始化方法回调和BeanPostProcessor回调；最后调用registryDisposableBeanIfNecessary方法注册销毁回调方法。
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#createBeanInstance：
/**
* 根据指定的bean创建bean instance
* 实例化策略：factory method、constructor autowiring、simple instantiation
*/
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
//1.工厂方法
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Candidate constructors for autowiring?
//2.有参构造，按类型匹配
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// No special handling: simply use no-arg constructor.
//3.默认构造方法
return instantiateBean(beanName, mbd);
}
实例Bean主要有三种方式：工厂方法（静态工厂、工厂方法）、有参构造、无参构造。
org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#instantiateBean：
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
return getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
}, getAccessControlContext());
}
else {
//1.实例化
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
//2.封装
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
}
}
该方法将创建的Bean实例封装为BeanWrapper并返回。
org.springframework.beans.factory.support.SimpleInstantiationStrategy#instantiate：
@Override
public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
// Don't override the class with CGLIB if no overrides.
//1.如果没有方法覆盖（如<lookup-method/>或@Lookup），不需要使用CGLIB生成代理类
if (bd.getMethodOverrides().isEmpty()) {
return BeanUtils.instantiateClass(constructorToUse);
}
else {
// Must generate CGLIB subclass.
//2.使用CGLIB生成代理类
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
判断该BeanDefinition是否有方法覆盖，如果存在，则使用CGLIB动态代理生成代理对象，否则，直接创建当前实例。
org.springframework.beans.BeanUtils#instantiateClass：
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
ReflectionUtils.makeAccessible(ctor);
return ctor.newInstance(args);
}
通过反射创建Java对象并返回。至此，Spring实例化Bean的过程也就完成了，后续就调用上述的依赖注入、初始化回调、BeanPostPorcessor、销毁回调等方法，最后放入到一级缓存中。
总结一下：
1.在
BeanDefinition准备好之后，需要调用finishBeanFactoryInitialization方法对beanDefinitionNames进行遍历，单例的非懒加载的Bean进行预实例化。2.对
beanDefinitionName进行转换，为了解决FactoryBean的转义符&，然后从IOC的三个缓存（singletonObjects、earlySingletonObjects、singletonFactories）中判断要预实例化的bean是否已经存在，如果存在，则直接返回（然后调用getObjectForBeanInstance方法，判断如果是bean，直接返回，如果是FactoryBean，则返回FactoryBean#getObject产生的对象），如果不存在，则判断beanDefinition的作用域，根据作用域走不同的路径。3.对于
Singleton作用域的beanDefinition，通过调用DefaultSingletonBeanRegistry#getSingleton方法获取实例，在这个方法中首先会把这个bean加入到正在创建的集合中， 然后调用匿名内部类的ObjectFactory#createBean方法创建实例，之后把该bean从创建的集合中移除，并加入IOC的一级缓存（singletonObjects）中，那也就完成了预实例化。4.匿名内部类
ObjectFactory其中一个重要的实现类AbstractAutowireCapableBeanFactory，该类是实例化bean的核心类，在createBean方法中是为了后面的doCreateBean做准备，比如方法覆盖、短路返回代理bean等；doCreateBean方法调用createBeanInstance方法通过反射进行了实例化，createBeanInstance方法包含了工厂方法（实例工厂、静态工厂）、有参构造、无参构造三种实例化方式；拿到实例化对象之后，为了解决循环依赖，需要把ObjectFactory放到三级缓存中（singletonFactories），ObjectFactory包括了当前创建的beanName、BeanDefinition、bean；调用populateBean方法进行依赖注入（深拷贝），依赖注入的时候会解决循环依赖，会把循环依赖的实例放入二级缓存（earlySingletonObjects）；调用initalizeBean回调BeanPostProcessor的方法以及一些初始化回调方法、Aware方法等；后续注入销毁方法。最后调用getObjectForBeanInstance方法，判断如果是bean，直接返回，如果是FactoryBean，则返回FactoryBean#getObject产生的对象。5.至此，预实例化也就完成了，当
getBean的时候就会调用DefaultSingletonBeanRegistry#getSingleton从一级缓存（singletonObjects）中获取（之后调用getObjectForBeanInstance方法，判断如果是bean，直接返回，如果是FactoryBean，则返回FactoryBean#getObject产生的对象）。
2.prototype
在了解完singleton之后，对于prototye就相对简单的多了，prototype是只有当我们调用的时候才会创建，并且不会被缓存。
test：
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
TestB testB = applicationContext.getBean(TestB.class);
applicationContext.xml：
<bean id="testB" class="com.ly.entity.cycle.TestB" scope="prototype">
<property name="name" value="5555"/>
</bean>
上述代码申明了一个prototype的bean，那么它只有当我们使用到这个bean的时候才会被调用，所以getBean就是该bean实例化的入口。
org.springframework.context.support.AbstractApplicationContext#getBean：
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
//1.断言
assertBeanFactoryActive();
//2.实例化BeanDefinition的时候创建的BeanFactory，一般是DefaultListableBeanFactory
return getBeanFactory().getBean(requiredType);
}
org.springframework.beans.factory.support.DefaultListableBeanFactory#getBean：
@Override
public <T> T getBean(Class<T> requiredType) throws BeansException {
return getBean(requiredType, (Object[]) null);
}
@Override
public <T> T getBean(Class<T> requiredType, Object... args) throws BeansException {
//1.这是对bean和beanName的封装
NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args);
if (namedBean != null) {
return namedBean.getBeanInstance();
}
//2.当前容器没找到这个bean，则从父容器中获取
BeanFactory parent = getParentBeanFactory();
if (parent != null) {
return parent.getBean(requiredType, args);
}
//3.都没有，则抛出异常
throw new NoSuchBeanDefinitionException(requiredType);
}
org.springframework.beans.factory.support.DefaultListableBeanFactory#resolveNamedBean：
private <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType, Object... args) throws BeansException {
Assert.notNull(requiredType, "Required type must not be null");
//1.beanNames
String[] candidateNames = getBeanNamesForType(requiredType);
//2.只有一个名称
if (candidateNames.length == 1) {
String beanName = candidateNames[0];
return new NamedBeanHolder<T>(beanName, getBean(beanName, requiredType, args));
}
return null;
}
这部分源码省略了多个名称的情况，对于只有单个名称的bean，通过NamedBeanHolder封装了beanName和getBean获取的bean。这里的getBean还是回到了和singleton一样的方法中。
org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean：
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//转换beanName，为了解决FactoryBean的&符号
final String beanName = transformedBeanName(name);
Object bean;
//2.如果这个bean是原型bean，并且已经在创建中了，则抛出异常，循环引用问题
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
//8.原型
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
return (T) bean;
}
这部分源码省略了很多关于singleton的，只需要关注这里即可。首先将要创建的这个bean放入一个ThreadLocal中，如果循环引用的时候，会判断bean已经在创建中了，会抛出异常，这也是prototype不支持循环引用的原因；然后调用createBean方法创建bean，这和singleton是一模一样的；最后从ThreadLocal中移除，然后根据getObjectForBeanInstance方法判断这个bean是普通的bean还是FactoryBean，如果是普通bean，则直接返回，如果是FactoryBean，则返回FactoryBean#getObejct方法产生的对象。
至此，prototype的bean的创建过程也就完成了。
