接着上文，說到關於createBean，在上節的doGetBean 9.1.1、9.2.2、9.3.4三次調用了createBean，篇幅原因，適當去掉一些異常的處理
1.createBean
@Override
protected Object createBean(String beanName,
RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isTraceEnabled()) {
logger.trace("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// Make sure bean class is actually resolved at this point, and
// clone the bean definition in case of a dynamically resolved Class
// which cannot be stored in the shared merged bean definition.
// 1.解析beanName對應的Bean的類型
// 確保此時已經解析了bean類，如果動態解析的類不能存儲在共享合併bean定義中，則克隆bean定義。
// 做各種各樣的屬性值的賦值,
// 比如這種 通過Spring的Bean傳遞給Spring框架的值 ==> bd.setPropertyValue("aaa")
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass()
&& mbd.getBeanClassName() != null) {
// 如果resolvedClass存在，並且mdb的beanClass類型不是Class，
// 並且mdb的beanClass不爲空（則代表beanClass存的是Class的name）,
// 則使用mdb深拷貝一個新的RootBeanDefinition副本，
// 並且將解析的Class賦值給拷貝的RootBeanDefinition副本的beanClass屬性，
// 該拷貝副本取代mdb用於後續的操作
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 處理 lookup-method 和 replace-method 配置，Spring
// 將這兩個配置統稱爲 override method
// 2.驗證及準備覆蓋的方法（對override屬性進行標記及驗證）
mbdToUse.prepareMethodOverrides();
// 3.實例化前的處理，給InstantiationAwareBeanPostProcessor
// 一個機會返回代理對象來替代真正的bean實例，
// 達到“短路”效果
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 4.如果bean不爲空，則會跳過Spring默認的實例化過程，直接使用返回的bean
if (bean != null) {
return bean;
}
// 5.創建Bean實例（真正創建Bean的方法）
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isTraceEnabled()) {
logger.trace("Finished creating instance of bean '" + beanName + "'");
}
// 6.返回創建的Bean實例
return beanInstance;
}
2. resolveBeforeInstantiation
在實例化之前執行 InstantiationAwareBeanPostProcessor 的 postProcessBeforeInstantiation 方法，該方法可以返回 bean 實例的代理，從而跳過 Spring 默認的實例化過程。
@Nullable
protected Object resolveBeforeInstantiation(String beanName,
RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
// 1.mbd不是合成的，並且BeanFactory中存在InstantiationAwareBeanPostProcessor
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
// 2.解析beanName對應的Bean實例的類型
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
// 3.實例化前的後置處理器應用（處理InstantiationAwareBeanPostProcessor）
bean = applyBeanPostProcessorsBeforeInstantiation(targetType,
beanName);
if (bean != null) {
// 4.如果返回的bean不爲空，會跳過Spring默認的實例化過程，
// 所以只能在這裏調用BeanPostProcessor實現類的
// postProcessAfterInitialization方法
bean = applyBeanPostProcessorsAfterInitialization(bean,
beanName);
}
}
}
// 5.如果bean不爲空，則將beforeInstantiationResolved賦值爲true，
// 代表在實例化之前已經解析
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}
protected Object applyBeanPostProcessorsBeforeInstantiation(
Class<?> beanClass, String beanName) {
// 1.遍歷當前BeanFactory中的BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 2.應用InstantiationAwareBeanPostProcessor後置處理器，
// 允許postProcessBeforeInstantiation方法返回bean對象的代理
if (bp instanceof InstantiationAwareBeanPostProcessor) {
// 3.執行postProcessBeforeInstantiation方法，在Bean實例化前操作，
// 該方法可以返回一個構造完成的Bean實例，
// 從而不會繼續執行創建Bean實例的“正規的流程”，達到“短路”的效果。
InstantiationAwareBeanPostProcessor ibp =
(InstantiationAwareBeanPostProcessor) bp;
Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
if (result != null) {
// 4.如果result不爲空，也就是有後置處理器返回了bean實例對象，
// 則會跳過Spring默認的實例化過程
return result;
}
}
}
return null;
}
3. doCreateBean
protected Object doCreateBean(final String beanName,
final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// Instantiate the bean.
// 1. 新建Bean包裝類
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
// 2.如果是FactoryBean，則需要先移除未完成的FactoryBean實例的緩存
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
/*
* 3.根據beanName、mbd、args，使用對應的策略創建Bean實例，並返回包裝類BeanWrapper
* 創建 bean 實例，並將實例包裹在 BeanWrapper 實現類對象中返回。
* createBeanInstance中包含三種創建 bean 實例的方式：
* 1. 通過工廠方法創建 bean 實例
* 2. 通過構造方法自動注入（autowire by constructor）的方式創建 bean 實例
* 3. 通過無參構造方法方法創建 bean 實例
*
* 若bean的配置信息中配置了lookup-method 和replace-method，
* 則會使用CGLIB增強bean實例。
* 關於lookup-method和replace-method後面再說。
*/
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 4. 拿到創建好的Bean實例
final Object bean = instanceWrapper.getWrappedInstance();
// 5. 拿到Bean實例類型
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 {
// 6.應用後置處理器MergedBeanDefinitionPostProcessor，
// 允許修改MergedBeanDefinition，
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.
// 7.判斷是否需要提早曝光實例：單例 && 允許循環依賴 && 當前bean正在創建中
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");
}
// 8.提前曝光beanName的ObjectFactory，用於解決循環引用
// 8.1 應用後置處理器SmartInstantiationAwareBeanPostProcessor，
// 允許返回指定bean的早期引用，若沒有則直接返回bean
addSingletonFactory(beanName, ()
-> getEarlyBeanReference(beanName, mbd, bean));
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 9.對bean進行屬性填充；
// 其中，可能存在依賴於其他bean的屬性，則會遞歸初始化依賴的bean實例
populateBean(beanName, mbd, instanceWrapper);
// 執行後置處理器，aop就是在這裏完成的
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);
}
}
// 11.如果允許提前曝光實例，則進行循環依賴檢查
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
// 11.1 earlySingletonReference只有在當前解析的bean存在循環依賴的情況下才會不爲空
if (earlySingletonReference != null) {
if (exposedObject == bean) {
// 11.2 如果exposedObject沒有在initializeBean
// 方法中被增強，則不影響之前的循環引用
exposedObject = earlySingletonReference;
}
// 11.3 如果exposedObject在initializeBean方法中被增強 &&
// 不允許在循環引用的情況下使用注入原始bean實例 &&
// 當前bean有被其他bean依賴
else if (!this.allowRawInjectionDespiteWrapping &&
hasDependentBean(beanName)) {
// 11.4 拿到依賴當前bean的所有bean的beanName數組
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans =
new LinkedHashSet<>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
// 11.5 嘗試移除這些bean的實例，
// 因爲這些bean依賴的bean已經被增強了，他們依賴的bean相當於髒數據
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
// 11.6 移除失敗的添加到 actualDependentBeans
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
// 11.7 如果存在移除失敗的，則拋出異常，因爲存在bean依賴了“髒數據”
throw new BeanCurrentlyInCreationException(beanName);
}
}
}
}
// Register bean as disposable.
try {
// 12.註冊用於銷燬的bean，執行銷燬操作的有三種：
// 自定義destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName,
"Invalid destruction signature", ex);
}
// 13.完成創建並返回
return exposedObject;
}
4：createBeanInstance
protected BeanWrapper createBeanInstance(String beanName,
RootBeanDefinition mbd, @Nullable Object[] args) {
// Make sure bean class is actually resolved at this point.
// 解析bean的類型
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 檢測一個類的訪問權限spring默認情況下對於非public的類是不允許訪問的。
// beanClass不爲空 && beanClass不是公開類（不是public修飾）&&
// 該bean不允許訪問非公共構造函數和方法，則拋異常
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) {
// 如果存在Supplier回調，則使用給定的回調方法初始化策略
return obtainFromSupplier(instanceSupplier, beanName);
}
// 如果工廠方法不爲空，則通過工廠方法構建 bean 對象
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
/*
* resolved: 構造函數或工廠方法是否已經解析過
* 多次創建同一個Bean的時候，可以用這個Shortcut，不用每次推斷用那種方式構造bean
* resolved和constructorArgumentsResolved會在bean第一次實例化被設置
*/
boolean resolved = false;
// autowireNecessary: 是否需要自動注入（即是否需要解析構造函數參數）
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
// 2.1 如果resolvedConstructorOrFactoryMethod緩存不爲空，
// 則將resolved標記爲已解析
resolved = true;
// 2.2 根據constructorArgumentsResolved判斷是否需要自動注入
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
if (resolved) {
// 3.如果已經解析過，則使用
// resolvedConstructorOrFactoryMethod緩存裏解析好的構造函數方法
if (autowireNecessary) {
// 3.1 需要自動注入，則執行構造函數自動注入
// 通過構造方法自動裝備的方式構造Bean對象
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 3.2 否則使用默認的構造函數進行bean的實例化
// 如果已經解析了構造方法的參數，則必須要通過一個帶參構造方法來實例
return instantiateBean(beanName, mbd);
}
}
// 4.應用後置處理器SmartInstantiationAwareBeanPostProcessor，
// 拿到bean的候選構造函數
// 由後置處理器決定返回那些構造方法
// Candidate constructors for autowiring?
Constructor<?>[] ctors =
determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() ||
!ObjectUtils.isEmpty(args)) {
// 5.如果ctors不爲空 ||
// mbd的注入方式爲AUTOWIRE_CONSTRUCTOR ||
// mdb定義了構造函數的參數值 ||
// 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);
}
5：createBeanInstance
調用 SmartInstantiationAwareBeanPostProcessor 的 determineCandidateConstructors 方法，該方法可以返回要用於 beanClass 的候選構造函數。使用 @Autowire 註解修飾構造函數，則該構造函數在這邊會被 AutowiredAnnotationBeanPostProcessor 找到。
@Nullable
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors
(@Nullable Class<?> beanClass, String beanName)
throws BeansException {
if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
// 1.遍歷所有的BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
// 2.調用SmartInstantiationAwareBeanPostProcessor的
// determineCandidateConstructors方法，
// 該方法可以返回要用於beanClass的候選構造函數
// 例如：使用@Autowire註解修飾構造函數，
// 則該構造函數在這邊會被AutowiredAnnotationBeanPostProcessor找到
SmartInstantiationAwareBeanPostProcessor ibp =
(SmartInstantiationAwareBeanPostProcessor) bp;
Constructor<?>[] ctors = ibp.determineCandidateConstructors(
beanClass, beanName);
if (ctors != null) {
// 3.如果ctors不爲空，則不再繼續執行其他的
// SmartInstantiationAwareBeanPostProcessor
return ctors;
}
}
}
}
return null;
}
6：autowireConstructor
public BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd,
@Nullable Constructor<?>[] chosenCtors, @Nullable Object[] explicitArgs) {
// 定義bean包裝類
BeanWrapperImpl bw = new BeanWrapperImpl();
this.beanFactory.initBeanWrapper(bw);
// 最終用於實例化的構造函數
Constructor<?> constructorToUse = null;
// 最終用於實例化的參數Holder
ArgumentsHolder argsHolderToUse = null;
// 最終用於實例化的構造函數參數
Object[] argsToUse = null;
// 1.解析出要用於實例化的構造函數參數
if (explicitArgs != null) {
// 1.1 如果explicitArgs不爲空，則構造函數的參數直接使用explicitArgs
// 通過getBean方法調用時，顯示指定了參數，則explicitArgs就不爲null
argsToUse = explicitArgs;
}
else {
// 1.2 嘗試從緩存中獲取已經解析過的構造函數參數
Object[] argsToResolve = null;
// 1.2.1 拿到緩存中已解析的構造函數或工廠方法
synchronized (mbd.constructorArgumentLock) {
constructorToUse = (Constructor<?>) mbd.resolvedConstructorOrFactoryMethod;
if (constructorToUse != null && mbd.constructorArgumentsResolved) {
// Found a cached constructor...
// 1.2.3 從緩存中獲取已解析的構造函數參數
argsToUse = mbd.resolvedConstructorArguments;
if (argsToUse == null) {
// 1.2.4 如果resolvedConstructorArguments爲空，則從緩存中獲取準備用於解析的構造函數參數，
// constructorArgumentsResolved爲true時，resolvedConstructorArguments和
// preparedConstructorArguments必然有一個緩存了構造函數的參數
argsToResolve = mbd.preparedConstructorArguments;
}
}
}
if (argsToResolve != null) {
// 1.2.5 如果argsToResolve不爲空，則對構造函數參數進行解析，
// 如給定方法的構造函數 A(int,int)則通過此方法後就會把配置中的("1","1")轉換爲(1,1)
argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve, true);
}
}
// 2.如果構造函數沒有被緩存，則通過配置文件獲取
if (constructorToUse == null || argsToUse == null) {
// Take specified constructors, if any.
// 2.確認構造函數的候選者
// Take specified constructors, if any.
// 2.1 如果入參chosenCtors不爲空，則將chosenCtors的構造函數作爲候選者
Constructor<?>[] candidates = chosenCtors;
if (candidates == null) {
Class<?> beanClass = mbd.getBeanClass();
try {
// 2.2 如果入參chosenCtors爲空，則獲取beanClass的構造函數
// （mbd是否允許訪問非公共構造函數和方法 ? 所有聲明的構造函數：公共構造函數）
candidates = (mbd.isNonPublicAccessAllowed() ?
beanClass.getDeclaredConstructors() : beanClass.getConstructors());
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Resolution of declared constructors on bean Class [" + beanClass.getName() +
"] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
}
}
if (candidates.length == 1 && explicitArgs == null && !mbd.hasConstructorArgumentValues()) {
Constructor<?> uniqueCandidate = candidates[0];
if (uniqueCandidate.getParameterCount() == 0) {
synchronized (mbd.constructorArgumentLock) {
mbd.resolvedConstructorOrFactoryMethod = uniqueCandidate;
mbd.constructorArgumentsResolved = true;
mbd.resolvedConstructorArguments = EMPTY_ARGS;
}
bw.setBeanInstance(instantiate(beanName, mbd, uniqueCandidate, EMPTY_ARGS));
return bw;
}
}
// Need to resolve the constructor.
// 3 檢查是否需要自動裝配：chosenCtors不爲空 || autowireMode爲AUTOWIRE_CONSTRUCTOR
// 例子：當chosenCtors不爲空時，代表有構造函數通過@Autowire修飾，因此需要自動裝配
boolean autowiring = (chosenCtors != null ||
mbd.getResolvedAutowireMode() == AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR);
ConstructorArgumentValues resolvedValues = null;
// 構造函數參數個數
int minNrOfArgs;
if (explicitArgs != null) {
// 3.2 explicitArgs不爲空，則使用explicitArgs的length作爲minNrOfArgs的值
minNrOfArgs = explicitArgs.length;
}
else {
// 主要針對xml解析方式
// 3.3 獲得mbd的構造函數的參數值（indexedArgumentValues：帶index的參數值；genericArgumentValues：通用的參數值）
ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
// 3.4 創建ConstructorArgumentValues對象resolvedValues，用於承載解析後的構造函數參數的值
resolvedValues = new ConstructorArgumentValues();
// 3.5 解析mbd的構造函數的參數，並返回參數個數 參見7解析
minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
// 注：這邊解析mbd中的構造函數參數值，主要是處理我們通過xml方式定義的構造函數注入的參數，
// 但是如果我們是通過@Autowire註解直接修飾構造函數，則mbd是沒有這些參數值的
}
// 3.6 對給定的構造函數排序：先按方法修飾符排序：public排非public前面，再按構造函數參數個數排序：參數多的排前面
AutowireUtils.sortConstructors(candidates);
// 最小匹配權重，權重越小，越接近我們要找的目標構造函數
int minTypeDiffWeight = Integer.MAX_VALUE;
Set<Constructor<?>> ambiguousConstructors = null;
LinkedList<UnsatisfiedDependencyException> causes = null;
// 4.遍歷所有構造函數候選者，找出符合條件的構造函數
for (Constructor<?> candidate : candidates) {
// 4.1 拿到當前遍歷的構造函數的參數類型數組
Class<?>[] paramTypes = candidate.getParameterTypes();
if (constructorToUse != null && argsToUse != null && argsToUse.length > paramTypes.length) {
// Already found greedy constructor that can be satisfied ->
// do not look any further, there are only less greedy constructors left.
// 4.2 如果已經找到滿足的構造函數 && 目標構造函數需要的參數個數大於當前遍歷的構造函數的參數個數則終止，
// 因爲遍歷的構造函數已經排過序，後面不會有更合適的候選者了
break;
}
if (paramTypes.length < minNrOfArgs) {
// 4.3 如果當前遍歷到的構造函數的參數個數小於我們所需的參數個數，則直接跳過該構造函數
continue;
}
ArgumentsHolder argsHolder;
if (resolvedValues != null) {
// 存在參數則根據參數值來匹配參數類型
try {
// 4.4 resolvedValues不爲空，
// 4.4.1 獲取當前遍歷的構造函數的參數名稱
// 4.4.1.1 解析使用ConstructorProperties註解的構造函數參數
String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
if (paramNames == null) {
// 4.4.1.2 獲取參數名稱解析器
ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
if (pnd != null) {
// 4.4.1.3 使用參數名稱解析器獲取當前遍歷的構造函數的參數名稱
paramNames = pnd.getParameterNames(candidate);
}
}
// 4.4.2 創建一個參數數組以調用構造函數或工廠方法，
// 主要是通過參數類型和參數名解析構造函數或工廠方法所需的參數
// （如果參數是其他bean，則會解析依賴的bean）見8
argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
getUserDeclaredConstructor(candidate), autowiring, candidates.length == 1);
}
catch (UnsatisfiedDependencyException ex) {
// 4.4.3 參數匹配失敗，則拋出異常
if (logger.isTraceEnabled()) {
logger.trace("Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
}
// Swallow and try next constructor.
if (causes == null) {
causes = new LinkedList<>();
}
causes.add(ex);
continue;
}
}
else {
// 4.5 resolvedValues爲空，則explicitArgs不爲空，即給出了顯式參數
// Explicit arguments given -> arguments length must match exactly.
// 4.5.1 如果當前遍歷的構造函數參數個數與explicitArgs長度不相同，則跳過該構造函數
// Explicit arguments given -> arguments length must match exactly.
if (paramTypes.length != explicitArgs.length) {
continue;
}
// 4.5.2 使用顯式給出的參數構造ArgumentsHolder
argsHolder = new ArgumentsHolder(explicitArgs);
}
// 4.6 根據mbd的解析構造函數模式（true: 寬鬆模式(默認)，false：嚴格模式），
// 將argsHolder的參數和paramTypes進行比較，計算paramTypes的類型差異權重值
int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
// Choose this constructor if it represents the closest match.
// 4.7 類型差異權重值越小,則說明構造函數越匹配，則選擇此構造函數
if (typeDiffWeight < minTypeDiffWeight) {
// 將要使用的參數都替換成差異權重值更小的
constructorToUse = candidate;
argsHolderToUse = argsHolder;
argsToUse = argsHolder.arguments;
minTypeDiffWeight = typeDiffWeight;
// 如果出現權重值更小的候選者，
// 則將ambiguousConstructors清空，
// 允許之前存在權重值相同的候選者
ambiguousConstructors = null;
}
// 4.8 如果存在兩個候選者的權重值相同，並且是當前遍歷過權重值最小的
else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
// 將這兩個候選者都添加到ambiguousConstructors
if (ambiguousConstructors == null) {
ambiguousConstructors = new LinkedHashSet<>();
ambiguousConstructors.add(constructorToUse);
}
ambiguousConstructors.add(candidate);
}
}
if (constructorToUse == null) {
// 5.如果最終沒有找到匹配的構造函數，則進行異常處理
if (causes != null) {
UnsatisfiedDependencyException ex = causes.removeLast();
for (Exception cause : causes) {
this.beanFactory.onSuppressedException(cause);
}
throw ex;
}
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Could not resolve matching constructor " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
}
else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
// 6.如果找到了匹配的構造函數，但是存在多個（ambiguousConstructors不爲空） && 解析構造函數的模式爲嚴格模式，則拋出異常
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Ambiguous constructor matches found in bean '" + beanName + "' " +
"(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
ambiguousConstructors);
}
if (explicitArgs == null && argsHolderToUse != null) {
// 7.將解析的構造函數和參數放到緩存
argsHolderToUse.storeCache(mbd, constructorToUse);
}
}
Assert.state(argsToUse != null, "Unresolved constructor arguments");
// 9.將構造的實例加入BeanWrapper中，並返回
bw.setBeanInstance(instantiate(beanName, mbd, constructorToUse, argsToUse));
return bw;
}
private Object instantiate(
String beanName, RootBeanDefinition mbd, Constructor<?> constructorToUse, Object[] argsToUse) {
try {
InstantiationStrategy strategy = this.beanFactory.getInstantiationStrategy();
// 8.根據實例化策略以及得到的構造函數及構造函數參數實例化bean
if (System.getSecurityManager() != null) {
return AccessController.doPrivileged((PrivilegedAction<Object>) () ->
strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse),
this.beanFactory.getAccessControlContext());
}
else {
return strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean instantiation via constructor failed", ex);
}
}
7：resolveConstructorArguments
private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd,
BeanWrapper bw, ConstructorArgumentValues cargs,
ConstructorArgumentValues resolvedValues) {
// 1.構建bean定義值解析器
TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
TypeConverter converter = (customConverter != null ? customConverter : bw);
BeanDefinitionValueResolver valueResolver =
new BeanDefinitionValueResolver(this.beanFactory,
beanName, mbd, converter);
// 2.minNrOfArgs初始化爲indexedArgumentValues和
// genericArgumentValues的的參數個數總和
int minNrOfArgs = cargs.getArgumentCount();
// 3.遍歷解析帶index的參數值
for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry :
cargs.getIndexedArgumentValues().entrySet()) {
int index = entry.getKey();
if (index < 0) {
// index從0開始，不允許小於0
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Invalid constructor argument index: " + index);
}
// 3.1 如果index大於minNrOfArgs，則修改minNrOfArgs
if (index > minNrOfArgs) {
// index是從0開始，並且是有序遞增的，所以當有參數的index=5時，
// 代表該方法至少有6個參數
minNrOfArgs = index + 1;
}
// 3.2 解析參數值
ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue();
if (valueHolder.isConverted()) {
// 3.2.1 如果參數值已經轉換過，則直接將index和valueHolder
// 添加到resolvedValues的indexedArgumentValues屬性
resolvedValues.addIndexedArgumentValue(index, valueHolder);
}
else {
// 3.2.2 如果值還未轉換過，則先進行轉換
Object resolvedValue =
valueResolver.resolveValueIfNecessary("constructor argument",
valueHolder.getValue());
// 3.2.3 使用轉換後的resolvedValue構建新的ValueHolder
ConstructorArgumentValues.ValueHolder resolvedValueHolder =
new ConstructorArgumentValues.ValueHolder(resolvedValue,
valueHolder.getType(), valueHolder.getName());
// 3.2.4 將轉換前的valueHolder保存到新的ValueHolder的source屬性
resolvedValueHolder.setSource(valueHolder);
// 3.2.5 將index和新的ValueHolder添加到
// resolvedValues的indexedArgumentValues屬性
resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder);
}
}
// 4.遍歷解析通用參數值（不帶index）
for (ConstructorArgumentValues.ValueHolder valueHolder :
cargs.getGenericArgumentValues()) {
if (valueHolder.isConverted()) {
// 4.1 如果參數值已經轉換過，則直接將valueHolder添加到
// resolvedValues的genericArgumentValues屬性
resolvedValues.addGenericArgumentValue(valueHolder);
}
else {
// 4.2 如果值還未轉換過，則先進行轉換
Object resolvedValue =
valueResolver.resolveValueIfNecessary("constructor argument",
valueHolder.getValue());
// 4.3 使用轉換後的resolvedValue構建新的ValueHolder
ConstructorArgumentValues.ValueHolder resolvedValueHolder =
new ConstructorArgumentValues.ValueHolder(
resolvedValue, valueHolder.getType(), valueHolder.getName());
// 4.4 將轉換前的valueHolder保存到新的ValueHolder的source屬性
resolvedValueHolder.setSource(valueHolder);
// 4.5 將新的ValueHolder添加到resolvedValues的genericArgumentValues屬性
resolvedValues.addGenericArgumentValue(resolvedValueHolder);
}
}
// 5.返回構造函數參數的個數
return minNrOfArgs;
}
8：createArgumentArray
private ArgumentsHolder createArgumentArray(
String beanName, RootBeanDefinition mbd,
@Nullable ConstructorArgumentValues resolvedValues,
BeanWrapper bw, Class<?>[] paramTypes,
@Nullable String[] paramNames, Executable executable,
boolean autowiring, boolean fallback)
throws UnsatisfiedDependencyException {
TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
// 獲取類型轉換器
TypeConverter converter = (customConverter != null ? customConverter : bw);
// 新建一個ArgumentsHolder來存放匹配到的參數
ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
Set<ConstructorArgumentValues.ValueHolder> usedValueHolders =
new HashSet<>(paramTypes.length);
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
// 1.遍歷參數類型數組
for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
// 拿到當前遍歷的參數類型
Class<?> paramType = paramTypes[paramIndex];
// 拿到當前遍歷的參數名
String paramName = (paramNames != null ? paramNames[paramIndex] : "");
// 2.查找當前遍歷的參數，是否在mdb對應的bean的構造函數參數中存在index、
// 類型和名稱匹配的
ConstructorArgumentValues.ValueHolder valueHolder = null;
if (resolvedValues != null) {
valueHolder = resolvedValues.getArgumentValue(
paramIndex, paramType, paramName, usedValueHolders);
// If we couldn't find a direct match and are not supposed to autowire,
// let's try the next generic, untyped argument value as fallback:
// it could match after type conversion (for example, String -> int).
// 3.如果我們找不到直接匹配並且不應該自動裝配，
// 那麼讓我們嘗試下一個通用的無類型參數值作爲降級方法：
// 它可以在類型轉換後匹配（例如，String - > int）。
if (valueHolder == null && (!autowiring ||
paramTypes.length == resolvedValues.getArgumentCount())) {
valueHolder = resolvedValues.getGenericArgumentValue(
null, null, usedValueHolders);
}
}
if (valueHolder != null) {
// 4.valueHolder不爲空，存在匹配的參數
// We found a potential match - let's give it a try.
// Do not consider the same value definition multiple times!
// 將valueHolder添加到usedValueHolders
usedValueHolders.add(valueHolder);
// 原始屬性值
Object originalValue = valueHolder.getValue();
// 轉換後的屬性值
Object convertedValue;
if (valueHolder.isConverted()) {
// 4.1 如果valueHolder已經轉換過
// 4.1.1 則直接獲取轉換後的值
convertedValue = valueHolder.getConvertedValue();
// 4.1.2 將convertedValue作爲args在paramIndex位置的預備參數
args.preparedArguments[paramIndex] = convertedValue;
}
else {
// 4.2 如果valueHolder還未轉換過
// 4.2.1 將方法（此處爲構造函數）和參數索引封裝成MethodParameter
// (MethodParameter是封裝方法和參數索引的工具類)
MethodParameter methodParam =
MethodParameter.forExecutable(executable, paramIndex);
try {
// 將originalValue 轉化成paramType類型的對象，並返回
convertedValue = converter.convertIfNecessary(
originalValue, paramType, methodParam);
}
catch (TypeMismatchException ex) {
throw new UnsatisfiedDependencyException(
mbd.getResourceDescription(), beanName,
new InjectionPoint(methodParam),
"Could not convert argument value of type [" +
ObjectUtils.nullSafeClassName(valueHolder.getValue()) +
"] to required type [" + paramType.getName() + "]: " +
ex.getMessage());
}
// 4.2.2 拿到原始的ValueHolde
Object sourceHolder = valueHolder.getSource();
if (sourceHolder instanceof ConstructorArgumentValues.ValueHolder) {
// 4.2.3 拿到原始參數值
Object sourceValue =
((ConstructorArgumentValues.ValueHolder) sourceHolder)
.getValue();
// 4.2.4 args標記爲需要解析
args.resolveNecessary = true;
// 4.2.5 將convertedValue作爲args在paramIndex位置的預備參數
args.preparedArguments[paramIndex] = sourceValue;
}
}
// 4.3 將convertedValue作爲args在paramIndex位置的參數
args.arguments[paramIndex] = convertedValue;
// 4.4 將originalValue作爲args在paramIndex位置的原始參數
args.rawArguments[paramIndex] = originalValue;
}
else {
// 5.valueHolder爲空，不存在匹配的參數
// 5.1 將方法（此處爲構造函數）和參數索引封裝成MethodParameter
MethodParameter methodParam =
MethodParameter.forExecutable(executable, paramIndex);
// No explicit match found: we're either supposed to autowire or
// have to fail creating an argument array for the given constructor.
// 5.2 找不到明確的匹配，並且不是自動裝配，則拋出異常
if (!autowiring) {
throw new UnsatisfiedDependencyException(
mbd.getResourceDescription(), beanName,
new InjectionPoint(methodParam),
"Ambiguous argument values for parameter of type [" +
paramType.getName() +
"] - did you specify the correct bean references as arguments?");
}
try {
// 5.3 如果是自動裝配，則調用用於解析自動裝配參數的方法，
// 返回的結果爲依賴的bean實例對象
// 例如：@Autowire修飾構造函數，自動注入構造函數中的參數bean就是在這邊處理
Object autowiredArgument = resolveAutowiredArgument(
methodParam, beanName, autowiredBeanNames,
converter, fallback);
// 5.4 將通過自動裝配解析出來的參數賦值給args
args.rawArguments[paramIndex] = autowiredArgument;
args.arguments[paramIndex] = autowiredArgument;
args.preparedArguments[paramIndex] = autowiredArgumentMarker;
args.resolveNecessary = true;
}
catch (BeansException ex) {
// 5.5 如果自動裝配解析失敗，則會拋出異常
throw new UnsatisfiedDependencyException(
mbd.getResourceDescription(), beanName,
new InjectionPoint(methodParam), ex);
}
}
}
// 6.如果依賴了其他的bean，則註冊依賴關係
for (String autowiredBeanName : autowiredBeanNames) {
this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
if (logger.isDebugEnabled()) {
logger.debug("Autowiring by type from bean name '" + beanName +
"' via " +
(executable instanceof Constructor ?
"constructor" : "factory method") +
" to bean named '" + autowiredBeanName + "'");
}
}
return args;
}
9：resolveAutowiredArgument
/**
* 用於解析指定參數的模板方法，該參數應該是自動生成的。
*/
@Nullable
protected Object resolveAutowiredArgument(MethodParameter param, String beanName,
@Nullable Set<String> autowiredBeanNames,
TypeConverter typeConverter, boolean fallback) {
Class<?> paramType = param.getParameterType();
// 1.如果參數類型爲InjectionPoint
if (InjectionPoint.class.isAssignableFrom(paramType)) {
// 1.1 拿到當前的InjectionPoint
// 存儲了當前正在解析依賴的方法參數信息，DependencyDescriptor）
InjectionPoint injectionPoint = currentInjectionPoint.get();
if (injectionPoint == null) {
// 1.2 當前injectionPoint爲空，則拋出異常：目前沒有可用的InjectionPoint
throw new IllegalStateException(
"No current InjectionPoint available for " + param);
}
// 1.3 返回當前的InjectionPoint
return injectionPoint;
}
// 2.解析指定依賴，DependencyDescriptor：
//將MethodParameter的方法參數索引信息封裝成DependencyDescriptor
return this.beanFactory.resolveDependency(
new DependencyDescriptor(param, true),
beanName, autowiredBeanNames, typeConverter);
...
}
10：resolveDependency
@Override
@Nullable
public Object resolveDependency(DependencyDescriptor descriptor,
@Nullable String requestingBeanName,
@Nullable Set<String> autowiredBeanNames,
@Nullable TypeConverter typeConverter)
throws BeansException {
descriptor.initParameterNameDiscovery(getParameterNameDiscoverer());
if (Optional.class == descriptor.getDependencyType()) {
// 爲指定的依賴項創建一個Optional包裝器。
return createOptionalDependency(descriptor, requestingBeanName);
}
else if (ObjectFactory.class == descriptor.getDependencyType() ||
ObjectProvider.class == descriptor.getDependencyType()) {
// 2.ObjectFactory類注入的特殊處理
return new DependencyObjectProvider(descriptor, requestingBeanName);
}
else if (javaxInjectProviderClass == descriptor.getDependencyType()) {
// 3.javaxInjectProviderClass類注入的特殊處理
return new Jsr330Factory()
.createDependencyProvider(descriptor, requestingBeanName);
}
else {
// 4.通用類注入的處理
// 4.1 如有必要，請獲取延遲解析代理
Object result = getAutowireCandidateResolver()
.getLazyResolutionProxyIfNecessary(
descriptor, requestingBeanName);
if (result == null) {
// 4.2 解析依賴關係，返回的result爲創建好的依賴對象的bean實例 見11
result = doResolveDependency(descriptor,
requestingBeanName, autowiredBeanNames, typeConverter);
}
return result;
}
}
11：doResolveDependency
public Object doResolveDependency(DependencyDescriptor descriptor,
@Nullable String beanName,
@Nullable Set<String> autowiredBeanNames,
@Nullable TypeConverter typeConverter)
throws BeansException {
// 1.設置當前的descriptor(存儲了方法參數等信息)爲當前注入點
InjectionPoint previousInjectionPoint =
ConstructorResolver.setCurrentInjectionPoint(descriptor);
try {
// 2.如果是ShortcutDependencyDescriptor，
// 則直接通過getBean方法獲取Bean實例，並返回；否則返回null
/*
* 通過構造函數注入依賴的bean實例的整個過程是不會出現涉及到
* ShortcutDependencyDescriptor的。
* ShortcutDependencyDescriptor主要用於@Autowire註解，
* 在解析@Autowire註解的時候，當第一次注入依賴的bean實例後，
* 會將該依賴的bean的信息封裝成ShortcutDependencyDescriptor，
* 放到緩存中去，下一次需要依賴注入該bean時，可以直接快速的拿到該bean實例。
*/
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
return shortcut;
}
// 3.拿到descriptor包裝的方法的參數類型（通過參數索引定位到具體的參數）
Class<?> type = descriptor.getDependencyType();
// 4.用於支持spring中新增的註解@Value
//（確定給定的依賴項是否聲明Value註解，如果有則拿到值）
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
if (value instanceof String) {
String strVal = resolveEmbeddedValue((String) value);
BeanDefinition bd = (beanName != null && containsBean(beanName) ?
getMergedBeanDefinition(beanName) : null);
value = evaluateBeanDefinitionString(strVal, bd);
}
TypeConverter converter =
(typeConverter != null ? typeConverter : getTypeConverter());
try {
// 4.1 如果使用了@Value註解，則將解析到的值轉換成所需的類型並返回
return converter.convertIfNecessary(value,
type, descriptor.getTypeDescriptor());
}
catch (UnsupportedOperationException ex) {
return (descriptor.getField() != null ?
converter.convertIfNecessary(value,
type, descriptor.getField()) :
converter.convertIfNecessary(value, type,
descriptor.getMethodParameter()));
}
}
// 5.解析MultipleBean（下文的MultipleBean都是指類型爲：Array、Collection、Map）
// 這邊的返回結果matchingBeans的key是beanName，
// 而value有兩種情況：一種是匹配的bean實例，另一種是匹配的bean實例的類型
Object multipleBeans = resolveMultipleBeans(descriptor,
beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
// 5.1 如果確實是容器類型的屬性，則直接返回解析結果
return multipleBeans;
}
// 6.查找與所需類型匹配的Bean實例
// （matchingBeans，key：beanName；value：匹配的bean實例，或者匹配的bean實例的類型）
Map<String, Object> matchingBeans =
findAutowireCandidates(beanName, type, descriptor);
if (matchingBeans.isEmpty()) {
// 6.1 如果require屬性爲true，而找到的匹配Bean卻爲空則拋出異常
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound(type,
descriptor.getResolvableType(), descriptor);
}
// 6.2 如果require屬性爲false，而找到的匹配Bean卻爲空，則返回nul
return null;
}
String autowiredBeanName;
Object instanceCandidate;
if (matchingBeans.size() > 1) {
// 7.非MultipleBean，但是有多個候選者
// 7.1 從多個候選者中選出最優的那個
autowiredBeanName =
determineAutowireCandidate(matchingBeans, descriptor);
if (autowiredBeanName == null) {
if (isRequired(descriptor) || !indicatesMultipleBeans(type)) {
return descriptor.
resolveNotUnique(descriptor.getResolvableType(), matchingBeans);
}
else {
return null;
}
}
// 7.2.拿到autowiredBeanName對應的value（bean實例或bean實例類型）
instanceCandidate = matchingBeans.get(autowiredBeanName);
}
else {
// We have exactly one match.
// 8.只找到了一個候選者，則直接使用該候選者
Map.Entry<String, Object> entry =
matchingBeans.entrySet().iterator().next();
autowiredBeanName = entry.getKey();
instanceCandidate = entry.getValue();
}
if (autowiredBeanNames != null) {
// 9.將依賴的beanName加到autowiredBeanNames中
autowiredBeanNames.add(autowiredBeanName);
}
// 10.如果instanceCandidate爲Class，則instanceCandidate爲bean實例的類型，
// 執行descriptor.resolveCandidate方法，通過getBean方法獲取bean實例並返回；
// 如果instanceCandidate不是Class，則instanceCandidate爲bean實例，直接返回該實例
if (instanceCandidate instanceof Class) {
instanceCandidate =
descriptor.resolveCandidate(autowiredBeanName, type, this);
}
Object result = instanceCandidate;
// 返回結果的判斷
if (result instanceof NullBean) {
if (isRequired(descriptor)) {
raiseNoMatchingBeanFound
(type, descriptor.getResolvableType(), descriptor);
}
result = null;
}
if (!ClassUtils.isAssignableValue(type, result)) {
throw new BeanNotOfRequiredTypeException
(autowiredBeanName, type, instanceCandidate.getClass());
}
// 最終返回
return result;
}
finally {
// 11.執行結束，將注入點修改成原來的注入點
ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint);
}
}
6.查找與所需類型匹配的 bean 實例，這邊的返回結果 matchingBeans 的 key 是 beanName，而 value 有兩種情況：一種是匹配的 bean 實例，另一種是匹配的 bean 實例的類型，見12。
12：findAutowireCandidates
protected Map<String, Object> findAutowireCandidates(
@Nullable String beanName,
Class<?> requiredType, DependencyDescriptor descriptor) {
// 1.獲取給定類型的所有beanName，包括在祖先工廠中定義的beanName
String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors(
this, requiredType, true, descriptor.isEager());
Map<String, Object> result = new LinkedHashMap<>(candidateNames.length);
// 2.首先從已經解析的依賴關係緩存中尋找是否存在我們想要的類型
for (Map.Entry<Class<?>, Object> classObjectEntry :
this.resolvableDependencies.entrySet()) {
Class<?> autowiringType = classObjectEntry.getKey();
// 2.1 autowiringType是否與requiredType相同，或者是requiredType的超類、超接口
if (autowiringType.isAssignableFrom(requiredType)) {
// 2.2 如果requiredType匹配，則從緩存中拿到相應的自動裝配值（bean實例）
Object autowiringValue = classObjectEntry.getValue();
// 2.3 根據給定的所需類型解析給定的自動裝配值
autowiringValue = AutowireUtils.
resolveAutowiringValue(autowiringValue, requiredType);
if (requiredType.isInstance(autowiringValue)) {
// 2.4 將autowiringValue放到結果集中，此時的value爲bean實例
result.put(
ObjectUtils.identityToString(autowiringValue), autowiringValue);
break;
}
}
}
// 3.遍歷從容器中獲取到的類型符合的beanName
for (String candidate : candidateNames) {
// isAutowireCandidate：判斷是否有資格作爲依賴注入的候選者
// 3.1 如果不是自引用 && candidate有資格作爲依賴注入的候選者
if (!isSelfReference(beanName, candidate)
&& isAutowireCandidate(candidate, descriptor)) {
// 3.2 將候選者添加到result中
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
// 4.如果結果爲空 && type不是MultipleBean（Array、Collection、Map），則使用降級匹配
if (result.isEmpty()) {
boolean multiple = indicatesMultipleBeans(requiredType);
// Consider fallback matches if the first pass failed to find anything...
// 4.1 使用降級匹配（跟正常匹配類似）
DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch();
for (String candidate : candidateNames) {
if (!isSelfReference(beanName, candidate)
&& isAutowireCandidate(candidate, fallbackDescriptor)
&&(!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))
) {
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
if (result.isEmpty() && !multiple) {
// Consider self references as a final pass...
// but in the case of a dependency collection,
// not the very same bean itself.
// 5.如果使用降級匹配結果還是空，則考慮自引用
for (String candidate : candidateNames) {
if (isSelfReference(beanName, candidate)
&&(!(descriptor instanceof MultiElementDescriptor)
|| !beanName.equals(candidate))
&&isAutowireCandidate(candidate, fallbackDescriptor)) {
// 5.1 如果是自引用 && (descriptor不是MultiElementDescriptor
// || beanName不等於候選者)
// && candidate允許依賴注入，則將候選者添加到result中
addCandidateEntry(result, candidate, descriptor, requiredType);
}
}
}
}
return result;
}
3.1 isAutowireCandidate：判斷是否有資格作爲依賴注入的候選者，見13。
3.2 將候選者添加到 result 中，見代碼塊15詳解。
isAutowireCandidate
13：isAutowireCandidate
@Override
public boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
throws NoSuchBeanDefinitionException {
// getAutowireCandidateResolver:
// 返回BeanFactory的@Autowire解析器，
// 開啓註解後的解析器爲：ContextAnnotationAutowireCandidateResolver
// 解析beanName對應的bean是否有資格作爲候選者
return isAutowireCandidate(beanName, descriptor, getAutowireCandidateResolver());
}
protected boolean isAutowireCandidate(String beanName,
DependencyDescriptor descriptor, AutowireCandidateResolver resolver)
throws NoSuchBeanDefinitionException {
// 1.解析beanName，去掉FactoryBean的修飾符“&”
String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
if (containsBeanDefinition(beanDefinitionName)) {
// 2.beanDefinitionMap緩存中存在beanDefinitionName：
// 通過beanDefinitionName緩存拿到MergedBeanDefinition，
// 將MergedBeanDefinition作爲參數，解析beanName是否有資格作爲候選者
// 見下面的方法
return isAutowireCandidate(beanName,
getMergedLocalBeanDefinition(beanDefinitionName), descriptor, resolver);
}
else if (containsSingleton(beanName)) {
// 3.singletonObjects緩存中存在beanName：
// 使用beanName構建RootBeanDefinition作爲參數，解析beanName是否有資格作爲候選者
return isAutowireCandidate(beanName,
new RootBeanDefinition(getType(beanName)), descriptor, resolver);
}
// 4.在beanDefinitionMap緩存和singletonObjects緩存中都不存在，
// 則在parentBeanFactory中遞歸解析beanName是否有資格作爲候選者
BeanFactory parent = getParentBeanFactory();
if (parent instanceof DefaultListableBeanFactory) {
// No bean definition found in this factory -> delegate to parent.
return ((DefaultListableBeanFactory) parent).
isAutowireCandidate(beanName, descriptor, resolver);
}
else if (parent instanceof ConfigurableListableBeanFactory) {
// If no DefaultListableBeanFactory, can't pass the resolver along.
return ((ConfigurableListableBeanFactory) parent).
isAutowireCandidate(beanName, descriptor);
}
else {
return true;
}
}
protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {
// 1.解析beanName，去掉FactoryBean的修飾符“&”
String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
resolveBeanClass(mbd, beanDefinitionName);
if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
// 3.如果緩存中已經存在解析的構造函數或工廠方法，
// 則解析mbd中的工廠方法，並替換掉緩存中的方法
new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
}
// 4.使用resolver解析器解析mbd是否有資格作爲依賴注入的候選者 見14
return resolver.isAutowireCandidate(
new BeanDefinitionHolder(mbd, beanName,
getAliases(beanDefinitionName)), descriptor);
}
14： resolver.isAutowireCandidate
// QualifierAnnotationAutowireCandidateResolver
// ContextAnnotationAutowireCandidateResolver繼承了
// QualifierAnnotationAutowireCandidateResolver
@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder,
DependencyDescriptor descriptor) {
// 1.調用父類方法判斷此bean是否可以自動注入到其他bean
boolean match = super.isAutowireCandidate(bdHolder, descriptor);
if (match) {
// 2.@Qualifiers註解檢查
match = checkQualifiers(bdHolder, descriptor.getAnnotations());
if (match) {
MethodParameter methodParam = descriptor.getMethodParameter();
if (methodParam != null) {
Method method = methodParam.getMethod();
if (method == null || void.class == method.getReturnType()) {
match = checkQualifiers(bdHolder,
methodParam.getMethodAnnotations());
}
}
}
}
return match;
}
// GenericTypeAwareAutowireCandidateResolver
@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder,
DependencyDescriptor descriptor) {
if (!super.isAutowireCandidate(bdHolder, descriptor)) {
// 1.如果父類返回false，則直接返回false
return false;
}
// 2.bdHolder的類型與descriptor的類型匹配，則返回true
return checkGenericTypeMatch(bdHolder, descriptor);
}
// SimpleAutowireCandidateResolver
@Override
public boolean isAutowireCandidate(BeanDefinitionHolder bdHolder,
DependencyDescriptor descriptor) {
// 獲取此bean是否可以自動注入到其他bean（autowireCandidate屬性），
// 默認爲true，一般不修改，因此這邊返回true
return bdHolder.getBeanDefinition().isAutowireCandidate();
}
15： addCandidateEntry
/**
* [在候選映射中添加一個條目:一個bean實例(如果可用)，或者只是解析的類型，在主候選選擇之前防止bean的早期初始化。]
* Add an entry to the candidate map: a bean instance if available or just the resolved
* type, preventing early bean initialization ahead of primary candidate selection.
* 當被依賴注入的屬性是 MultipleBean（Array、Collection、Map）類型，
* 生成的依賴描述類型是 MultiElementDescriptor，因此所有的候選者均是合格的，
* 所以會當場實例化他們（2.1）。而如果屬性的類型是非 MultipleBean，
* 那麼可能是從多個候選者中挑一個最合適的，
* 因此此時實例化他們就不合適了，最終會把最合適的那個實例化，
* 如果沒有合格的則不應該實例化。
*/
private void addCandidateEntry(Map<String, Object> candidates, String candidateName,
DependencyDescriptor descriptor, Class<?> requiredType) {
// 1.如果descriptor爲MultiElementDescriptor類型
if (descriptor instanceof MultiElementDescriptor) {
// 2.1 resolveCandidate: 通過candidateName獲取對應的bean實例
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
if (!(beanInstance instanceof NullBean)) {
// 2.2 將beanName -> bean實例 的映射添加到candidates（此時的value爲bean實例）
candidates.put(candidateName, beanInstance);
}
}
// 如果singletonObjects容器中包含 candidateName
// 或者 （ descriptor 是StreamDependencyDescriptor類型的 && descriptor 是isOrdered）
else if (containsSingleton(candidateName) || (descriptor instanceof StreamDependencyDescriptor &&
((StreamDependencyDescriptor) descriptor).isOrdered())) {
Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this);
// 2.2 將beanName -> bean實例 的映射添加到candidates（此時的value爲bean實例）
candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance));
}
else {
// 3.將beanName -> bean實例的類型 的映射添加到candidates（此時的value爲bean實例的類型）
candidates.put(candidateName, getType(candidateName));
}
}
16：doResolveDependency >> determineAutowireCandidate
/**
* [確定給定bean集中的autowire候選。查找@Primary和@Priority(按這個順序)。]
*/
@Nullable
protected String determineAutowireCandidate(
Map<String, Object> candidates,
DependencyDescriptor descriptor) {
Class<?> requiredType = descriptor.getDependencyType();
// 1.根據@Primary註解來選擇最優解
String primaryCandidate = determinePrimaryCandidate(candidates, requiredType);
if (primaryCandidate != null) {
return primaryCandidate;
}
// 2.根據@Priority註解來選擇最優解
String priorityCandidate =
determineHighestPriorityCandidate(candidates, requiredType);
if (priorityCandidate != null) {
return priorityCandidate;
}
// Fallback
// 3.如果通過以上兩步都不能選擇出最優解，則使用最基本的策略
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
String candidateName = entry.getKey();
Object beanInstance = entry.getValue();
/* 3.1 containsValue：首先如果這個beanInstance已經由Spring註冊過依賴關係，
* 則直接使用該beanInstance作爲最優解，
* 3.2 matchesBeanName：如果沒有註冊過此beanInstance的依賴關係，
* 則根據參數名稱來匹配，
* 如果參數名稱和某個候選者的beanName或別名一致，那麼直接將此bean作爲最優解
*/
if ((beanInstance != null
&& this.resolvableDependencies.containsValue(beanInstance)) ||
matchesBeanName(candidateName, descriptor.getDependencyName())) {
return candidateName;
}
}
// 4.沒有找到匹配的候選者，則返回null
return null;
}
17：determineAutowireCandidate >> determinePrimaryCandidate
@Nullable
protected String determinePrimaryCandidate(Map<String, Object> candidates,
Class<?> requiredType) {
String primaryBeanName = null;
// 1.遍歷所有候選者
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
String candidateBeanName = entry.getKey();
Object beanInstance = entry.getValue();
// 2.判斷候選者bean是否使用了@Primary註解：
// 如果candidateBeanName在當前BeanFactory中存在BeanDefinition，
// 則判斷當前BeanFactory中的BeanDefinition是否使用@Primary修飾；
// 否則，在parentBeanFactory中判斷
if (isPrimary(candidateBeanName, beanInstance)) {
if (primaryBeanName != null) {
// 3.走到這邊primaryBeanName不爲null，
// 代表標識了@Primary的候選者不止一個，
// 則判斷BeanName是否存在於當前BeanFactory
// candidateLocal：candidateBeanName
// 是否在當前BeanFactory的beanDefinitionMap緩存中
boolean candidateLocal = containsBeanDefinition(candidateBeanName);
// primaryLocal：primaryBeanName是否在當前
// BeanFactory的beanDefinitionMap緩存中
boolean primaryLocal = containsBeanDefinition(primaryBeanName);
if (candidateLocal && primaryLocal) {
// 3.1 如果當前BeanFactory中同一個類型的多個Bean，
// 不止一個Bean使用@Primary註解，則拋出異常
throw new NoUniqueBeanDefinitionException(
requiredType, candidates.size(),
"more than one 'primary' bean found among candidates: " +
candidates.keySet());
}
else if (candidateLocal) {
// 3.2 candidateLocal爲true，primaryLocal爲false，
// 則代表primaryBeanName是parentBeanFactory中的Bean，
// candidateBeanName是當前BeanFactory中的Bean，
// 當存在兩個都使用@Primary註解的Bean，優先使用當前BeanFactory中的
primaryBeanName = candidateBeanName;
}
// 3.3 candidateLocal爲false，primaryLocal爲true，
// 則代表primaryBeanName是當前BeanFactory中的Bean，
// candidateBeanName是parentBeanFactory中的Bean，
// 因此無需修改primaryBeanName的值
}
else {
// 4.primaryBeanName還爲空，代表是第一個符合的候選者，
// 直接將primaryBeanName賦值爲candidateBeanName
primaryBeanName = candidateBeanName;
}
}
}
// 5.返回唯一的使用@Primary註解的Bean的beanName（如果都沒使用@Primary註解則返回null）
return primaryBeanName;
}
18：determineAutowireCandidate >> determineHighestPriorityCandidate
@Nullable
protected String determineHighestPriorityCandidate(Map<String, Object> candidates,
Class<?> requiredType) {
// 用來保存最高優先級的beanName
String highestPriorityBeanName = null;
// 用來保存最高優先級的優先級值
Integer highestPriority = null;
// 1.遍歷所有候選者
for (Map.Entry<String, Object> entry : candidates.entrySet()) {
String candidateBeanName = entry.getKey();
Object beanInstance = entry.getValue();
if (beanInstance != null) {
// 2.拿到beanInstance的優先級
Integer candidatePriority = getPriority(beanInstance);
if (candidatePriority != null) {
if (highestPriorityBeanName != null) {
// 3.如果之前已經有候選者有優先級，則進行選擇
if (candidatePriority.equals(highestPriority)) {
// 3.1 如果存在兩個優先級相同的Bean，則拋出異常
throw new NoUniqueBeanDefinitionException(requiredType,
candidates.size(),
"Multiple beans found with the same priority ('" +
highestPriority +
"') among candidates: " + candidates.keySet());
}
else if (candidatePriority < highestPriority) {
// 3.2 使用優先級值較小的Bean作爲最優解（值越低，優先級越高）
highestPriorityBeanName = candidateBeanName;
highestPriority = candidatePriority;
}
}
else {
// 4.第一次有候選者有優先級
highestPriorityBeanName = candidateBeanName;
highestPriority = candidatePriority;
}
}
}
}
// 5.返回優先級最高的bean的beanName
return highestPriorityBeanName;
}
19：autowireConstructor >> storeCache
public void storeCache(RootBeanDefinition mbd, Executable constructorOrFactoryMethod) {
synchronized (mbd.constructorArgumentLock) {
// 將構造函數或工廠方法放到resolvedConstructorOrFactoryMethod緩存
mbd.resolvedConstructorOrFactoryMethod = constructorOrFactoryMethod;
// constructorArgumentsResolved標記爲已解析
mbd.constructorArgumentsResolved = true;
if (this.resolveNecessary) {
// 如果參數需要解析，
// 則將preparedArguments放到preparedConstructorArguments緩存
mbd.preparedConstructorArguments = this.preparedArguments;
}
else {
// 如果參數不需要解析，則將arguments放到resolvedConstructorArguments緩存
mbd.resolvedConstructorArguments = this.arguments;
}
}
}
單元測試
留個坑。。
總結
留個坑。。
參考
https://blog.csdn.net/v123411739/article/details/87994934