Spring源碼二十一：Bean實例化流程四

上一篇Spring源碼二十：Bean實例化流程三中，我們主要討論了單例Bean創建對象的主要方法getSingleton的內部方法createBean，createBean方法中的resolveBeanClase方法與prepareMethodOverrides方法處理了lookup-method屬性與repliace-method配置屬性。重點討論了resolveBeforeInstantiation，看了Spring為我們提供的兩個擴展方法。最后我們找到了正常創建bena的方法，doCreateBean。

今天開始進入doCreateBean中一探究竟：

doCreateBean

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.// 實例化這個beanBeanWrapper instanceWrapper = null;if (mbd.isSingleton()) {// 如果是單例，則從factoryBeanInstanceCache獲取一個FactoryBeanWrapper對象，// 默認情況是單且factoryBeanInstanceCache為空，所以instanceWrapper還是 = nullinstanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}// 創建BeanWrapper實例對象：默認情況都是空，所以肯定會走這里if (instanceWrapper == null) {instanceWrapper = createBeanInstance(beanName, mbd, args);}// 獲取實例化對象final Object bean = instanceWrapper.getWrappedInstance();// 獲取實例化對象類型Class<?> beanType = instanceWrapper.getWrappedClass();if (beanType != NullBean.class) {mbd.resolvedTargetType = beanType;}// Allow post-processors to modify the merged bean definition.// 允許后置處理器修改beanDefinitionsynchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}catch (Throwable ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Post-processing of merged bean definition failed", ex);}mbd.postProcessed = true;}}// Eagerly cache singletons to be able to resolve circular references// even when triggered by lifecycle interfaces like BeanFactoryAware.boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&isSingletonCurrentlyInCreation(beanName));if (earlySingletonExposure) {if (logger.isTraceEnabled()) {logger.trace("Eagerly caching bean '" + beanName +"' to allow for resolving potential circular references");}addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));}// Initialize the bean instance. bean對象的初始化、DI在此出發// 這個exposed的對象，Object exposedObject = bean;try {populateBean(beanName, mbd, instanceWrapper);exposedObject = initializeBean(beanName, exposedObject, mbd);}catch (Throwable ex) {if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {throw (BeanCreationException) ex;}else {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);}}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);}}if (!actualDependentBeans.isEmpty()) {throw new BeanCurrentlyInCreationException(beanName,"Bean with name '" + beanName + "' has been injected into other beans [" +StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +"] in its raw version as part of a circular reference, but has eventually been " +"wrapped. This means that said other beans do not use the final version of the " +"bean. This is often the result of over-eager type matching - consider using " +"'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");}}}}// Register bean as disposable.try {registerDisposableBeanIfNecessary(beanName, bean, mbd);}catch (BeanDefinitionValidationException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);}return exposedObject;}

首先回去BeanFactory的緩存中獲取Bean Wrapper對象，默認沒有所以肯定會走到createBeanInstance方法中，我們進入方法內部看下。

createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {// Make sure bean class is actually resolved at this point.// 在此調用resolveBeanClass方法，解析BeanDefinition中的class ，確保現在bean的class已經被解析好了Class<?> beanClass = resolveBeanClass(mbd, beanName);// 這里對class進行校驗，主要是反射需要用的到的屬性：// 如果類不是public修飾的，并且不能通過反射訪問 提前拋出異常if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());}Supplier<?> instanceSupplier = mbd.getInstanceSupplier();if (instanceSupplier != null) {return obtainFromSupplier(instanceSupplier, beanName);}// 如果屬性factory-method不為空，則通過配置好的工廠方法來實例化bean// 這里為Spring 提供了通過工廠方法來實例化Beanif (mbd.getFactoryMethodName() != null) {return instantiateUsingFactoryMethod(beanName, mbd, args);}// Shortcut when re-creating the same bean...boolean resolved = false;boolean autowireNecessary = false;// 參數為空時處理if (args == null) {synchronized (mbd.constructorArgumentLock) {if (mbd.resolvedConstructorOrFactoryMethod != null) {resolved = true;autowireNecessary = mbd.constructorArgumentsResolved;}}}if (resolved) {if (autowireNecessary) {return autowireConstructor(beanName, mbd, null, null);}else {return instantiateBean(beanName, mbd);}}// Candidate constructors for autowiring?Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {return autowireConstructor(beanName, mbd, ctors, args);}// Preferred constructors for default construction?ctors = mbd.getPreferredConstructors();if (ctors != null) {return autowireConstructor(beanName, mbd, ctors, null);}// No special handling: simply use no-arg constructor.return instantiateBean(beanName, mbd);}

上述代碼注釋基本上都解釋了一遍，咱們簡單總結下：

類解析和校驗：首先解析bean的類，并進行訪問權限校驗。這一步確保了后續操作的前提條件都已經滿足。

實例供應商檢查：如果定義了實例供應商，則通過供應商創建實例。這種方式提供了高度的靈活性，使得實例的創建可以由外部邏輯控制。一般不做擴展，故不做具體分析

工廠方法實例化：如果定義了工廠方法，則通過工廠方法創建實例。工廠方法模式是一種常見的設計模式，能夠靈活地創建對象。這塊我們等會進去看下。主要還是Spring給我們提供了一種實例化方式，等會舉例說明。

構造函數解析和自動裝配：解析候選的構造函數并進行自動裝配。這種方式適用于需要依賴注入的場景，確保bean的依賴能夠被正確地解析和注入。

默認實例化：如果沒有特殊的創建需求，則使用無參構造函數進行實例化。這種方式簡單直接，適用于大多數情況。

這段代碼體現了Spring框架在設計和實現上的許多優秀思想和實踐。通過靈活的實例化策略、嚴格的前置校驗、線程安全處理、性能優化以及分層設計，Spring框架能夠高效、穩定地處理復雜的bean創建需求。這些設計思想和實踐對于任何大型軟件系統的設計和實現都有重要的借鑒意義。

工廠方法來實例化Bean

有兩種方式來定義，主要是靜態方法與普通方法，下面咱們來看下代碼：

package org.springframework.factory;import org.springframework.dto.JmUser;/*** @author Jeremy* @version 1.0* @description: 測試FactoryMethod方法* @date 2024/7/10 16:56*/
public class JmUserFactory {public static JmUser getObject(){JmUser jmUser = new JmUser();jmUser.setName("JmUserFactory");jmUser.setAge("1");return 	jmUser;}public JmUser getJmUser(){JmUser jmUser = new JmUser();jmUser.setName("JmUserFactoryNoStatic");jmUser.setAge("2");return 	jmUser;}}package org.springframework.dto;/*** @author Jeremy* @version 1.0* @description: 實體類* @date 2024/6/30 03:02*/
public class JmUser {private String name;private String age;private String systemOs;public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}
}

<!--factory-method 靜態方法--><bean id="jmUserFactory" class="org.springframework.factory.JmUserFactory" factory-method="getObject"></bean><!--factory-method 非靜態方法--><bean id="jmUserFactoryNoStatic" class="org.springframework.factory.JmUserFactory" ></bean><bean id="jmCreateUser" factory-bean="jmUserFactoryNoStatic" factory-method="getJmUser"  ></bean>

可以看到此時會我們在xml中設置的factory-method方法會set到BeanDefinitionfactoryMethodName中，這里通過getFactoryMethodName方法獲取屬性值，如果有值則進入factoryMethod方法內部進行實例化。

instantiateUsingFactoryMethod

代碼比較長，我大家可以自己去代碼里看，我這里就截取核心內容出來。

Spring 框架中用于通過工廠方法實例化 bean 的方法。無論是 bean 類上的靜態工廠方法，還是其他工廠 bean 上的方法，都是通過這個方法來處理的。以下是該方法的概述和關鍵部分的解釋：

instantiateUsingFactoryMethod 方法旨在使用指定的工廠方法創建 bean 的新實例。它通過解析適當的方法、準備必要的參數，然后調用該方法來創建 bean。

BeanWrapper 初始化:


BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);

這里創建了一個 BeanWrapperImpl 實例并進行初始化，BeanWrapper 用于包裝 bean 對象并提供對其屬性的操作。

獲取工廠 bean 和工廠類:


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 {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;
}

這里獲取工廠 bean 和工廠類。如果指定了工廠 bean 名稱，則獲取該工廠 bean 實例及其類；如果沒有指定工廠 bean 名稱，則使用 bean 類上的靜態工廠方法。

解析工廠方法和參數:


Method factoryMethodToUse = null;
ArgumentsHolder argsHolderToUse = null;
Object[] argsToUse = null;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;}}}if (argsToResolve != null) {argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve, true);}
}

這里解析工廠方法和參數。如果有顯式參數，則直接使用；否則，從 bean 定義中解析參數。

確定工廠方法:


if (factoryMethodToUse == null || argsToUse == null) {factoryClass = ClassUtils.getUserClass(factoryClass);List<Method> candidates = null;if (mbd.isFactoryMethodUnique) {if (factoryMethodToUse == null) {factoryMethodToUse = mbd.getResolvedFactoryMethod();}if (factoryMethodToUse != null) {candidates = Collections.singletonList(factoryMethodToUse);}}if (candidates == null) {candidates = new ArrayList<>();Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);for (Method candidate : rawCandidates) {if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {candidates.add(candidate);}}}...
}

這里嘗試確定具體的工廠方法。首先檢查是否有緩存的工廠方法，然后嘗試從工廠類的所有方法中找到匹配的方法。

實例化 bean:


bw.setBeanInstance(instantiate(beanName, mbd, factoryBean, factoryMethodToUse, argsToUse));
return bw;

最后，通過解析得到的工廠方法和參數來實例化 bean，并將其包裝在 BeanWrapper 中返回。

總結下：就是判斷一下當前是通過靜態工廠方法，還是通過實例工廠方法來實例化bean的實例。剩下復雜的錯都通過反射實例化bean的過程。

小結

今天咱們主要分析里createBeanInstance方法Spring給我們提供給的FactoryMethod方法，舉例說明了factoryMethod屬性如何使用，同時簡單討論了具體實現邏輯。下一節咱們將進入反射實例化Bean。