@Test
public void testDefaultListableBeanFactory() {
    // 創(chuàng)建工廠
    DefaultListableBeanFactory factory = new DefaultListableBeanFactory();
    // 創(chuàng)建 XML 閱讀器，并指定關(guān)聯(lián)的工廠
    XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(factory);
    // 開始解析加載 Bean
    reader.loadBeanDefinitions(new ClassPathResource("applicationContext.xml"));
    System.out.println(factory.getBean("user"));
}

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    
    @Override
	public Object getBean(String name) throws BeansException {
		return doGetBean(name, null, null, false);
	}

	@Override
	public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
		return doGetBean(name, requiredType, null, false);
	}
    
	@Override
	public Object getBean(String name, Object... args) throws BeansException {
		return doGetBean(name, null, args, false);
	}
	
    ...
}

// 為了簡潔美觀，這里將源碼中的部分非核心內(nèi)容進(jìn)行了刪減
protected <T> T doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly) {
    
    // 轉(zhuǎn)換名稱，返回 Bean 的 ID
    // 如果是 FactoryBean 類型，則參數(shù) name 會(huì)以 & 為前綴。此方法會(huì)去掉該修飾符，并返回后面的內(nèi)容
    // 如果傳入的是 Bean 的別名，則會(huì)找到 Bean 的 ID 返回
    final String beanName = transformedBeanName(name);
    Object bean;
    
    // 單例 Bean 只會(huì)被創(chuàng)建一次，后續(xù)再獲取 Bean，直接從單例緩存中獲?。ü灿腥壘彺妫?
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        // 如果存在緩存的 Bean
        // 獲取 Bean，正常 Bean 直接返回，如果是 FactoryBean 則返回 FactoryBean.getObject()
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    
    else {
        // 檢驗(yàn)邏輯
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(...);
        }
        
        // 父子容器的處理
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // 當(dāng)父容器不為空并且獲取的 Bean 不在子容器定義時(shí)，從父容器遞歸獲取
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
                return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                    nameToLookup, requiredType, args, typeCheckOnly);
            } else if (args != null) {
                // 遞歸到父容器中尋找
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            } else if (requiredType != null) {
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            } else {
                return (T) parentBeanFactory.getBean(nameToLookup);
            }
        }
        
        if (!typeCheckOnly) {
            // 將 Bean 標(biāo)記為已經(jīng)創(chuàng)建（或?qū)⒁獎(jiǎng)?chuàng)建）,即將 beanName 加入 alreadyCreated 集合
            markBeanAsCreated(beanName);
        }
        
        try {
            // 獲取合并后的父子 Bean，對應(yīng) <bean id="p" abstract="true"> 和 <bean id="c" parent="p" 的用法
            // 將子標(biāo)簽 bean 的各個(gè)屬性合并到父標(biāo)簽，生成 RootBeanDefinition
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);
            
            // 獲取目標(biāo) bean 所依賴的其它 bean 名稱
            String[] dependsOn = mbd.getDependsOn();
            if (dependsOn != null) {
                for (String dep : dependsOn) {
                    if (isDependent(beanName, dep)) {
                        throw new BeanCreationException(...);
                    }
                    // 若存在依賴則需要遞歸實(shí)例化依賴的 bean
                    registerDependentBean(dep, beanName);
                    try {
                        getBean(dep);
                    } // catch...
                }
            }
            
            if (mbd.isSingleton()) {
                // 創(chuàng)建單例 Bean
                sharedInstance = getSingleton(beanName, () -> {
                    try {
                        // 創(chuàng)建 Bean 的核心方法
                        return createBean(beanName, mbd, args);
                    } // catch...
                });
                bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } 
            
            else if (mbd.isPrototype()) {
                // 創(chuàng)建原型 Bean
                Object prototypeInstance = null;
                try {
                    beforePrototypeCreation(beanName);
                    prototypeInstance = createBean(beanName, mbd, args);
                } finally {
                    afterPrototypeCreation(beanName);
                }
                bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } 
            
            else {
                // 創(chuàng)建其他作用域的 Bean
                String scopeName = mbd.getScope();
                final Scope scope = this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException(...);
                }
                try {
                    Object scopedInstance = scope.get(beanName, () -> {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        } finally {
                            afterPrototypeCreation(beanName);
                        }
                    });
                    bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                } // catch...
            }
        } // catch...
    }
    // 將 Bean 的類型轉(zhuǎn)換為 getBean 時(shí)指定的 requireType 類型
    if (requiredType != null && !requiredType.isInstance(bean)) {
        try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
                throw new BeanNotOfRequiredTypeException(...);
            }
            return convertedBean;
        } // catch...
    }
    return (T) bean;
}

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {

	// 如果 beanName 以 & 為前綴，但對應(yīng)的 Bean 不是 FactoryBean 類型，則拋異常
	if (BeanFactoryUtils.isFactoryDereference(name)) {
		if (beanInstance instanceof NullBean) {
			return beanInstance;
		}
		if (!(beanInstance instanceof FactoryBean)) {
			throw new BeanIsNotAFactoryException(...);
		}
	}

	// 校驗(yàn)已獲取的 Bean 
	// 1、如果該 Bean 不是 FactoryBean 類型，直接返回
	// 2、如果是 FactoryBean 類型，且 beanName 以 & 為前綴，說明想獲取的是 FactoryBean，也是直接返回
	if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
		return beanInstance;
	}

    // 從緩存中嘗試獲取 FactoryBean 創(chuàng)建的對象
	Object object = null;
	if (mbd == null) {
		object = getCachedObjectForFactoryBean(beanName);
	}
	if (object == null) {
		// 到這里已確定 beanInstance 一定是 FactoryBean 類型，所以進(jìn)行強(qiáng)轉(zhuǎn)
		FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
		// 獲取 Bean 對應(yīng)的 BeanDefinition
		if (mbd == null && containsBeanDefinition(beanName)) {
			mbd = getMergedLocalBeanDefinition(beanName);
		}
		// 當(dāng)前 Bean 是否是用戶定義的，而不是應(yīng)用程序自己定義的
		boolean synthetic = (mbd != null && mbd.isSynthetic());
		// 解析 FactoryBean 的核心方法
		object = getObjectFromFactoryBean(factory, beanName, !synthetic);
	}
	return object;
}

protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
    // 如果是單例 Bean 
	if (factory.isSingleton() && containsSingleton(beanName)) {
		synchronized (getSingletonMutex()) {
		    // 嘗試從緩存中獲取，緩存中存儲的是已經(jīng)通過 FactoryBean 創(chuàng)建的 bean 
			Object object = this.factoryBeanObjectCache.get(beanName);
			if (object == null) {
			    // 通過 FactoryBean 創(chuàng)建真正的 Bean，其實(shí)就是調(diào)用了 factory.getObject() 方法
				object = doGetObjectFromFactoryBean(factory, beanName);
				// 這里大概是在執(zhí)行上一步 doGetObjectFromFactoryBean 方法過程中，該 bean 已被其它線程創(chuàng)建并緩存了起來
				Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
				if (alreadyThere != null) {
					object = alreadyThere;
				} else { // 如果沒有
					if (shouldPostProcess) { 
                        // Bean 是否要進(jìn)行后置處理
						...
						try {
						    // 執(zhí)行后置處理器
							object = postProcessObjectFromFactoryBean(object, beanName);
						} // catch ...
					}
					...
				}
			}
			return object;
		}
	}
	else { 
        // 如果不是單例 bean 
	    // 通過 FactoryBean 創(chuàng)建真正的 bean 
		Object object = doGetObjectFromFactoryBean(factory, beanName);
		if (shouldPostProcess) {
			try {
			    // 執(zhí)行后置處理器
				object = postProcessObjectFromFactoryBean(object, beanName);
			} // catch ...
		}
		return object;
	}
}

protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) {

	RootBeanDefinition mbdToUse = mbd;

	// 根據(jù)設(shè)置的 class 屬性或 className 來解析得到 Class 引用賦值給 RootBeanDefinition
	if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
		mbdToUse = new RootBeanDefinition(mbd);
		mbdToUse.setBeanClass(resolvedClass);
	}

	// 對 override 屬性進(jìn)行標(biāo)記和驗(yàn)證，本質(zhì)上是處理 lookup-method 和 replaced-method 標(biāo)簽
	try {
		mbdToUse.prepareMethodOverrides();
	} // catch...

	try {
		// 執(zhí)行 BeanPostProcessors 后置處理器，如果有 Bean 返回，則不執(zhí)行接下來創(chuàng)建 Bean 的操作，直接返回該 Bean
        // 實(shí)際上這里的代碼是不走的
		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
		if (bean != null) {
			return bean;
		}
	} // catch...

	try {
	    // 最后會(huì)執(zhí)行到這里，這是創(chuàng)建 Bean 的核心方法
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		return beanInstance;
	} // catch...
}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args) {

	BeanWrapper instanceWrapper = null;
	// 如果是單例，嘗試獲取對應(yīng)的 BeanWrapper
	if (mbd.isSingleton()) {
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
        // 這里是一個(gè)關(guān)鍵點(diǎn)，使用對應(yīng)的策略（工廠方法、構(gòu)造函數(shù)）創(chuàng)建 Bean 實(shí)例，以及簡單初始化
        // BeanWrapper 包裝了 Bean 對象，并封裝類型轉(zhuǎn)換器
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	// 從 BeanWrapper 中獲取包裝的 Bean 實(shí)例
	final Object bean = instanceWrapper.getWrappedInstance();
	// 從 BeanWrapper 獲取包裝 Bean 的 Class 引用
	Class<?> beanType = instanceWrapper.getWrappedClass();
	if (beanType != NullBean.class) {
		mbd.resolvedTargetType = beanType;
	}

	// 執(zhí)行 MergedBeanDefinitionPostProcessor 后置處理器。
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			try {
				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			}
			// catch...
			mbd.postProcessed = true;
		}
	}

	// 檢查是否需要提前曝光，避免循環(huán)依賴（循環(huán)依賴問題會(huì)在后面詳細(xì)討論）
	boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
	if (earlySingletonExposure) {
		addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
	}

	// 開始初始化 Bean 
	Object exposedObject = bean;
	try {
	    // 對 Bean 進(jìn)行填充，將各個(gè)屬性值注入，如果存在依賴的 Bean 則進(jìn)行遞歸初始化
		populateBean(beanName, mbd, instanceWrapper);
		// 執(zhí)行一系列的初始化方法
		exposedObject = initializeBean(beanName, exposedObject, mbd);
	}
	// catch...

    // 再次檢查是否循環(huán)依賴
	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 
				}
			}
		}
	}

	// 注冊 DisposableBean
	try {
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	// catch...

	return exposedObject;
}

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    
	Class<?> beanClass = resolveBeanClass(mbd, beanName);
	if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
		throw new BeanCreationException(...);
	}

    // 如果有用于創(chuàng)建 Bean 實(shí)例的回調(diào)方法
	Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
	if (instanceSupplier != null) {
		return obtainFromSupplier(instanceSupplier, beanName);
	}
    
    // 如果工廠方法不為空，則使用工廠方法進(jìn)行實(shí)例化
	if (mbd.getFactoryMethodName() != null)  {
		return instantiateUsingFactoryMethod(beanName, mbd, args);
	}

	// 利用構(gòu)造函數(shù)進(jìn)行實(shí)例化，解析并確定目標(biāo)構(gòu)造函數(shù)
	boolean resolved = false;
	boolean autowireNecessary = false;
	if (args == null) {
		synchronized (mbd.constructorArgumentLock) {
		    // 一個(gè)類可能有多個(gè)構(gòu)造函數(shù)，需要根據(jù)參數(shù)來確定具體的構(gòu)造函數(shù)
			if (mbd.resolvedConstructorOrFactoryMethod != null) {
				resolved = true;
				autowireNecessary = mbd.constructorArgumentsResolved;
			}
		}
	}
	
	// 如果已經(jīng)解析過，則使用已經(jīng)確定的構(gòu)造方法
	if (resolved) {
		if (autowireNecessary) {
		    // 依據(jù)構(gòu)造函數(shù)注入
			return autowireConstructor(beanName, mbd, null, null);
		}
		else {
		    // 使用默認(rèn)構(gòu)造函數(shù)構(gòu)造
			return instantiateBean(beanName, mbd);
		}
	}

	// 根據(jù)參數(shù)確定構(gòu)造函數(shù)
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// 使用默認(rèn)的構(gòu)造函數(shù)
	return instantiateBean(beanName, mbd);
}

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
    
    // 判斷實(shí)例化的 Bean 是否為空
	if (bw == null) {
	    // 返回是否有為此 Bean 定義的屬性值，如果有，則拋異常，提示 “無法將屬性值應(yīng)用于空實(shí)例”
		if (mbd.hasPropertyValues()) {
			throw new BeanCreationException(...);
		}
		// 沒有，則跳過屬性填充階段以獲取空實(shí)例
		else {
			return;
		}
	}

	// 在設(shè)置屬性之前，先執(zhí)行 InstantiationAwareBeanPostProcessors 后置處理器，這些后置處理器可以用其它方式注入屬性，如字段注入。
	boolean continueWithPropertyPopulation = true;
	if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
		for (BeanPostProcessor bp : getBeanPostProcessors()) {
			if (bp instanceof InstantiationAwareBeanPostProcessor) {
				InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
				if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
					continueWithPropertyPopulation = false;
					break;
				}
			}
		}
	}
    // 當(dāng)使用了 InstantiationAwareBeanPostProcessors 后置處理器注入屬性，則結(jié)束屬性注入流程，直接返回
	if (!continueWithPropertyPopulation) {
		return;
	}

    // 獲取 Bean 實(shí)例的屬性值集合
	PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

		// 根據(jù)名稱自動(dòng)注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}

		// 根據(jù)類型自動(dòng)注入
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}

		pvs = newPvs;
	}

    // 返回此工廠是否擁有 InstantiationAwareBeanPostProcessor
	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	// 是否進(jìn)行依賴檢查
	boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

	if (hasInstAwareBpps || needsDepCheck) {
		if (pvs == null) {
			pvs = mbd.getPropertyValues();
		}
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		// 在屬性注入前執(zhí)行 InstantiationAwareBeanPostProcessor 后置處理器
        // @Autoware 的實(shí)現(xiàn)原理 
        // 這里涉及一個(gè)極其重要的后置處理器實(shí)現(xiàn) AutowiredAnnotationBeanPostProcessor，其主要用來處理 @Autowired 注解，這部分會(huì)在后面詳細(xì)討論
		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;
					}
				}
            }
		}
		// 進(jìn)行依賴檢查
		if (needsDepCheck) {
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}

	if (pvs != null) {
        // 這里進(jìn)行屬性的類型轉(zhuǎn)換，例如將字符串的 id 轉(zhuǎn)為數(shù)字的 id
	    // 執(zhí)行屬性注入，這里才真正的將屬性進(jìn)行填充，將解析和類型轉(zhuǎn)換好的屬性列表（pvs）賦值到包裝對象（bw）上
		applyPropertyValues(beanName, mbd, bw, pvs);
	}
}

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
		
   	// ...
    
    // Create a deep copy, resolving any references for values.
    List<PropertyValue> deepCopy = new ArrayList<>(original.size());
    boolean resolveNecessary = false;
    for (PropertyValue pv : original) {
        // 遍歷解析到的每個(gè)屬性
        if (pv.isConverted()) {
            deepCopy.add(pv);
        }
        else {
            String propertyName = pv.getName();
            // 如果是 JDK 類型，返回的是 TypeStringValue
            // 如果是要注入其他的 Bean，則是 RuntimeBeanReference 類型
            Object originalValue = pv.getValue();
            // 這里是個(gè)重點(diǎn)，進(jìn)行屬性的解析，如果是 JDK 類型則返回的對應(yīng) JDK 的類型
            // 如果是 RuntimeBeanReference，則會(huì)遞歸調(diào)用工廠的 getBean 獲取到要注入的對象
            Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
            Object convertedValue = resolvedValue;
            boolean convertible = bw.isWritableProperty(propertyName) &&
                !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
            if (convertible) {
                // 進(jìn)行類型準(zhǔn)換
                convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
            }
            if (resolvedValue == originalValue) {
                if (convertible) {
                    // 將類型轉(zhuǎn)換好的數(shù)據(jù)賦值給 PropertyValue
                    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();
    }

    try {
        // 這里才真正的對創(chuàng)建的包裝對象進(jìn)行了屬性的賦值，底層肯定是用到了反射了
        bw.setPropertyValues(new MutablePropertyValues(deepCopy));
    }
    catch (BeansException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Error setting property values", ex);
    }
}

protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {

    // 回調(diào) Aware 系列接口
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
			invokeAwareMethods(beanName, bean);
			return null;
		}, getAccessControlContext());
	}
	else {
		invokeAwareMethods(beanName, bean);
	}

    // 回調(diào) BeanPostProcessor 后置處理器的 postProcessBeforeInitialization 方法
	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
	    // 回調(diào) InitializingBean 的 afterPropertiesSet 方法
		invokeInitMethods(beanName, wrappedBean, mbd);
	}
	catch (Throwable ex) {
		throw new BeanCreationException(
				(mbd != null ? mbd.getResourceDescription() : null),
				beanName, "Invocation of init method failed", ex);
	}
	if (mbd == null || !mbd.isSynthetic()) {
	    // 回調(diào) BeanPostProcessor 后置處理器的 postProcessAfterInitialization 方法
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}

	return wrappedBean;
}

private void invokeAwareMethods(final String beanName, final Object bean) {   
    
	if (bean instanceof Aware) {
	    // 如果當(dāng)前 Bean 繼承了 BeanNameAware 接口，則回調(diào)接口中的 setBeanName 方法，并傳遞 beanName 參數(shù)
		if (bean instanceof BeanNameAware) {
			((BeanNameAware) bean).setBeanName(beanName);
		}
		
		// 這個(gè) BeanClassLoaderAware 接口傳遞的是 ClassLoader
		if (bean instanceof BeanClassLoaderAware) {
			ClassLoader bcl = getBeanClassLoader();
			if (bcl != null) {
				((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
			}
		}
		
		// 這個(gè) BeanFactoryAware 接口傳遞的是 AbstractAutowireCapableBeanFactory
		if (bean instanceof BeanFactoryAware) {
			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
		}
	}
}

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) {

	Object result = existingBean;
	
	// getBeanPostProcessors 方法獲取所有的 BeanPostProcessor 后置處理器的實(shí)現(xiàn)
    // 并循環(huán)執(zhí)行 postProcessBeforeInitialization 方法，參數(shù)是當(dāng)前 Bean 以及 beanName
	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
		Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}

@Override
public Object postProcessBeforeInitialization(final Object bean, String beanName) throws BeansException {
    AccessControlContext acc = null;
    //...

    invokeAwareInterfaces(bean);
    //...

	return bean;
}

private void invokeAwareInterfaces(Object bean) {
	if (bean instanceof Aware) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}
}

protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
	//..
    ((InitializingBean) bean).afterPropertiesSet();
	//..
}

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) {
	Object result = existingBean;
	// getBeanPostProcessors 方法獲取所有的 BeanPostProcessor 后置處理器的實(shí)現(xiàn)
    // 并循環(huán)執(zhí)行 postProcessAfterInitialization 方法，參數(shù)是當(dāng)前 Bean 以及 beanName
	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
		Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
		if (current == null) {
			return result;
		}
		result = current;
	}
	return result;
}