spring源碼（10）從緩存中獲取到單例bean的後續操作（對FactoryBean的處理）

從緩存中獲取到實例，doGetBean第一步就是對我們輸入的name做了處理。

1. 去除FactoryBean的修飾符，也就是name=”&a”，最終處理爲name=”a”
2. 取指定別名最終所指向的beanName

在從緩存中獲取實例時，getSingleton(beanName)，參數是已經處理的。我們知道如果想要獲取FactoryBean getObject方法對應的實例，那麼name需要加前綴&。所以通過getSingletom獲取到的可能是FactoryBean實例。

getObjectForBeanInstance就是對以上的糾正。

總體流程圖如下：

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

             //如果name的以&爲開頭，但是beanInstance又不是FactoryBean類型，則拋出BeanIsNotAFactoryException
             if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
                    throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
             }

             //如果beanInstance不是FactoryBean類型，或者不是以&開頭，則直接返回實例
             if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
                    return beanInstance;
             }

             //以下步驟處理以&開頭的name，即FactoryBean
             Object object = null;
             if (mbd == null) {
                    //嘗試從緩存中加載bean
                    object = getCachedObjectForFactoryBean(beanName);
             }
             if (object == null) {
                    //到這裏已經明確知道beanInstance爲FactoryBean類型
                    FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
                    //將存儲XML配置文件的GernericBeanDefinition轉換成RootBeanDefinition
                    if (mbd == null && containsBeanDefinition(beanName)) {
                          mbd = getMergedLocalBeanDefinition(beanName);
                    }
                    boolean synthetic = (mbd != null && mbd.isSynthetic());

                    object = getObjectFromFactoryBean(factory, beanName, !synthetic);
             }
             return object;
       }

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
             //如果factoryBean爲單例子，並且已經在緩存中存在
             if (factory.isSingleton() && containsSingleton(beanName)) {
                    //同步訪問singletonObjects
                    synchronized (getSingletonMutex()) {
                          //從緩存中獲取bean實例，如果存在直接返回
                          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 {
                                                    //後續處理
                                                    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 {
                                 //後續處理
                                 object = postProcessObjectFromFactoryBean(object, beanName);
                          }
                          catch (Throwable ex) {
                                 throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                          }
                    }
                    return object;
             }
       }

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>() {
                                       @Override
                                       public Object run() throws Exception {
                                                    return factory.getObject();
                                              }
                                       }, acc);
                          }
                          catch (PrivilegedActionException pae) {
                                 throw pae.getException();
                          }
                    }
                    else {
                          //直接調用factorybean的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;
       }