【死磕 Spring】—– IOC 之 Factory 實體化 bean

實體化 bean 是一個複雜的過程，其主要的邏輯為：

• 如果存在 Supplier 回呼，則呼叫 obtainFromSupplier() 進行初始化

• 如果存在工廠方法，則使用工廠方法進行初始化

• 首先判斷快取，如果快取中存在，即已經解析過了，則直接使用已經解析了的，根據 constructorArgumentsResolved 引數來判斷是使用建構式自動註入還是預設建構式

• 如果快取中沒有，則需要先確定到底使用哪個建構式來完成解析工作，因為一個類有多個建構式，每個建構式都有不同的構造引數，所以需要根據引數來鎖定建構式並完成初始化，如果存在引數則使用相應的帶有引數的建構式，否則使用預設建構式。

下麵就上面四種情況做分別說明。

obtainFromSupplier()

Supplier> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
    return obtainFromSupplier(instanceSupplier, beanName);
}

首先從 BeanDefinition 中獲取 Supplier，如果不為空，則呼叫 obtainFromSupplier() 。那麼 Supplier 是什麼呢？在這之前也沒有提到過這個欄位。

public interface Supplier<T> {
    T get();
}

Supplier 介面僅有一個功能性的 get()，該方法會傳回一個 T 型別的物件，有點兒類似工廠方法。這個介面有什麼作用？用於指定建立 bean 的回呼，如果我們設定了這樣的回呼，那麼其他的建構式或者工廠方法都會沒有用。在什麼設定該引數呢？Spring 提供了相應的 setter 方法，如下：

    public void setInstanceSupplier(@Nullable Supplier> instanceSupplier) {
        this.instanceSupplier = instanceSupplier;
    }

在構造 BeanDefinition 的時候設定了該值，如下（以 RootBeanDefinition 為例）：

    public <T> RootBeanDefinition(@Nullable Class<T> beanClass, String scope, @Nullable Supplier<T> instanceSupplier) {
        super();
        setBeanClass(beanClass);
        setScope(scope);
        setInstanceSupplier(instanceSupplier);
    }

如果設定了 instanceSupplier 則呼叫 obtainFromSupplier() 完成 bean 的初始化，如下：

    protected BeanWrapper obtainFromSupplier(Supplier> instanceSupplier, String beanName) {
        String outerBean = this.currentlyCreatedBean.get();
        this.currentlyCreatedBean.set(beanName);
        Object instance;
        try {
          // 呼叫 Supplier 的 get()，傳回一個物件
            instance = instanceSupplier.get();
        }
        finally {
            if (outerBean != null) {
                this.currentlyCreatedBean.set(outerBean);
            }
            else {
                this.currentlyCreatedBean.remove();
            }
        }
        // 根據物件構造 BeanWrapper 物件
        BeanWrapper bw = new BeanWrapperImpl(instance);
        // 初始化 BeanWrapper
        initBeanWrapper(bw);
        return bw;
    }

程式碼很簡單，呼叫 呼叫 Supplier 的 get() 方法，獲得一個 bean 實體物件，然後根據該實體物件構造一個 BeanWrapper 物件 bw，最後初始化該物件。有關於 BeanWrapper 後面專門出文講解。

instantiateUsingFactoryMethod()

如果存在工廠方法，則呼叫 instantiateUsingFactoryMethod() 完成 bean 的初始化工作（方法實現比較長，細節比較複雜，各位就硬著頭皮看吧）。

    protected BeanWrapper instantiateUsingFactoryMethod(
            String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
        return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
    }

構造一個 ConstructorResolver 物件，然後呼叫其 instantiateUsingFactoryMethod() 方法。ConstructorResolver 是構造方法或者工廠類初始化 bean 的委託類。

      public BeanWrapper instantiateUsingFactoryMethod(
            final String beanName, final RootBeanDefinition mbd, @Nullable final Object[] explicitArgs) {
        // 構造 BeanWrapperImpl 物件
        BeanWrapperImpl bw = new BeanWrapperImpl();
        // 初始化 BeanWrapperImpl
        // 向BeanWrapper物件中新增 ConversionService 物件和屬性編輯器 PropertyEditor 物件
        //
        this.beanFactory.initBeanWrapper(bw);
        Object factoryBean;
        Class> factoryClass;
        boolean isStatic;
        // 工廠名不為空
        String factoryBeanName = mbd.getFactoryBeanName();
        if (factoryBeanName != null) {
            if (factoryBeanName.equals(beanName)) {
                throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                        "factory-bean reference points back to the same bean definition");
            }
            // 獲取工廠實體
            factoryBean = this.beanFactory.getBean(factoryBeanName);
            if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
                throw new ImplicitlyAppearedSingletonException();
            }
            factoryClass = factoryBean.getClass();
            isStatic = false;
        }
        else {
            // 工廠名為空，則其可能是一個靜態工廠
            // 靜態工廠建立bean，必須要提供工廠的全類名
            if (!mbd.hasBeanClass()) {
                throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                        "bean definition declares neither a bean class nor a factory-bean reference");
            }
            factoryBean = null;
            factoryClass = mbd.getBeanClass();
            isStatic = true;
        }
        // 工廠方法
        Method factoryMethodToUse = null;
        ConstructorResolver.ArgumentsHolder argsHolderToUse = null;
        // 引數
        Object[] argsToUse = null;
        // 工廠方法的引數
        // 如果指定了構造引數則直接使用
        // 在呼叫 getBean 方法的時候指定了方法引數
        if (explicitArgs != null) {
            argsToUse = explicitArgs;
        }
        else {
            // 沒有指定，則嘗試從配置檔案中解析
            Object[] argsToResolve = null;
            // 首先嘗試從快取中獲取
            synchronized (mbd.constructorArgumentLock) {
                // 獲取快取中的建構式或者工廠方法
                factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
                if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
                    // 獲取快取中的構造引數
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        // 獲取快取中的建構式引數的包可見欄位
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }
            // 快取中存在,則解析儲存在 BeanDefinition 中的引數
            // 如給定方法的建構式 A(int ,int )，則透過此方法後就會把配置檔案中的("1","1")轉換為 (1,1)
            // 快取中的值可能是原始值也有可能是最終值
            if (argsToResolve != null) {
                argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
            }
        }
        //
        if (factoryMethodToUse == null || argsToUse == null) {
            // 獲取工廠方法的類全名稱
            factoryClass = ClassUtils.getUserClass(factoryClass);
            // 獲取所有待定方法
            Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
            // 檢索所有方法，這裡是對方法進行過濾
            List<Method> candidateSet = new ArrayList<>();
            for (Method candidate : rawCandidates) {
                // 如果有static 且為工廠方法，則新增到 candidateSet 中
                if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                    candidateSet.add(candidate);
                }
            }
            Method[] candidates = candidateSet.toArray(new Method[0]);
            // 排序建構式
            // public 建構式優先引數數量降序，非public 建構式引數數量降序
            AutowireUtils.sortFactoryMethods(candidates);
            // 用於承載解析後的建構式引數的值
            ConstructorArgumentValues resolvedValues = null;
            boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
            int minTypeDiffWeight = Integer.MAX_VALUE;
            Set<Method> ambiguousFactoryMethods = null;
            int minNrOfArgs;
            if (explicitArgs != null) {
                minNrOfArgs = explicitArgs.length;
            }
            else {
                // getBean() 沒有傳遞引數，則需要解析儲存在 BeanDefinition 建構式中指定的引數
                if (mbd.hasConstructorArgumentValues()) {
                    // 建構式的引數
                    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                    resolvedValues = new ConstructorArgumentValues();
                    // 解析建構式的引數
                    // 將該 bean 的建構式引數解析為 resolvedValues 物件，其中會涉及到其他 bean
                    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
                }
                else {
                    minNrOfArgs = 0;
                }
            }
            LinkedList<UnsatisfiedDependencyException> causes = null;
            for (Method candidate : candidates) {
                // 方法體的引數
                Class>[] paramTypes = candidate.getParameterTypes();
                if (paramTypes.length >= minNrOfArgs) {
                    // 儲存引數的物件
                    ArgumentsHolder argsHolder;
                    // getBean()傳遞了引數
                    if (explicitArgs != null){
                        // 顯示給定引數，引數長度必須完全匹配
                        if (paramTypes.length != explicitArgs.length) {
                            continue;
                        }
                        // 根據引數建立引數持有者
                        argsHolder = new ArgumentsHolder(explicitArgs);
                    }
                    else {
                        // 為提供引數，解析構造引數
                        try {
                            String[] paramNames = null;
                            // 獲取 ParameterNameDiscoverer 物件
                            // ParameterNameDiscoverer 是用於解析方法和建構式的引數名稱的介面，為引數名稱探測器
                            ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                            if (pnd != null) {
                                // 獲取指定建構式的引數名稱
                                paramNames = pnd.getParameterNames(candidate);
                            }
                            // 在已經解析的建構式引數值的情況下，建立一個引數持有者物件
                            argsHolder = createArgumentArray(
                                    beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
                        }
                        catch (UnsatisfiedDependencyException ex) {
                            if (this.beanFactory.logger.isTraceEnabled()) {
                                this.beanFactory.logger.trace("Ignoring factory method [" + candidate +
                                        "] of bean '" + beanName + "': " + ex);
                            }
                            if (causes == null) {
                                causes = new LinkedList<>();
                            }
                            causes.add(ex);
                            continue;
                        }
                    }
                    // isLenientConstructorResolution 判斷解析建構式的時候是否以寬鬆樣式還是嚴格樣式
                    // 嚴格樣式：解析建構式時，必須所有的都需要匹配，否則丟擲異常
                    // 寬鬆樣式：使用具有"最接近的樣式"進行匹配
                    // typeDiffWeight：型別差異權重
                    int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                            argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                    // 代表最接近的型別匹配，則選擇作為建構式
                    if (typeDiffWeight < minTypeDiffWeight) {
                        factoryMethodToUse = candidate;
                        argsHolderToUse = argsHolder;
                        argsToUse = argsHolder.arguments;
                        minTypeDiffWeight = typeDiffWeight;
                        ambiguousFactoryMethods = null;
                    }
                    // 如果具有相同引數數量的方法具有相同的型別差異權重，則收集此型別選項
                    // 但是，僅在非寬鬆建構式解析樣式下執行該檢查，並顯式忽略重寫方法（具有相同的引數簽名）
                    else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
                            !mbd.isLenientConstructorResolution() &&
                            paramTypes.length == factoryMethodToUse.getParameterCount() &&
                            !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                        // 查詢到多個可匹配的方法
                        if (ambiguousFactoryMethods == null) {
                            ambiguousFactoryMethods = new LinkedHashSet<>();
                            ambiguousFactoryMethods.add(factoryMethodToUse);
                        }
                        ambiguousFactoryMethods.add(candidate);
                    }
                }
            }
            // 沒有可執行的工廠方法，丟擲異常
            if (factoryMethodToUse == null) {
                if (causes != null) {
                    UnsatisfiedDependencyException ex = causes.removeLast();
                    for (Exception cause : causes) {
                        this.beanFactory.onSuppressedException(cause);
                    }
                    throw ex;
                }
                List<String> argTypes = new ArrayList<>(minNrOfArgs);
                if (explicitArgs != null) {
                    for (Object arg : explicitArgs) {
                        argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
                    }
                }
                else if (resolvedValues != null){
                    Set<ConstructorArgumentValues.ValueHolder> valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
                    valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
                    valueHolders.addAll(resolvedValues.getGenericArgumentValues());
                    for (ConstructorArgumentValues.ValueHolder value : valueHolders) {
                        String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
                                (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
                        argTypes.add(argType);
                    }
                }
                String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "No matching factory method found: " +
                                (mbd.getFactoryBeanName() != null ?
                                        "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
                                "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
                                "Check that a method with the specified name " +
                                (minNrOfArgs > 0 ? "and arguments " : "") +
                                "exists and that it is " +
                                (isStatic ? "static" : "non-static") + ".");
            }
            else if (void.class == factoryMethodToUse.getReturnType()) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Invalid factory method '" + mbd.getFactoryMethodName() +
                                "': needs to have a non-void return type!");
            }
            else if (ambiguousFactoryMethods != null) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Ambiguous factory method matches found in bean '" + beanName + "' " +
                                "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                                ambiguousFactoryMethods);
            }
            if (explicitArgs == null && argsHolderToUse != null) {
                // 將解析的建構式加入快取
                argsHolderToUse.storeCache(mbd, factoryMethodToUse);
            }
        }
        try {
            // 實體化 bean
            Object beanInstance;
            if (System.getSecurityManager() != null) {
                final Object fb = factoryBean;
                final Method factoryMethod = factoryMethodToUse;
                final Object[] args = argsToUse;
                // 透過執行工廠方法來建立bean示例
                beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
                                beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, fb, factoryMethod, args),
                        beanFactory.getAccessControlContext());
            }
            else {
                // 透過執行工廠方法來建立bean示例
                beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
                        mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);
            }
            // 包裝為 BeanWraper 物件
            bw.setBeanInstance(beanInstance);
            return bw;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean instantiation via factory method failed", ex);
        }
    }

instantiateUsingFactoryMethod() 方法體實在是太大了，處理細節感覺很複雜，LZ是硬著頭皮看完的，中間斷斷續續的。吐槽這裡的程式碼風格，完全不符合我們前面看的 Spring 程式碼風格。Spring 的一貫做法是將一個複雜邏輯進行拆分，分為多個細小的模組進行巢狀，每個模組負責一部分功能，模組與模組之間層層巢狀，上一層一般都是對下一層的總結和概括，這樣就會使得每一層的邏輯變得清晰易懂。

回歸到上面的方法體，雖然程式碼體量大，但是總體我們還是可看清楚這個方法要做的事情。一句話概括就是：確定工廠物件，然後獲取建構式和構造引數，最後呼叫 InstantiationStrategy 物件的 instantiate() 來建立 bean 實體。下麵我們就這個句概括的話進行拆分並詳細說明。

確定工廠物件

首先獲取工廠方法名，若工廠方法名不為空，則呼叫 beanFactory.getBean() 獲取工廠物件，若為空，則可能為一個靜態工廠，對於靜態工廠則必須提供工廠類的全類名，同時設定 factoryBean=null

構造引數確認

工廠物件確定後，則是確認構造引數。構造引數的確認主要分為三種情況：explicitArgs 引數、快取中獲取、配置檔案中解析。

explicitArgs 引數

explicitArgs 引數是我們呼叫 getBean() 時傳遞景來，一般該引數，該引數就是用於初始化 bean 時所傳遞的引數，如果該引數不為空，則可以確定建構式的引數就是它了。

快取中獲取

在該方法的最後，我們會發現這樣一段程式碼： argsHolderToUse.storeCache(mbd,factoryMethodToUse) ，這段程式碼主要是將建構式、構造引數儲存到快取中，如下：

        public void storeCache(RootBeanDefinition mbd, Executable constructorOrFactoryMethod) {
            synchronized (mbd.constructorArgumentLock) {
                mbd.resolvedConstructorOrFactoryMethod = constructorOrFactoryMethod;
                mbd.constructorArgumentsResolved = true;
                if (this.resolveNecessary) {
                    mbd.preparedConstructorArguments = this.preparedArguments;
                }
                else {
                    mbd.resolvedConstructorArguments = this.arguments;
                }
            }
        }

其中涉及到的幾個引數 constructorArgumentLock、resolvedConstructorOrFactoryMethod、constructorArgumentsResolved、resolvedConstructorArguments。這些引數都是跟建構式、建構式快取有關的。

• constructorArgumentLock：建構式的快取鎖

• resolvedConstructorOrFactoryMethod：快取已經解析的建構式或者工廠方法

• constructorArgumentsResolved：標記欄位，標記建構式、引數已經解析了。預設為false

• resolvedConstructorArguments：快取已經解析的建構式引數，包可見欄位

所以從快取中獲取就是提取這幾個引數的值，如下：

            synchronized (mbd.constructorArgumentLock) {
                // 獲取快取中的建構式或者工廠方法
                factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
                if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
                    // 獲取快取中的構造引數
                    argsToUse = mbd.resolvedConstructorArguments;
                    if (argsToUse == null) {
                        // 獲取快取中的建構式引數的包可見欄位
                        argsToResolve = mbd.preparedConstructorArguments;
                    }
                }
            }

如果快取中存在構造引數，則需要呼叫 resolvePreparedArguments() 方法進行轉換，因為快取中的值有可能是最終值也有可能不是最終值，比如我們建構式中的型別為 Integer 型別的 1 ，但是原始的引數型別有可能是 String 型別的 1 ，所以即便是從快取中得到了構造引數也需要經過一番的型別轉換確保引數型別完全對應。

配置檔案中解析

即沒有透過傳遞引數的方式傳遞構造引數，快取中也沒有，那就只能透過解析配置檔案獲取構造引數了。

在 bean 解析類的博文中我們瞭解了，配置檔案中的資訊都會轉換到 BeanDefinition 實體物件中，所以配置檔案中的引數可以直接透過 BeanDefinition 物件獲取。程式碼如下：

if (mbd.hasConstructorArgumentValues()) {
    // 建構式的引數
    ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
    resolvedValues = new ConstructorArgumentValues();
    // 解析建構式的引數
    // 將該 bean 的建構式引數解析為 resolvedValues 物件，其中會涉及到其他 bean
    minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
}

透過 BeanDefinition 的 getConstructorArgumentValues() 就可以獲取構造資訊了，有了構造資訊就可以獲取相關的引數值資訊了，獲取的引數資訊包括直接值和取用，這一步驟的處理交由 resolveConstructorArguments()完成，該方法會將構造引數資訊解析為 resolvedValues 物件 並傳回解析到的引數個數。

建構式

確定構造引數後，下一步則是確定建構式。第一步則是透過 getCandidateMethods() 獲取所有的構造方法，同時對構造方法進行刷選，然後在對其進行排序處理（ AutowireUtils.sortFactoryMethods(candidates)），排序的主要目的是為了能夠更加方便的找到匹配的建構式，因為建構式的確認是根據引數個數確認的。排序的規則是：public 建構式優先引數數量降序、非 public 構造引數數量降序。

透過迭代 candidates（包含了所有要匹配的建構式）的方式，一次比較其引數，如果顯示提供了引數（explicitArgs != null），則直接比較兩者是否相等，如果相等則表示找到了，否則繼續比較。如果沒有顯示提供引數，則需要獲取 ParameterNameDiscoverer 物件，該物件為引數名稱探測器，主要用於發現方法和建構式的引數名稱。

將引數包裝成 ArgumentsHolder 物件，該物件用於儲存引數，我們稱之為引數持有者。當將物件包裝成 ArgumentsHolder 物件後，我們就可以透過它來進行建構式匹配，匹配分為嚴格樣式和寬鬆樣式。

• 嚴格樣式：解析建構式時，必須所有引數都需要匹配，否則丟擲異常

• 寬鬆樣式：使用具有"最接近的樣式"進行匹配

判斷的依據是根據 BeanDefinition 的 isLenientConstructorResolution 屬性（該引數是我們在構造 AbstractBeanDefinition 物件是傳遞的）來獲取型別差異權重（typeDiffWeight） 的。如果 typeDiffWeight<minTypeDiffWeight ，則代表“最接近的樣式”，選擇其作為建構式，否則只有兩者具有相同的引數數量且型別差異權重相等才會納入考慮範圍。

至此，建構式已經確認了。

建立 bean 實體

工廠物件、建構式、構造引數都已經確認了，則最後一步就是呼叫 InstantiationStrategy 物件的 instantiate() 來建立 bean 實體，如下：

public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
            @Nullable Object factoryBean, final Method factoryMethod, @Nullable Object... args) {
        try {
            if (System.getSecurityManager() != null) {
                AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
                    ReflectionUtils.makeAccessible(factoryMethod);
                    return null;
                });
            }
            else {
                ReflectionUtils.makeAccessible(factoryMethod);
            }
            Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
            try {
                currentlyInvokedFactoryMethod.set(factoryMethod);
                // 執行工廠方法，並傳回實體
                Object result = factoryMethod.invoke(factoryBean, args);
                if (result == null) {
                    result = new NullBean();
                }
                return result;
            }
            finally {
                if (priorInvokedFactoryMethod != null) {
                    currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
                }
                else {
                    currentlyInvokedFactoryMethod.remove();
                }
            }
        }
        // 省略一波 catch
    }

instantiate() 最核心的部分就是利用 Java 反射執行工廠方法並傳回建立好的實體，也就是這段程式碼：

Object result = factoryMethod.invoke(factoryBean, args);

到這裡 instantiateUsingFactoryMethod() 已經分析完畢了，這裡 LZ 有些題外話需要說下，看原始碼真心是一個痛苦的過程，尤其是複雜的原始碼，比如這個方法我看了三天才弄清楚點皮毛，當然這裡跟 LZ 的智商有些關係（智商捉急 ┭┮﹏┭┮），寫這篇部落格也花了五天時間才寫完（最後截稿日為：2018.08.10 01:23:49），所以每一個堅持寫部落格的都是折翼的天使，值得各位尊敬

createBeanInstance() 還有兩個重要方法 autowireConstructor() 和 instantiateBean() ,由於篇幅問題，所以將這兩個方法放在下篇部落格分析。敬請期待!!!

往

期

精

彩

【死磕 Spring】----- IOC 之分析各 scope 的 bean 建立

【死磕 Spring】----- IOC 之開啟 bean 的載入

【死磕 Spring】----- IOC 之從單例快取中獲取單例 bean

【死磕 Spring】----- IOC 之parentBeanFactory 與依賴處理

【死磕 Spring】----- IOC 之 IOC 初始化總結

END

>>>>>> 加群交流技術 <<<<<<

長按二維碼向我轉賬

受蘋果公司新規定影響，微信 iOS 版的贊賞功能被關閉，可透過二維碼轉賬支援公眾號。

閱讀原文


微信掃一掃
使用小程式
即將開啟""小程式
取消
開啟