原文出自：http://cmsblogs.com
doCreateBean() 主要用於完成 bean 的創建和初始化工作，我們可以將其分爲四個過程：
createBeanInstance()實例化 beanpopulateBean()屬性填充- 循環依賴的處理
initializeBean()初始化 bean
第一個過程實例化 bean 已經在前面兩篇博客分析完畢了，這篇博客開始分析 屬性填充，也就是 populateBean()，該函數的作用是將 BeanDefinition 中的屬性值賦值給 BeanWrapper 實例對象(對於 BeanWrapper 我們後續專門寫文分析)。
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) { // 沒有實例化對象 if (bw == null) { // 有屬性拋出異常 if (mbd.hasPropertyValues()) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance"); } else { // 沒有屬性直接返回 return; } } // 在設置屬性之前給 InstantiationAwareBeanPostProcessors 最後一次改變 bean 的機會 boolean continueWithPropertyPopulation = true; // bena 不是"合成"的，即未由應用程序本身定義 // 是否持有 InstantiationAwareBeanPostProcessor if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) { // 迭代所有的 BeanPostProcessors for (BeanPostProcessor bp : getBeanPostProcessors()) { // 如果爲 InstantiationAwareBeanPostProcessor if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; // 返回值爲是否繼續填充 bean // postProcessAfterInstantiation：如果應該在 bean上面設置屬性則返回true，否則返回false // 一般情況下，應該是返回true，返回 false 的話， // 將會阻止在此 Bean 實例上調用任何後續的 InstantiationAwareBeanPostProcessor 實例。 if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) { continueWithPropertyPopulation = false; break; } } } } // 如果後續處理器發出停止填充命令，則終止後續操作 if (!continueWithPropertyPopulation) { return; } // bean 的屬性值 PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null); if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { // 將 PropertyValues 封裝成 MutablePropertyValues 對象 // MutablePropertyValues 允許對屬性進行簡單的操作， // 並提供構造函數以支持Map的深度複製和構造。 MutablePropertyValues newPvs = new MutablePropertyValues(pvs); // 根據名稱自動注入 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) { autowireByName(beanName, mbd, bw, newPvs); } // 根據類型自動注入 if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) { autowireByType(beanName, mbd, bw, newPvs); } pvs = newPvs; } // 是否已經註冊了 InstantiationAwareBeanPostProcessors boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors(); // 是否需要進行依賴檢查 boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE); if (hasInstAwareBpps || needsDepCheck) { if (pvs == null) { pvs = mbd.getPropertyValues(); } // 從 bw 對象中提取 PropertyDescriptor 結果集 // PropertyDescriptor：可以通過一對存取方法提取一個屬性 PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching); if (hasInstAwareBpps) { for (BeanPostProcessor bp : getBeanPostProcessors()) { if (bp instanceof InstantiationAwareBeanPostProcessor) { InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp; // 對所有需要依賴檢查的屬性進行後處理 pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName); if (pvs == null) { return; } } } } if (needsDepCheck) { // 依賴檢查，對應 depends-on 屬性 checkDependencies(beanName, mbd, filteredPds, pvs); } } if (pvs != null) { // 將屬性應用到 bean 中 applyPropertyValues(beanName, mbd, bw, pvs); } }處理流程如下：
- 根據 hasInstantiationAwareBeanPostProcessors 屬性來判斷是否需要在注入屬性之前給 InstantiationAwareBeanPostProcessors 最後一次改變 bean 的機會，此過程可以控制 Spring 是否繼續進行屬性填充。
- 根據注入類型的不同來判斷是根據名稱來自動注入（
autowireByName()）還是根據類型來自動注入（autowireByType()），統一存入到 PropertyValues 中，PropertyValues 用於描述 bean 的屬性。 - 判斷是否需要進行 BeanPostProcessor 和 依賴檢測。
- 將所有 PropertyValues 中的屬性填充到 BeanWrapper 中。
自動注入
Spring 會根據注入類型（ byName / byType ）的不同，調用不同的方法（ autowireByName() / autowireByType()）來注入屬性值。
autowireByName()
方法 autowireByName() 是根據屬性名稱完成自動依賴注入的，代碼如下：
protected void autowireByName( String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { // 對 Bean 對象中非簡單屬性 String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); for (String propertyName : propertyNames) { // 如果容器中包含指定名稱的 bean，則將該 bean 注入到 bean中 if (containsBean(propertyName)) { // 遞歸初始化相關 bean Object bean = getBean(propertyName); // 爲指定名稱的屬性賦予屬性值 pvs.add(propertyName, bean); // 屬性依賴注入 registerDependentBean(propertyName, beanName); if (logger.isDebugEnabled()) { logger.debug("Added autowiring by name from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + propertyName + "'"); } } else { if (logger.isTraceEnabled()) { logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName + "' by name: no matching bean found"); } } } }該方法邏輯很簡單，獲取該 bean 的非簡單屬性，什麼叫做非簡單屬性呢？就是類型爲對象類型的屬性，但是這裏並不是將所有的對象類型都都會找到，比如 8 個原始類型，String 類型 ，Number類型、Date類型、URL類型、URI類型等都會被忽略，如下：
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) { Set<String> result = new TreeSet<>(); PropertyValues pvs = mbd.getPropertyValues(); PropertyDescriptor[] pds = bw.getPropertyDescriptors(); for (PropertyDescriptor pd : pds) { if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) && !BeanUtils.isSimpleProperty(pd.getPropertyType())) { result.add(pd.getName()); } } return StringUtils.toStringArray(result); }過濾條件爲：有可寫方法、依賴檢測中沒有被忽略、不是簡單屬性類型。其實這裏獲取的就是需要依賴注入的屬性。
獲取需要依賴注入的屬性後，通過迭代、遞歸的方式初始化相關的 bean，然後調用 registerDependentBean()完成註冊依賴，如下：
public void registerDependentBean(String beanName, String dependentBeanName) { String canonicalName = canonicalName(beanName); synchronized (this.dependentBeanMap) { Set<String> dependentBeans = this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8)); if (!dependentBeans.add(dependentBeanName)) { return; } } synchronized (this.dependenciesForBeanMap) { Set<String> dependenciesForBean = this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8)); dependenciesForBean.add(canonicalName); } }autowireByType()
protected void autowireByType( String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) { // 獲取 TypeConverter 實例 // 使用自定義的 TypeConverter，用於取代默認的 PropertyEditor 機制 TypeConverter converter = getCustomTypeConverter(); if (converter == null) { converter = bw; } Set<String> autowiredBeanNames = new LinkedHashSet<>(4); // 獲取非簡單屬性 String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw); for (String propertyName : propertyNames) { try { // 獲取 PropertyDescriptor 實例 PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName); // 不要嘗試按類型 if (Object.class != pd.getPropertyType()) { // 探測指定屬性的 set 方法 MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd); boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance()); DependencyDescriptor desc = new AbstractAutowireCapableBeanFactory.AutowireByTypeDependencyDescriptor(methodParam, eager); // 解析指定 beanName 的屬性所匹配的值，並把解析到的屬性名稱存儲在 autowiredBeanNames 中 // 當屬性存在過個封裝 bean 時將會找到所有匹配的 bean 並將其注入 Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter); if (autowiredArgument != null) { pvs.add(propertyName, autowiredArgument); } // 迭代方式注入 bean for (String autowiredBeanName : autowibeanredBeanNames) { registerDependentBean(autowiredBeanName, beanName); if (logger.isDebugEnabled()) { logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" + propertyName + "' to bean named '" + autowiredBeanName + "'"); } } autowiredBeanNames.clear(); } } catch (BeansException ex) { throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex); } } }其實主要過程和根據名稱自動注入差不多都是找到需要依賴注入的屬性，然後通過迭代的方式尋找所匹配的 bean，最後調用 registerDependentBean() 註冊依賴。不過相對於 autowireByName() 而言，根據類型尋找相匹配的 bean 過程比較複雜，下面我們就分析這個複雜的過程，如下：
public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException { // 初始化參數名稱發現器，該方法並不會在這個時候嘗試檢索參數名稱 // getParameterNameDiscoverer 返回 parameterNameDiscoverer 實例，parameterNameDiscoverer 方法參數名稱的解析器 descriptor.initParameterNameDiscovery(getParameterNameDiscoverer()); // 依賴類型爲 Optional 類型 if (Optional.class == descriptor.getDependencyType()) { // 創建 Optional 實例依賴類型 return createOptionalDependency(descriptor, requestingBeanName); } // 依賴類型爲ObjectFactory、ObjectProvider else if (ObjectFactory.class == descriptor.getDependencyType() || ObjectProvider.class == descriptor.getDependencyType()) { // ObjectFactory / ObjectProvider 用於 用於延遲解析依賴項 return new DefaultListableBeanFactory.DependencyObjectProvider(descriptor, requestingBeanName); } else if (javaxInjectProviderClass == descriptor.getDependencyType()) { // javaxInjectProviderClass 類注入的特殊處理 return new DefaultListableBeanFactory.Jsr330ProviderFactory().createDependencyProvider(descriptor, requestingBeanName); } else { // 爲實際依賴關係目標的延遲解析構建代理 // 默認實現返回 null Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary( descriptor, requestingBeanName); if (result == null) { // 通用處理邏輯 result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter); } return result; } }這裏我們關注通用處理邏輯： doResolveDependency()，如下：
public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException { // 注入點 InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor); try { // 針對給定的工廠給定一個快捷實現的方式，例如考慮一些預先解析的信息 // 在進入所有bean的常規類型匹配算法之前，解析算法將首先嚐試通過此方法解析快捷方式。 // 子類可以覆蓋此方法 Object shortcut = descriptor.resolveShortcut(this); if (shortcut != null) { // 返回快捷的解析信息 return shortcut; } // 依賴的類型 Class<?> type = descriptor.getDependencyType(); // 支持 Spring 的註解 @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()); return (descriptor.getField() != null ? converter.convertIfNecessary(value, type, descriptor.getField()) : converter.convertIfNecessary(value, type, descriptor.getMethodParameter())); } // 解析複合 bean，其實就是對 bean 的屬性進行解析 // 包括：數組、Collection 、Map 類型 Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter); if (multipleBeans != null) { return multipleBeans; } // 查找與類型相匹配的 bean // 返回值構成爲：key = 匹配的 beanName，value = beanName 對應的實例化 bean Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor); // 沒有找到，檢驗 @autowire 的 require 是否爲 true if (matchingBeans.isEmpty()) { // 如果 @autowire 的 require 屬性爲 true ，但是沒有找到相應的匹配項，則拋出異常 if (isRequired(descriptor)) { raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor); } return null; } String autowiredBeanName; Object instanceCandidate; if (matchingBeans.size() > 1) { // 確認給定 bean autowire 的候選者 // 按照 @Primary 和 @Priority 的順序 autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor); if (autowiredBeanName == null) { if (isRequired(descriptor) || !indicatesMultipleBeans(type)) { // 唯一性處理 return descriptor.resolveNotUnique(type, matchingBeans); } else { // 在可選的Collection / Map的情況下，默默地忽略一個非唯一的情況：可能它是一個多個常規bean的空集合 return null; } } instanceCandidate = matchingBeans.get(autowiredBeanName); } else { // We have exactly one match. Map.Entry<Staring, Object> entry = matchingBeans.entrySet().iterator().next(); autowiredBeanName = entry.getKey(); instanceCandidate = entry.getValue(); } if (autowiredBeanNames != null) { autowiredBeanNames.add(autowiredBeanName); } 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 { ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint); } }到這裏就已經完成了所有屬性的注入了。 populateBean() 該方法就已經完成了一大半工作了，下一步則是對依賴 bean 的檢測和 PostProcessor 處理，這個我們後面分析，下面分析該方法的最後一步： applyPropertyValues()
applyPropertyValues
其實上面只是完成了所有注入屬性的獲取，將獲取的屬性封裝在 PropertyValues 的實例對象 pvs 中，並沒有應用到已經實例化的 bean 中，而 applyPropertyValues() 則是完成這一步驟的。
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) { if (pvs.isEmpty()) { return; } if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) { ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext()); } // MutablePropertyValues 類型屬性 MutablePropertyValues mpvs = null; // 原始類型 List<PropertyValue> original; if (pvs instanceof MutablePropertyValues) { mpvs = (MutablePropertyValues) pvs; if (mpvs.isConverted()) { try { // 設置到 BeanWrapper 中去 bw.setPropertyValues(mpvs); return; } catch (BeansException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Error setting property values", ex); } } original = mpvs.getPropertyValueList(); } else { // 如果 pvs 不是 MutablePropertyValues 類型，則直接使用原始類型 original = Arrays.asList(pvs.getPropertyValues()); } // 獲取 TypeConverter TypeConverter converter = getCustomTypeConverter(); if (converter == null) { converter = bw; } // 獲取對應的解析器 BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter); // Create a deep copy, resolving any references for values. List<PropertyValue> deepCopy = new ArrayList<>(original.size()); boolean resolveNecessary = false; // 遍歷屬性，將屬性轉換爲對應類的對應屬性的類型 for (PropertyValue pv : original) { if (pv.isConverted()) { deepCopy.add(pv); } else { String propertyName = pv.getName(); Object originalValue = pv.getValue(); Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue); Object convertedValue = resolvedValue; boolean convertible = bw.isWritableProperty(propertyName) && !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName); if (convertible) { convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter); } // Possibly store converted value in merged bean definition, // in order to avoid re-conversion for every created bean instance. if (resolvedValue == originalValue) { if (convertible) { pv.setConvertedValue(convertedValue); } deepCopy.add(pv); } else if (convertible && originalValue instanceof TypedStringValue && !((TypedStringValue) originalValue).isDynamic() && !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) { pv.setConvertedValue(convertedValue); deepCopy.add(pv); } else { resolveNecessary = true; deepCopy.add(new PropertyValue(pv, convertedValue)); } } } if (mpvs != null && !resolveNecessary) { mpvs.setConverted(); } // Set our (possibly massaged) deep copy. try { bw.setPropertyValues(new MutablePropertyValues(deepCopy)); } catch (BeansException ex) { throw new BeanCreationException( mbd.getResourceDescription(), beanName, "Error setting property values", ex); } }至此， doCreateBean() 第二個過程：屬性填充 已經分析完成了，下篇分析第三個過程：循環依賴的處理，其實循環依賴並不僅僅只是在 doCreateBean() 中處理，其實在整個加載 bean 的過程中都有涉及，所以下篇內容並不僅僅只侷限於 doCreateBean()。