Spring IOC源码分析（二）

时间 2020-06-15

标签 spring ioc 源码分析栏目 Spring 繁體版

原文原文链接

Spring IOC源码分析（二）

在Spring完成将BeanDefinition注入IOC容器的任务以后，最主要的一步就是完成对ApplicationContext中的剩下的全部单例非懒加载Bean完成预实例化。对于原型Bean只有使用的时候才会被建立。java

org.springframework.context.support.AbstractApplicationContext#finishBeanFactoryInitialization：web

// Instantiate all remaining (non-lazy-init) singletons.
//4.预实例化全部非懒加载的单例Bean
beanFactory.preInstantiateSingletons();
复制代码

org.springframework.beans.factory.support.DefaultListableBeanFactory#preInstantiateSingletons：spring

/** * 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实例。bootstrap

1.singleton

对于singleton bean，多是FactoryBean，也多是普通的Bean，可是从上述的入口能够看出来，最终都是调用org.springframework.beans.factory.support.AbstractBeanFactory#getBean来获取对应bean实例的，因此主要看该方法。缓存

org.springframework.beans.factory.support.AbstractBeanFactory#getBean：websocket

/** * 根据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格式的方法都是真正的作事的方法。session

org.springframework.beans.factory.support.AbstractBeanFactory#doGetBean：app

/** * 返回一个实例，能够是指定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的做用域，根据做用域走不一样的解决方案，这里主要看单例。socket

org.springframework.beans.factory.support.DefaultSingletonBeanRegistry#getSingleton：ide

/** * 若是给定的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的建立过程也就完成了。