bean的加載

對於加載bean的功能，在Spring中的調用方式爲：

MyTestBean bean = (MyTestBean)bf.getBean("myTestBean")

這行代碼在Spring中是這樣實現的

public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
    return this.doGetBean(name, requiredType, args, false);
}

protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
    //提取對應的beanName
    final String beanName = this.transformedBeanName(name);
    /*
     *檢查緩存中或者實例工廠中是否有對應的實例
     *爲什麼首先會使用這段代碼呢，因爲在創建單例bean的時候會存在依賴注入的情況，而在創建依賴的時候爲了避免循環依賴，
     *Spring創建bean的原則是不等bean創建完成就會將創建bean的ObjectFactory提早曝光，
     *也就是將ObjectFactory加入到緩存中，一旦下個bean創建時候需要依賴上個bean則直接使用ObjectFactory
     */
    //直接嘗試從緩存獲取或者singletonFactories中的ObjectFactory中獲取
    Object sharedInstance = this.getSingleton(beanName);
    Object bean;
    if(sharedInstance != null && args == null) {
        if(this.logger.isDebugEnabled()) {
            if(this.isSingletonCurrentlyInCreation(beanName)) {
                this.logger.debug("Returning eagerly cached instance of singleton bean \'" + beanName + "\' that is not fully initialized yet - a consequence of a circular reference");
            } else {
                this.logger.debug("Returning cached instance of singleton bean \'" + beanName + "\'");
            }
        }

        //返回對應的實例，有時候存在諸如BeanFactory的情況並不是直接返回實例本身而是返回指定方法返回的實例
        bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
    } else {
        //只有在單例情況下才會嘗試解決循環依賴，原型模式情況下，如果存在
        //A中有B的屬性，B中有A的屬性，那麼當依賴注入的時候，就會產生當A還未創建完的時候因爲
        //對於B的創建再次返回創建A，造成循環依賴，也就是下面的情況
        //isPrototypeCurrentlyInCreation(beanName)爲true
        if(this.isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        BeanFactory parentBeanFactory = this.getParentBeanFactory();
        //如果BeanDefinitionMap中也就是在所有已經加載的類中不包括beanName則嘗試從parentBeanFactory中檢測
        if(parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
            String var19 = this.originalBeanName(name);
            //遞歸到BeanFactory中尋找
            if(args != null) {
                return parentBeanFactory.getBean(var19, args);
            }

            return parentBeanFactory.getBean(var19, requiredType);
        }

        //如果不是僅僅做類型檢查則是創建bean，這裏要進行記錄
        if(!typeCheckOnly) {
            this.markBeanAsCreated(beanName);
        }

        //將存儲XML配置文件的GernericBeanDefinition轉換爲RootBeanDefinition，如果指定BeanName是子Bean的話同時會合並父類的相關屬性
        final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
        this.checkMergedBeanDefinition(mbd, beanName, args);
        String[] dependsOn = mbd.getDependsOn();
        String scopeName;
        //若存在依賴則需要遞歸實例化依賴的bean
        if(dependsOn != null) {
            String[] var14 = dependsOn;
            int ex = dependsOn.length;

            for(int scope = 0; scope < ex; ++scope) {
                scopeName = var14[scope];
                this.getBean(scopeName);
                //緩存依賴調用
                 this.registerDependentBean(scopeName, beanName);
            }
        }

        //實例化依賴的bean後便可以實例化mbd本身了
        //singleton模式的創建
        if(mbd.isSingleton()) {
            sharedInstance = this.getSingleton(beanName, new ObjectFactory() {
                public Object getObject() throws BeansException {
                    try {
                        return AbstractBeanFactory.this.createBean(beanName, mbd, args);
                    } catch (BeansException var2) {
                        AbstractBeanFactory.this.destroySingleton(beanName);
                        throw var2;
                    }
                }
            });
            bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        } else if(mbd.isPrototype()) {
            //prototype模式的創建(new)
            scopeName = null;

            Object var20;
            try {
                this.beforePrototypeCreation(beanName);
                var20 = this.createBean(beanName, mbd, args);
            } finally {
                this.afterPrototypeCreation(beanName);
            }

            bean = this.getObjectForBeanInstance(var20, name, beanName, mbd);
        } else {
            //指定的scope上實例化bean
            scopeName = mbd.getScope();
            Scope var21 = (Scope)this.scopes.get(scopeName);
            if(var21 == null) {
                throw new IllegalStateException("No Scope registered for scope \'" + scopeName + "\'");
            }

            try {
                Object var22 = var21.get(beanName, new ObjectFactory() {
                    public Object getObject() throws BeansException {
                        AbstractBeanFactory.this.beforePrototypeCreation(beanName);

                        Object var2;
                        try {
                            var2 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
                        } finally {
                            AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                        }

                        return var2;
                    }
                });
                bean = this.getObjectForBeanInstance(var22, name, beanName, mbd);
            } catch (IllegalStateException var18) {
                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", var18);
            }
        }
    }

    //檢查需要的類型是否符合bean的實際類型
    if(requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    } else {
        return bean;
    }
}

對於Spring加載bean的過程，大致分爲以下幾步：

轉換對應beanName

這裏傳入的參數name不一定就是beanName，有可能是別名或FactoryBean，所以需要進行一系列的解析，這些解析內容包括如下內容
- 去除FactoryBean的修飾符，也就是如果name=”&aa”，那麼會首先去除&而使name=”aa”
- 取指定alias所表示的最終beanName，例如別名A指向名稱爲B的bean則返回B；若別名A指向別名B，別名B又指向名稱爲C的bean則返回C
嘗試從緩存中加載單例

單例在Spring的同一個容器內只會被創建一次，後續再獲取bean，就直接從單例緩存中獲取了。這裏只是嘗試加載，首先嚐試從緩存中加載，如果加載不成功則再次嘗試從singletonFactories中加載，因爲在創建單例bean的時候會存在依賴注入的情況，而在創建依賴的時候爲了避免循環依賴，在Spring中創建bean的原則是不等bean創建完成就會將創建bean的ObjectFactory提早曝光加入到緩存中，一旦下一個bean創建時候需要依賴上一個bean則直接使用ObjectFactory
bean的實例化

如果從緩存中得到了bean的原始狀態，則需要對bean進行實例化，這裏有必要強調一下，在緩存中記錄的只是最原始的bean狀態，並不一定是我們最終想要的bean
原型模式的依賴檢查

只有在單例情況下才會嘗試解決循環依賴，如果存在A中有B的屬性，B中有A的屬性，那麼當依賴注入的時候，就會產生當A還未創建完的時候因爲對於B的創建再次返回創建A，造成循環依賴，也就是情況：isPrototypeCurrentlyInCreation(beanName)判斷true
檢測parentBeanFactory

從代碼上來看，如果緩存沒有數據的話直接轉到父類工廠上去加載，!this.containsBeanDefinition(beanName檢測如果當前加載的XML配置文件中不包含beanName所對應的配置，就只能到parentBeanFactory去嘗試，然後再去遞歸的調用getBean方法
將存儲XML配置文件的GernericBeanDefinition轉換爲RootBeanDefinition

因爲從XML配置文件中讀取到的Bean信息是存儲在GernericBeanDefinition中的，但是所有的Bean後續處理都是針對於RootBeanDefinition的，所以這裏需要進行一個轉換，轉換的同時如果父類bean不爲空的話，則會一併合併父類屬性
尋找依賴

因爲bean的初始化過程很可能會用到某些屬性，而某些屬性很可能是動態配置的，並且配置成依賴於其他的bean，那麼這個時候就有必要先加載依賴的bean，所以，在Spring的加載順尋中，在初始化某一個bean的時候首先會初始化這個bean所對應的依賴
針對不同的scope進行bean的創建

在Spring中存在着不同的scope，其中默認的是singleton，但是還有些其他的配置諸如prototype、request之類的，在這個步驟中，Spring會根據不同的配置進行不同的初始化策略
類型轉換

程序到這裏返回bean後已經基本結束了，通常對該方法的調用參數requiredType是爲空的，但是可能會存在這樣的情況，返回的bean其實是個Spring，但是requiredType卻傳入Integer類型，那麼這時候本步驟就會起作用了，它的功能是將返回的bean轉換爲requiredType所指定的類型，當然，Spring轉換爲Integer是最簡單的一種轉換，在Spring中提供了各種各樣的轉換器，用戶也可以自己擴展轉換器來滿足需求

FactoryBean的使用

一般情況下， Spring通過反射機制利用bean的class屬性指定實現類來實例化bean，在某些情況下，實例化bean過程比較複雜，如果按照傳統的方式，則需要在<bean>中提供大量的配置信息，配置方式的靈活性是受限的，這時採用編碼的方式可能會得到一個簡單的方案

Spring爲此提供了一個org.Springframework.bean.factory.FactoryBean的工廠類接口，用戶可以通過實現該接口定製實例化bean的邏輯

FactoryBean接口對於Spring框架來說佔有重要的地位，Spring自身就提供了70多個FactoryBean的實現，它們隱藏了實例化一些複雜bean的細節，給上層應用帶來了便利，從Spring 3.0開始，FactoryBean開始支持泛型，即接口聲明改爲FactoryBean<T>的形式：

package org.springframework.beans.factory;

public interface FactoryBean<T> {
    T getObject() throws Exception;

    Class<?> getObjectType();

    boolean isSingleton();
}

在該接口中還定義了以下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的每個屬性分別對應一個<propery>元素標籤

public class Car{
    private int maxSpeed;
    private String brand;
    private double price;
    //get/set方法
}

如果用FactoryBean的方式實現就會靈活一些，下例通過逗號分隔符的方式一次性地爲Car的所有屬性指定配置值

public class CarFactoryBean implements FactoryBean<Car>{
    private String carInfo;
    public Car getObject() throws Exceptino {
        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> getObjectType(){
        return Car.class;
    }

    public boolean isSingleton(){
        return false;
    }

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

    //接受逗號分割符設置屬性信息
    public void setCarInfo(String carInfo){
        this.carInfo = carInfo;
    }
}

有了這個CarFactoryBean後，就可以在配置文件中使用下面這種自定義的配置方式配置CarBean了

<bean id="car" class="com.test.factorybean.CarFactoryBean" carInfo="超級跑車,400,2000000" />

當調用getBean(“car”)時，Spring通過反射機制發現CarFactoryBean實現了FactoryBean的接口，這時Spring容器就調用接口方法CarFactoryBean#getObject()方法返回，如果希望獲取CarFactoryBean的實例，則需要在使用getBean(beanName)方法時在beanName前顯示的加上”&”前綴，例如getBean(“&car”)

緩存中獲取單例bean

 public Object getSingleton(String beanName) {
    //參數true設置標識允許早期依賴
    return this.getSingleton(beanName, true);
}

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    //檢查緩存中是否存在實例
    Object singletonObject = this.singletonObjects.get(beanName);
    if(singletonObject == null) {
        //如果爲空，則鎖定全局變量並進行處理
        Map var4 = this.singletonObjects;
        synchronized(this.singletonObjects) {
            //如果此bean正在加載則不處理
            singletonObject = this.earlySingletonObjects.get(beanName);
            if(singletonObject == null && allowEarlyReference) {
                //當某些方法需要提前初始化的時候則會調用addSingletonFactory方法將對應的ObjectFactory初始化策略存儲在singletonFactories
                ObjectFactory singletonFactory = (ObjectFactory)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裏面去，並且從singletonFactories裏面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

從bean的實例中獲取對象

在getBean方法中，getObjectForBeanInstance是個高頻率使用的方法，無論是從緩存中獲得bean還是根據不同的scope策略加載bean。總之，得到bean的實例後要做的第一步就是調用這個方法來檢測一下正確性，其實就是用於檢測當前bean是否是FactoryBean類型的bean，如果是，那麼需要調用該bean對應的FactoryBean實例中的getObject()作爲返回值

無論是從緩存中獲取到的bean還是通過不同的scope策略加載的bean都只是最原始的bean狀態，並不一定是最終想要的bean，如需要對工廠bean進行處理，那麼這裏得到的其實是工廠bean的初始狀態，但是我們真正需要的是工廠bean中定義的factory-method方法中返回的bean，而getObjectForBeanInstance方法就是完成這個工作的

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
    //如果指定的name是工廠相關(以&爲前綴)且beanInstance又不是FactoryBean類型則驗證不通過
    if(BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
        throw new BeanIsNotAFactoryException(this.transformedBeanName(name), beanInstance.getClass());
    } else if(beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
        //加載FactoryBean
        Object object = null;
        if(mbd == null) {
            //嘗試從緩存中加載bean
            object = this.getCachedObjectForFactoryBean(beanName);
        }

        //到這裏已經明確知道beanInstance一定是FactoryBean類型
        if(object == null) {
            FactoryBean factory = (FactoryBean)beanInstance;
            //containsBeanDefinition檢測BeanDefinitionMap中也就是在所有已經加載的類中檢測是否定義beanName
            if(mbd == null && this.containsBeanDefinition(beanName)) {
                //將存儲XML配置文件的GernericBeanDefinition轉換爲RootBeanDefinition，如果指定BeanName是子Bean的話同時會合並父類的相關屬性
                mbd = this.getMergedLocalBeanDefinition(beanName);
            }

            //是否是用戶定義的而不是應用程序本身定義的
            boolean synthetic = mbd != null && mbd.isSynthetic();
            object = this.getObjectFromFactoryBean(factory, beanName, !synthetic);
        }

        return object;
    } else {
        return beanInstance;
    }
}

getObjectForBeanInstance中所做的工作如下：

對FactoryBean正確性的驗證
對非FactoryBean不做任何處理
對bean進行轉換

將從Factory中解析bean的工作委託給getObjectFromFactoryBean

protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {
    if(factory.isSingleton() && this.containsSingleton(beanName)) {
        //如果是單例模式
        synchronized(this.getSingletonMutex()) {
            Object object = this.factoryBeanObjectCache.get(beanName);
            if(object == null) {
                object = this.doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
                this.factoryBeanObjectCache.put(beanName, object != null?object:NULL_OBJECT);
            }

            return object != NULL_OBJECT?object:null;
        }
    } else {
        return this.doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
    }
}

這個方法中只做了一件事情，就是返回的bean如果是單例的，那就必須保證全局唯一，同時，也因爲是單例的，所以不必重複創建，可以使用緩存來提高性能，也就是說已經加載過就要記錄下來以便於下次複用，否則的話就直接獲取了

doGetObjectFromFactoryBean方法的代碼如下：

private Object doGetObjectFromFactoryBean(final FactoryBean factory, String beanName, boolean shouldPostProcess) throws BeanCreationException {
    Object object;
    try {
        //需要權限驗證
        if(System.getSecurityManager() != null) {
            AccessControlContext ex = this.getAccessControlContext();

            try {
                object = AccessController.doPrivileged(new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        return factory.getObject();
                    }
                }, ex);
            } catch (PrivilegedActionException var8) {
                throw var8.getException();
            }
        } else {
            //直接調用getObject方法
            object = factory.getObject();
        }
    } catch (FactoryBeanNotInitializedException var9) {
        throw new BeanCurrentlyInCreationException(beanName, var9.toString());
    } catch (Throwable var10) {
        throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", var10);
    }

    if(object == null && this.isSingletonCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName, "FactoryBean which is currently in creation returned null from getObject");
    } else {
        if(object != null && shouldPostProcess) {
            try {
                //調用ObjectFactory的後處理器
                object = this.postProcessObjectFromFactoryBean(object, beanName);
            } catch (Throwable var7) {
                throw new BeanCreationException(beanName, "Post-processing of the FactoryBean\'s object failed", var7);
            }
        }

        return object;
    }
}

doGetObjectFromFactoryBean實現了從FactoryBean中對應的getObject方法得到bean，但是得到後並沒有立即返回，而是做了些後處理的操作

protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
    return this.applyBeanPostProcessorsAfterInitialization(object, beanName);
}

public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
    Object result = existingBean;
    Iterator var5 = this.getBeanPostProcessors().iterator();

    while(var5.hasNext()) {
        BeanPostProcessor beanProcessor = (BeanPostProcessor)var5.next();
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if(result == null) {
            return result;
        }
    }

    return result;
}

在Spring獲取bean的規則中有這樣一條：儘可能保證所有bean初始化後都會調用註冊的BeanPostProcessor的postProcessAfterInitialization方法進行處理，在實際開發過程中大可以針對此特性設計自己的業務邏輯

獲取單例

如果緩存中不存在已經加載的單例bean就需要從頭開始bean的加載過程了，而Spring中使用getSingleton的重載方法實現bean的加載過程

public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
    Assert.notNull(beanName, "\'beanName\' must not be null");
    Map var3 = this.singletonObjects;
    //全局變量需要同步
    synchronized(this.singletonObjects) {
        //首先檢查對應的bean是否已經加載過，因爲singleton模式其實就是複用以前創建的bean，所以這一步是必須的
        Object singletonObject = this.singletonObjects.get(beanName);
        //如果爲null纔可以進行singleton的bean的初始化
        if(singletonObject == null) {
            if(this.singletonsCurrentlyInDestruction) {
                throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while the singletons of this factory are in destruction (Do not request a bean from a BeanFactory in a destroy method implementation!)");
            }

            if(this.logger.isDebugEnabled()) {
                this.logger.debug("Creating shared instance of singleton bean \'" + beanName + "\'");
            }

            this.beforeSingletonCreation(beanName);
            boolean recordSuppressedExceptions = this.suppressedExceptions == null;
            if(recordSuppressedExceptions) {
                this.suppressedExceptions = new LinkedHashSet();
            }

            try {
                //初始化bean
                singletonObject = singletonFactory.getObject();
            } catch (BeanCreationException var13) {
                BeanCreationException ex = var13;
                if(recordSuppressedExceptions) {
                    Iterator var8 = this.suppressedExceptions.iterator();

                    while(var8.hasNext()) {
                        Exception suppressedException = (Exception)var8.next();
                        ex.addRelatedCause(suppressedException);
                    }
                }

                throw ex;
            } finally {
                if(recordSuppressedExceptions) {
                    this.suppressedExceptions = null;
                }

                this.afterSingletonCreation(beanName);
            }

            //加入緩存
            this.addSingleton(beanName, singletonObject);
        }

        return singletonObject != NULL_OBJECT?singletonObject:null;
    }
}

上述代碼中其實是使用了回調方法，使得程序可以在單例創建的前後做一些準備及處理操作，而真正獲取單例bean的方法其實並不是再此方法中實現的，其實現邏輯是在ObjectFactory類型的實例singletonFactory中實現的，而這些準備及處理操作包括如下內容

檢查緩存是否已經加載過
若沒有加載，則記錄beanName的正在加載狀態
加載單例前記錄加載狀態

beforeSingletonCreation方法是個空實現，其目的是：記錄加載狀態，也就是通過this.singletonsCurrentlyInCreation.add(beanName)將當前正在創建的bean記錄在緩存中，這樣便可以對循環依賴進行檢測
```
 protected void beforeSingletonCreation(String beanName) {
    if(!this.singletonsCurrentlyInCreation.add(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
    }
}
```
通過調用參數傳入的ObjectFactory的個體Object方法實例化bean

加載單例後的處理方法調用

當bean加載結束後需要移除緩存中對該bean的正在加載狀態的記錄

protected void afterSingletonCreation(String beanName) {
    if(!this.singletonsCurrentlyInCreation.remove(beanName)) {
        throw new IllegalStateException("Singleton \'" + beanName + "\' isn\'t currently in creation");
    }
}

將結果記錄至緩存並刪除加載bean過程中所記錄的各種輔助狀態

protected void addSingleton(String beanName, Object singletonObject) {
    Map var3 = this.singletonObjects;
    synchronized(this.singletonObjects) {
        this.singletonObjects.put(beanName, singletonObject != null?singletonObject:NULL_OBJECT);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

返回處理結果

bean的加載邏輯其實是在傳入的ObjectFactory類型的參數singletonFactory中定義的，反推參數的獲取，得到如下代碼：

sharedInstance = getSingleton(beanName, new ObjectFactory<Object>(){
    public Object getObject() throws BeansException {
        try {
            return createBean(beanName, mbd, args);
        } catch(BeansException ex) {
            destroySingleton(beanName);
            throw ex;
        }
    }
});

ObjectFactory的核心部分其實只是調用了createBean的方法

benhuo931115

發佈了84 篇原創文章 · 獲贊 135 · 訪問量 41萬+

私信關注

《Spring源碼深度解析》學習筆記——bean的加載（一）

bean的加載

FactoryBean的使用

緩存中獲取單例bean

從bean的實例中獲取對象

獲取單例

Dubbo API 筆記——配置參考

《大話設計模式》——學習筆記之"創建型模式"（單例&工廠方法&抽象工廠&建造者&原型）

《大型網站技術架構：核心原理與案例分析》——大型網站架構演化過程

雲計算&大數據&人工智能相關概念

Netty系列之Netty高性能之道

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結