前面的文章中主要分析Spring是如何加载配置文件以及将其转化成BeanDefinition的，从本文开始，我们继续研究Spring是如何创建bean的。bean加载的功能实现远比bean的解析要复杂得多，会占用多篇文章的篇幅来进行分析，按照流程大致可以分为获取缓存bean、准备创建bean、创建bean这几个部分，本文会在浏览整个bean获取过程的基础上分析一下获取缓存单例的逻辑，更复杂的bean创建的逻辑留待后面文章分析。 

1. bean获取过程概览

　　对于加载bean的功能，在Spring中的调用方式为：

TestBean myTestBean = (TestBean) xmlBeanFactory.getBean("testBean");

　　这句代码背后是怎样实现的呢？我们可以先快速体验一下Spring中代码是如何实现的，这部分的代码是实现在AbstractBeanFactory中：

  1 public Object getBean(String name) throws BeansException {
  2     return doGetBean(name, null, null, false);
  3 }
  4 
  5 protected <T> T doGetBean(
  6             final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
  7             throws BeansException {
  8     // 获取对应的beanName
  9     final String beanName = transformedBeanName(name);
 10     Object bean;
 11     /* 检查缓存中或者实例工厂中是否有对应的实例
 12      * 为什么首先会使用这段代码呢，
 13      * 因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，
 14      * Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFact提早曝光
 15      * 也就是将objectFactory加入到缓存中，
 16      * 一旦下个bean创建时候需要依赖上个bean则直接使用objectFactory
 17      **/
 18     // Eagerly check singleton cache for manually registered singletons.
 19     // 直接尝试从缓存获取或者singletonFactories中的ObjectFactory中获取
 20     Object sharedInstance = getSingleton(beanName);
 21     if (sharedInstance != null && args == null) {
 22         if (logger.isDebugEnabled()) {
 23             if (isSingletonCurrentlyInCreation(beanName)) {
 24                 logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
 25                         "' that is not fully initialized yet - a consequence of a circular reference");
 26             }
 27             else {
 28                 logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
 29             }
 30         }
 31         // 返回对应的实例，有时候存在诸如BeanFactory的情况并不是直接返回实例本身，而是返回指定方法返回的实例
 32         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 33     }
 34 
 35     else {
 36         // 只有在单例情况才会尝试解决循环依赖，原型模式情况下，如果存在
 37         // A中有B的属性，B中有A的属性，那么当依赖注入的时候，就会产生当A还未创建完的时候由于
 38         // 对于B的创建而再次返回创建A，造循环依赖，也就是下面的情况
 39         // Fail if we're already creating this bean instance:
 40         // We're assumably within a circular reference.
 41         if (isPrototypeCurrentlyInCreation(beanName)) {
 42             throw new BeanCurrentlyInCreationException(beanName);
 43         }
 44 
 45         // Check if bean definition exists in this factory.
 46         BeanFactory parentBeanFactory = getParentBeanFactory();
 47         // 如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName则尝试从parentBeanFactory中检测
 48         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
 49             // Not found -> check parent.
 50             String nameToLookup = originalBeanName(name);
 51             // 递归到BeanFactory中寻找
 52             if (args != null) {
 53                 // Delegation to parent with explicit args.
 54                 return (T) parentBeanFactory.getBean(nameToLookup, args);
 55             }
 56             else {
 57                 // No args -> delegate to standard getBean method.
 58                 return parentBeanFactory.getBean(nameToLookup, requiredType);
 59             }
 60         }
 61         // 如果不是仅仅做类型检查则是创建bean，这里要进行记录
 62         if (!typeCheckOnly) {
 63             markBeanAsCreated(beanName);
 64         }
 65 
 66         try {
 67             // 将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition，如果指定BeanName是子Bean的话同时会合并父类的相关属性
 68             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 69             checkMergedBeanDefinition(mbd, beanName, args);
 70 
 71             // Guarantee initialization of beans that the current bean depends on.
 72             // 确保当前bean依赖的bean已经实例化了，通过递归来实现
 73             String[] dependsOn = mbd.getDependsOn();
 74             if (dependsOn != null) {
 75                 for (String dependsOnBean : dependsOn) {
 76                     getBean(dependsOnBean);
 77                     // 缓存依赖调用
 78                     registerDependentBean(dependsOnBean, beanName);
 79                 }
 80             }
 81             // 实例化依赖的bean后便可以实例化mbd本身了
 82             // singleton模式的创建
 83             // Create bean instance.
 84             if (mbd.isSingleton()) {
 85                 sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
 86                     public Object getObject() throws BeansException {
 87                         try {
 88                             return createBean(beanName, mbd, args);
 89                         }
 90                         catch (BeansException ex) {
 91                             // Explicitly remove instance from singleton cache: It might have been put there
 92                             // eagerly by the creation process, to allow for circular reference resolution.
 93                             // Also remove any beans that received a temporary reference to the bean.
 94                             destroySingleton(beanName);
 95                             throw ex;
 96                         }
 97                     }
 98                 });
 99                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
100             }
101             else if (mbd.isPrototype()) {
102                 // It's a prototype -> create a new instance.
103                 Object prototypeInstance = null;
104                 try {
105                     beforePrototypeCreation(beanName);
106                     prototypeInstance = createBean(beanName, mbd, args);
107                 }
108                 finally {
109                     afterPrototypeCreation(beanName);
110                 }
111                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
112             }
113 
114             else {
115                 String scopeName = mbd.getScope();
116                 final Scope scope = this.scopes.get(scopeName);
117                 if (scope == null) {
118                     throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
119                 }
120                 try {
121                     Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
122                         public Object getObject() throws BeansException {
123                             beforePrototypeCreation(beanName);
124                             try {
125                                 return createBean(beanName, mbd, args);
126                             }
127                             finally {
128                                 afterPrototypeCreation(beanName);
129                             }
130                         }
131                     });
132                     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
133                 }
134                 catch (IllegalStateException ex) {
135                     throw new BeanCreationException(beanName,
136                             "Scope '" + scopeName + "' is not active for the current thread; " +
137                             "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
138                             ex);
139                 }
140             }
141         }
142         catch (BeansException ex) {
143             cleanupAfterBeanCreationFailure(beanName);
144             throw ex;
145         }
146     }
147 
148     // Check if required type matches the type of the actual bean instance.
149     if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
150         try {
151             return getTypeConverter().convertIfNecessary(bean, requiredType);
152         }
153         catch (TypeMismatchException ex) {
154             if (logger.isDebugEnabled()) {
155                 logger.debug("Failed to convert bean '" + name + "' to required type [" +
156                         ClassUtils.getQualifiedName(requiredType) + "]", ex);
157             }
158             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
159         }
160     }
161     return (T) bean;
162 }

　　其实我想说我第一次看到这里，内心是崩溃的，这个方法的代码量。。。bean的加载经历了一个相当复杂的过程，其中涉及到各种各样的考虑，我也只是初略地了解一下Spring加载bean的过程，这里先总结一下所涉及的步骤吧：

转换对应beanName。

  这部分对应上面第9行，这里为什么要先转换呢？因为这里传入的参数可能是别名，也可能是FactoryBean(关于这个后面会专门总结)，所以需要进行专门的解析，解析操作如下：

去除FactoryBean的修饰符，也就是如果name=”&aa”，那么会首先去除&而使name=”aa”；
取指定alias所表示的最终beanName，例如别名A指向名称为B的beanvxxx则返回B；若别名A指向别名B，别名B又指向名称为C的bean则返回C；

尝试从缓存中加载单例。

　　这部分对应上面第20行代码。我们知道，Spring对bean创建定义了多种作用域：

singleton，单例模式；
prototype，多例模式；
request，表示针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效；
session，表示针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效；

  其中单例在一个Spring容器内只会被创建一次，后续再获取bean，就直接从单例缓存中获取了。这里也只是尝试加载，首先尝试从缓存中加载，如果加载不成功则再次尝试从singletonFactories中加载。因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖的时候为了避免循环依赖，在Spring中创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时候需要依赖上一个bean则直接使用ObjectFactory(后面会对循环依赖进行重点分析)。

bean的实例化。

  这部分对应上面第32行代码。如果从缓存中得到了bean的原始状态，则需要对bean进行实例化。为什么缓存中记录的只是最原始的bean状态，而并不一定是我们最终想要的bean呢？这是因为如果我们需要对工厂bean进行处理，那么这里得到的其实是工厂bean的初始状态，但是我们真正需要的是工厂bean中定义的factory-method方法中返回的bean，而getObjectForBeanInstance()方法就是完成这个工作的，这个后续也会详细讲解的，这里不清楚的可以先跳过去。

原型模式(即prototype)的依赖检查。

  这部分对应上面第41行代码。理解这一步的关键在于只有在单例情况下才会尝试解决循环依赖，如果存在A中有B的属性，B中有A的属性，那么当依赖注入的时候，就会产生当A还未创建完的时候因为对于B的创建再次返回创建A，造成循环依赖，也就是情况：isPrototypeCurrentlyInCreation(beanName)判断为true。

检测parentBeanFactory。

  从代码上看这部分对应上面第46行到58行，如果缓存没有数据的话就直接转到父类工厂上去加载了，但是这里也别忽略其判断条件：parentBeanFactory != null && !containsBeanDefinition(beanName)。

其中parentBeanFactory != null即parentBeanFactory如果为空，则其他一切都是浮云，也不会转到父类工厂去加载；
而!containsBeanDefinition(beanName)，则是检测当前加载的XML配置文件是否包含beanName所对应的配置，如果没有就到parentBeanFactory去尝试下加载，然后再去递归的调用getBean()方法；

将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition。

  这部分对应上面的68行。在上文中有分析到，从XML配置文件中读取到的Bean信息是存储在GernericBeanDefinition中的，但是所有Bean的后续处理都是针对RootBeanDefinition进行的，所以这里需要进行一个转换，转换的同时如果父类bean不为空的话，也会一并合并父类的属性。

加载依赖。

  这部分对应上面的73到78行。因为bean的初始化过程中很可能会用到某些属性，而某些属性很可能是动态配置的，并且配置成依赖于其他的bean，那么这个时候就有必要先加载依赖的bean，所以，在Spring的加载顺序中，在初始化某一个bean的时候首先会初始化这个bean所对应的所有依赖对象。

针对不同的scope进行bean的创建。

  这部分对应上面的84到138行。我们都知道，在Spring中存在着不同的scope，其中默认的是singleton，但是还有些其他的配置诸如prototype、request之类的。在这个步骤中，Spring会根据不同的配置进行不同的初始化策略，这部分的过程很复杂，我们放到后面的文章中专门来解析这部分。

类型转换。

  这部分对应上面的149到161行。bean的加载到这一步已经基本结束了，通常对加载bean的实际执行方法doGetBean()进行调用时传入的参数requiredType是为空，但是还是可能会存在这样的情况，即返回的bean其实是个String，但是requiredType却传入Integer类型，那么这时候本步骤就会起作用了，它的功能是将返回的bean转换为requiredType所指定的类型。当然，String转换为Integer是最简单的一种转换，在Spring中提供了各种各样的转换器，用户也可以自己扩展转换器来满足需求。

　　经过上面的步骤后bean的加载就结束了，这个时候就可以返回我们所需要的bean了。其中最重要的就是步骤8，针对不同的scope进行bean的创建，这个后面会专门写一篇文章对这部分进行解析，接下来先来看一下除此之外的一些主要功能实现吧。

2. 尝试从缓存加载单例

　　前面提到过，单例在同一个Spring容器内只会被创建一次，所以每次获取bean时都会先尝试从缓存获取，未获取到则会尝试从头加载bean。

　　这里的步骤是先从缓存singletonObjects获取，没有则再次尝试从singletonFactories中获取。因为在创建单例bean的时候会存在依赖注入的情况，而在创建依赖bean的时候为了避免循环依赖，Spring创建bean的原则是不等bean创建完成就会将创建bean的ObjectFactory提早曝光加入到缓存中，一旦下一个bean创建时需要依赖上个bean，则直接使用ObjectFactory。

public Object getSingleton(String beanName) {
    // 参数true设置允许早期依赖
    return getSingleton(beanName, true);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 检查缓存中是否存在实例
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 如果为空，则锁定全局变量并进行处理
        synchronized (this.singletonObjects) {
            // 如果此bean正在加载则不处理
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                // 当某些方法需要提前初始化的时候则会调用addSingletonFactory方法将对应的ObjectFactory初始化策略存储在singletonFactories
                ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    // 调用预先设定的getObject方法
                    singletonObject = singletonFactory.getObject();
                    // 记录在缓存中，earlySingletonObjects和singletonFactories互斥
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

　　这里首先尝试从singletonObjects里面获取实例，如果获取不到再从earlySingletonObjects里面获取，如果还获取不到，再尝试从singletonFactories里面获取beanName对应的ObjectFactory，然后调用这个ObjectFactory的getObject()来创建bean，并放到earlySingletonObjects里面去，并且从singletonFacotories里面remove掉这个ObjectFactory，而对于后续的所有内存操作都只是为了循环依赖检测时使用，也就是在allowEarlyReference为true的情况下才会使用。

  这里涉及用于存储bean的不同的map，简单解释如下：

singletonObjects：用于保存BeanName和bean实例之间的关系，bean name–>bean instance；
singletonFactories：用于保存BeanName和创建bean的工厂之间的关系，bean name–>ObjectFactory；
earlySingletonObjects：也是保存BeanName和bean实例之间的关系，与singletonObjects的不同之处在于，当一个单例bean被放到这里面后，那么当bean还在创建过程中，就可以通过getBean方法获取到了，其目的是用来检测循环引用；
registeredSingletons：用来保存当前所有已注册的bean；

　　这里从缓存获取到object，并不一定是我们最终想要的bean，比如这个bean的类型是FactoryBean，这其实是bean的初始状态，我们真正需要的是工厂bean中定义的factory-method方法中返回的bean，而getobjectForBeanInstance方法就是完成这个工作的。关于工厂bean，这里再说几句。

2.1 FactoryBean

　　一般情况下，Spring通过反射机制利用beanDefinition的class属性指定的实现类来实例化bean。如果按照传统的方式，如果一个bean有很多属性，则需要在<bean>中提供大量的配置信息，配置方式的灵活性是受限的，这时采用编码的方式可能会得到一个更简单的方案。Spring为此提供了一个org.Springframework.bean.factory.FactoryBean的工厂类接口，用户可以通过实现该接口定制实例化bean的逻辑。
　　FactoryBean接口对于Spring框架来说占有重要地位，其自身就提供了许多FactoryBean的实现，它们隐藏了实例化一些复杂bean的细节，给上层应用带来了便利。该接口中定义了3个方法：

T getObject()：返回由FactoryBean创建的bean实例，如果isSingleton()返回true，则该实例会放到Spring容器中单例实例缓存池中；
boolean isSingleton()：返回由FactoryBean创建的bean实例的作用域是singleton还是prototype；
Class<T> getObjectType()：返回FactoryBean创建的bean类型；

　　当配置文件中<bean>的class属性配置的实现类实现了FactoryBean接口时，通过getBean()方法返回的并不是FactoryBean本身，而是FactoryBean#getObject()方法所返回的对象，相当于FactoryBean#getObject()代理了getBean()方法。例如：如果使用传统方式配置下面Car的<bean>时，Car的每个属性分别对应一个<property>元素标签。

public class Car{
    private int masSpeed;
    private String brand;
    private double price;

    // get/set 方法    
}

　　如果用FactoryBean的方式实现就会灵活一些，可以通过逗号分隔符的方式一次性配置所有属性：

public class CarFactoryBean implements FactoryBean<Car> {
    private String carInfo;
    
    public car getObject() throws Exception {
        Car car = new Car();
        String[] infos = carInfo.split(",");
        car.setBrand(infos[0]);
        car.setMaxSpeed(Integer.valueOf(infos[1]));
        car.setPrice(Double.valueOf(infos[2]));
        return car;
    }

    public Class<Car> getObectType() {
        return Car.class;
    }

    public boolean inSingleton() {
        return false;
    }

    public String getCarInfo() {
        return this.carInfo;
    }

    // 接收逗号分隔符设置属性信息
    public void setCarInfo(String carInfo) {
        this.carInfo = carInfo;
    }
}

　　有了这个CarFactoryBean后，就可以在配置文件中使用下面这种自定义的配置方式进行配置了：

<bean id = "car" class = "xxx" carInfo = "保时捷,400,20000"/>

　　当调用getBean(“car”)时，Spring通过反射机制发现CarFactoryBean实现了FactoryBean的接口，这时Spring容器就调用接口方法CarFactoryBean#getObject()返回Car的实例bean。如果希望获取CarFactoryBean的实例，则需要在使用getBean(beanName)方法时在beanName前面显示的加上”&”前缀，比如getBean(“&car”)。

3. FactoryBean的实例化

　　在getBean方法中，getObjectForBeanInstance()是个高频率使用的方法，无论是从缓存中获得bean还是根据不同的scope策略加载bean。总之，我们得到bean的实例后要做的第一步就是调用这个方法来检测一下正确性，其实就是用于检测当前bean是否是FactoryBean类型的bean，如果是，那么需要调用该bean对应的FactoryBean实例中的getobject()方法。

protected Object getObjectForBeanInstance(
            Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

    // Don't let calling code try to dereference the factory if the bean isn't a factory.
    // 如果指定的name是工厂相关(以&为前缀)且beanInstance又不是FactoryBean类型则验证不通过
    if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
        throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
    }

    // Now we have the bean instance, which may be a normal bean or a FactoryBean.
    // If it's a FactoryBean, we use it to create a bean instance, unless the
    // caller actually wants a reference to the factory.
    // 现在我们有了个bean的实例，这个实例可能会是正常的bean或者是FactoryBean
    // 如果是FactoryBean我们将使用它创建实例，但是如果用户想要直接获取工厂实例而不是工厂的getObject方法对应的实例那么传入的name应该加入前缀&
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
        return beanInstance;
    }
    // 加载FactoryBean
    Object object = null;
    if (mbd == null) {
        // 尝试从缓存中加载bean
        object = getCachedObjectForFactoryBean(beanName);
    }
    if (object == null) {
        // Return bean instance from factory.
        // 到这里已经明确知道beanInstance一定是FactoryBean类型
        FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
        // containBeanDefinition检测beanDefinitionMap中也就是在所有已经加载的类中检测是否定义beanName
        // Caches object obtained from FactoryBean if it is a singleton.
        if (mbd == null && containsBeanDefinition(beanName)) {
            //将存储XML配置文件的GernericBeanDefinition转换为RootBeanDefinition，如果指定BeanName是子Bean的话同时会合并父类的相关属性
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        // 是否是用户定义的而不是应用程序本身定义的
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

　　这部分并没有实质性的工作，主要是对传入的bean判断是否是FactoryBean，不是则直接返回，是则将解析bean的工作委托给getObjectFromFactoryBean()。

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    // 如果是单例模式
    if (factory.isSingleton() && containsSingleton(beanName)) {
        synchronized (getSingletonMutex()) {
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
                object = doGetObjectFromFactoryBean(factory, beanName);
                // Only post-process and store if not put there already during getObject() call above
                // (e.g. because of circular reference processing triggered by custom getBean calls)
                Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                if (alreadyThere != null) {
                    object = alreadyThere;
                }
                else {
                    if (object != null && shouldPostProcess) {
                        try {
                            // 调用objectFactory的后处理器
                            object = postProcessObjectFromFactoryBean(object, beanName);
                        }
                        catch (Throwable ex) {
                            throw new BeanCreationException(beanName,
                                    "Post-processing of FactoryBean's singleton object failed", ex);
                        }
                    }
                    this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
                }
            }
            return (object != NULL_OBJECT ? object : null);
        }
    }
    else {
        Object object = doGetObjectFromFactoryBean(factory, beanName);
        if (object != null && shouldPostProcess) {
            try {
                // 调用objectFactory的后处理器
                object = postProcessObjectFromFactoryBean(object, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
            }
        }
        return object;
    }
}

　　如上代码中，如果返回的bean是单例的，那就必须要保证全局唯一，同时，也因为是单例的，所以不必重复创建，可以使用缓存来提高性能，也就是说已经加载过就要记录下来以便于下次复用，否则的话就直接获取了。

　　如果判断返回的bean是单例，为了避免重复创建，使用了缓存(factoryBeanObjectCache)来提高性能，如果有则直接获取。而且必须保证全局唯一，这里使用同步锁，并且在调用doGetObjectFromFactoryBean()之后又一次从缓存尝试获取，如果有则使用已创建的，并且不会执行后处理器，即调用postProcessObjectFromFactoryBean()方法，这里面主要是调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理，我们在实际开发过程中可以针对此特性设计自己的业务逻辑。

　　在上面的方法中还是没有真正加载bean的操作，这部分委托给doGetObjectFromFactoryBean()来完成：

private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
            throws BeanCreationException {

    Object object;
    try {
        if (System.getSecurityManager() != null) {
            // 需要权限验证
            AccessControlContext acc = getAccessControlContext();
            try {
                object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
                    public Object run() throws Exception {
                            return factory.getObject();
                        }
                    }, acc);
            }
            catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }
        else {
            // 直接调用getObject()方法
            object = factory.getObject();
        }
    }
    catch (FactoryBeanNotInitializedException ex) {
        throw new BeanCurrentlyInCreationException(beanName, ex.toString());
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
    }

    // Do not accept a null value for a FactoryBean that's not fully
    // initialized yet: Many FactoryBeans just return null then.
    if (object == null && isSingletonCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(
                beanName, "FactoryBean which is currently in creation returned null from getObject");
    }
    return object;
}

　　在doGetObjectFromFactoryBean()方法中我们终于看到了我们想要看到的方法，也就是object = factory.getObject()，是的，就是这句代码，我们的历程犹如剥洋葱一样，一层一层的直到最内部的代码实现，虽然最终实现很简单。

4. 总结

　　本文在浏览了完整的bean获取流程的基础上，着重分析了从缓存中获取bean，这只是整个bean获取流程中的第一步，如果从缓存获取bean未果，那么就要开始从头创建一个bean了，而这个过程留待后文分析。