[[385910]]

前情回顧前文「Spring 如何從 IoC 容器中獲取對象?」從整體上分析了如何從 Spring IoC 容器獲取一個 bean 對象。該邏輯由 AbstractBeanFactory#doGetBean 方法實現，主要流程如下：

本文進一步深入細節，主要分析如何創建 singleton(單例)類型的對象。

如何創建單例對象?

從流程圖可以看出，當獲取一個 bean 對象時，Spring 會首先嘗試從緩存中獲取單例對象。

值得注意是的：

1. 只有對象是單例的場景，即 scope 為 singleton 時才會緩存對象。
2. 這里其實涉及到了所謂的「三級緩存」，為了更容易理解三級緩存，本文先研究這個 bean 對象是什么時候放入緩存的，后面再研究三級緩存。

既然能取，必然有地方把 bean 對象存入了緩存，那緩存中的數據是從哪里來的呢?

下面主要分析單例對象是如何創建、并放入緩存中的。

該邏輯在 AbstractBeanFactory#doGetBean 方法中，主要代碼如下(保留了創建單例 bean 對象的代碼，其他部分暫時忽略)：

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory { 
    // ... 
 
    protected <T> T doGetBean( 
            String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) 
            throws BeansException { 
 
        String beanName = transformedBeanName(name); 
        Object bean; 
 
        // 從緩存中獲取單例 bean 對象 
        Object sharedInstance = getSingleton(beanName); 
         
        // 緩存中不存在 bean 對象 
        else { 
 
            // ... 
 
            try { 
                // 獲取 BeanDefinition 
                RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 
 
                // 獲取依賴的 bean 對象 
                // 若創建一個 bean 對象時依賴其他對象，則先創建被依賴對象 
                // ... 
 
                // 創建 scope 為 singleton（單例）的對象 
                if (mbd.isSingleton()) { 
                    sharedInstance = getSingleton(beanName, () -> { 
                        try { 
                            return createBean(beanName, mbd, args); 
                        } 
                        catch (BeansException ex) { 
                            // ... 
                        } 
                    }); 
                    // 處理 FactoryBean 的場景 
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); 
                } 
 
                // 創建 scope 為 prototype 的對象 
                else if (mbd.isPrototype()) { 
                    // ... 
                } 
 
                // 創建其他類型對象 
                else { 
                    // ... 
                } 
            } 
            catch (BeansException ex) { 
                // ... 
            } 
        } 
 
        // 類型檢查 
 
        return (T) bean; 
    } 
} 

其實就是這個 DefaultSingletonBeanRegistry#getSingleton 方法，代碼如下：

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry { 
    // 單例 bean 對象緩存（beanName, bean） 
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256); 
 
    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) { 
        Assert.notNull(beanName, "Bean name must not be null"); 
        synchronized (this.singletonObjects) { 
            // 先從緩存中獲取 bean 對象 
            Object singletonObject = this.singletonObjects.get(beanName); 
            // 緩存中不存在時再去創建 
            if (singletonObject == null) { 
                // ... 
                // 創建單例對象前 
                beforeSingletonCreation(beanName); 
                boolean newSingleton = false; 
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null); 
                if (recordSuppressedExceptions) { 
                    this.suppressedExceptions = new LinkedHashSet<>(); 
                } 
                try { 
                    // 創建單例對象 
                    singletonObject = singletonFactory.getObject(); 
                    newSingleton = true; 
                } 
                // catch ... 
                finally { 
                    if (recordSuppressedExceptions) { 
                        this.suppressedExceptions = null; 
                    } 
                    // 創建單例對象后 
                    afterSingletonCreation(beanName); 
                } 
                if (newSingleton) { 
                    // 將對象添加到緩存 
                    addSingleton(beanName, singletonObject); 
                } 
            } 
            // 緩存中有的話直接返回 
            return singletonObject; 
        } 
    } 
 
} 

getSingleton 方法會先從緩存 singletonObjects(其實就是一個 Map)中獲取 bean 對象，如果緩存有就直接返回，否則再去創建。創建成功后，會把該對象存入緩存。

創建的邏輯在哪呢?

看代碼是通過 ObjectFactory#getObject 方法來創建的，ObjectFactory 是一個函數式接口：

@FunctionalInterface 
public interface ObjectFactory<T> { 
    T getObject() throws BeansException; 
} 

這個方法的實現是什么呢?退回上一層，即 getBean 方法，看這里：

sharedInstance = getSingleton(beanName, () -> { 
    try { 
        // 創建 bean 對象 
        return createBean(beanName, mbd, args); 
    } 
    catch (BeansException ex) { 
        // ... 
    } 
}); 

這里用到了 Lambda 表達式，將如下表達式作為參數：

() -> { 
    try { 
        // 創建 bean 對象 
        return createBean(beanName, mbd, args); 
    } 
    catch (BeansException ex) { 
        // ... 
    } 
} 

創建 bean 對象的邏輯就在這個 createBean 方法中，它在 AbstractAutowireCapableBeanFactory 類中：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory 
        implements AutowireCapableBeanFactory { 
 
    @Override 
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 
            throws BeanCreationException { 
 
        RootBeanDefinition mbdToUse = mbd; 
 
        Class<?> resolvedClass = resolveBeanClass(mbd, beanName); 
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) { 
            mbdToUse = new RootBeanDefinition(mbd); 
            mbdToUse.setBeanClass(resolvedClass); 
        } 
 
        // Prepare method overrides. 
        try { 
            mbdToUse.prepareMethodOverrides(); 
        } 
        // catch ... 
 
        try { 
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance. 
            // 這里可能返回代理對象 
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 
            if (bean != null) { 
                return bean; 
            } 
        } 
        // catch ... 
 
        try { 
            // 創建 bean 對象 
            Object beanInstance = doCreateBean(beanName, mbdToUse, args); 
            if (logger.isTraceEnabled()) { 
                logger.trace("Finished creating instance of bean '" + beanName + "'"); 
            } 
            return beanInstance; 
        } 
        // catch ... 
    } 
} 

• 值得注意的是，resolveBeforeInstantiation 方法其實是跟 AOP 實現相關的，可能在這里生成代理對象就返回了。由于現在主要分析 IoC 的流程，因此這里暫時略過，有興趣的朋友們可以自行研究。

這里繼續沿著主線邏輯走。

創建 bean 對象是在 doCreateBean 方法中實現的，如下：

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory 
        implements AutowireCapableBeanFactory { 
 
    protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) 
            throws BeanCreationException { 
 
        // Instantiate the bean. 
        // 1. 實例化 bean 
        BeanWrapper instanceWrapper = null; 
        if (mbd.isSingleton()) { 
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName); 
        } 
        if (instanceWrapper == null) { 
            instanceWrapper = createBeanInstance(beanName, mbd, args); 
        } 
        Object bean = instanceWrapper.getWrappedInstance(); 
        Class<?> beanType = instanceWrapper.getWrappedClass(); 
        if (beanType != NullBean.class) { 
            mbd.resolvedTargetType = beanType; 
        } 
 
        // Allow post-processors to modify the merged bean definition. 
        synchronized (mbd.postProcessingLock) { 
            if (!mbd.postProcessed) { 
                try { 
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 
                } 
                // catch ... 
                mbd.postProcessed = true; 
            } 
        } 
 
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && 
                isSingletonCurrentlyInCreation(beanName)); 
        if (earlySingletonExposure) { 
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); 
        } 
 
        // Initialize the bean instance. 
        Object exposedObject = bean; 
        try { 
            // 2. 填充屬性 
            populateBean(beanName, mbd, instanceWrapper); 
            // 3. 初始化 
            exposedObject = initializeBean(beanName, exposedObject, mbd); 
        } 
        // catch ... 
 
        if (earlySingletonExposure) { 
            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<>(dependentBeans.length); 
                    for (String dependentBean : dependentBeans) { 
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) { 
                            actualDependentBeans.add(dependentBean); 
                        } 
                    } 
                    // ... 
                } 
            } 
        } 
 
        // Register bean as disposable. 
        try { 
            registerDisposableBeanIfNecessary(beanName, bean, mbd); 
        } 
        // catch ... 
 
        return exposedObject; 
    } 
 
} 

• 注意：Instantiate 和 Initialize 雖然看起來有點像，但它倆不是一回事，前者是“實例化”，后者是“初始化”。

這個方法看起來有點長，但最主要的事情只有三件：

1. 創建 bean 對象：createBeanInstance 方法
2. 填充屬性：populateBean 方法
3. 初始化 bean：initializeBean 方法

這幾個方法內部其實都有一大堆堆堆堆堆……的代碼，再對照一下前面給出的整體流程圖 :

就是這樣。

本文在前文整體分析的基礎上又進一步細化，先到這里吧，后面再繼續分析~

小結

如何從 Spring IoC 容器中獲取 bean 對象?前文對此進行了整體流程的分析。

本文在前文的基礎上又進一步細化，主要從整體上探討了 Spring 如何創建單例的 bean 對象，整體上分為三個步驟：

1. 創建 bean 對象。
2. 填充 bean 屬性
3. 初始化 bean 對象

至于這三個步驟具體又做了什么，且聽下回分解。