Spring源碼-IOC容器(三)-GetBean

Spring IOC容器 源碼解析系列，建議你們按順序閱讀，歡迎討論

(spring源碼均爲4.1.6.RELEASE版本)

1. Spring源碼-IOC容器(一)-構建簡單IOC容器
2. Spring源碼-IOC容器(二)-Bean的定位解析註冊
3. Spring源碼-IOC容器(三)-GetBean
4. Spring源碼-IOC容器(四)-FactoryBean
5. Spring源碼-IOC容器(五)-Bean的初始化
6. Spring源碼-IOC容器(六)-bean的循環依賴
7. Spring源碼-IOC容器(七)-ApplicationContext
8. Spring源碼-IOC容器(八)-NamespaceHandler與自定義xml
9. Spring源碼-IOC容器(九)-Component-Scan源碼解析
10. Spring源碼-IOC容器(十)-@Autowired解析

IOC容器最基本也是最重要的特性，就是管理bean的生命週期。配置好bean的約定，bean的建立和銷燬都由spring來管理。當咱們須要bean對象時，經過BeanFactory的getBean方法就能夠拿到實例化好的對象實例。getBean方法到底是如何作到的呢？spring中實現BeanFactory接口的getBean方法是AbstractBeanFactory。

public Object getBean(String name) throws BeansException {
	return doGetBean(name, null, null, false);
}

doGetBean方法是spring中獲取bean的通用方法，負責bean的實例化，以及支持各類bean的特性。doGetBean作的事情不少，我粗略地分解爲一下幾個部分。

1.轉換name參數

// 轉換傳入的name
// 若是是FactoryBean,去掉「&」前綴
// 若是是bean的暱稱，返回bean真正的name
final String beanName = transformedBeanName(name);

進入transformedBeanName方法

protected String transformedBeanName(String name) {
	return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

作了兩個事情，一個是BeanFactoryUtils.transformedBeanName，就是判斷name是否以&開頭，是的話就去掉&

public static String transformedBeanName(String name) {
	Assert.notNull(name, "'name' must not be null");
	String beanName = name;
	// 判斷是否以&開頭
	while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
		beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
	}
	return beanName;
}

另外一個是canonicalName方法

public String canonicalName(String name) {
	String canonicalName = name;
	// Handle aliasing...
	String resolvedName;
	do {
		// 判斷是否爲暱稱
		resolvedName = this.aliasMap.get(canonicalName);
		if (resolvedName != null) {
			canonicalName = resolvedName;
		}
	}
	while (resolvedName != null);
	return canonicalName;
}

判斷參數name是否爲暱稱，若是是，返回真正的beanName

2.查詢緩存是否存在

Object sharedInstance = getSingleton(beanName);

getSingleton方法由SingletonBeanRegistry接口定義，AbstractBeanFactory繼承了SingletonBeanRegistry的實現類DefaultSingletonBeanRegistry。

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
	// 從實例化好的對象Map中查詢beanName是否存在
	Object singletonObject = this.singletonObjects.get(beanName);
	// 若是緩存對象不存在，判斷beanName是否正在建立
	if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
		synchronized (this.singletonObjects) {
			// 若是beanName正在建立，說明bean之間相互依賴
			// 從預實例化對象Map中獲取bean對象
			singletonObject = this.earlySingletonObjects.get(beanName);
			if (singletonObject == null && allowEarlyReference) {
				// 若是預實例化對象Map也不存在，則從單例工廠Map中獲取bean的ObjectFactory
				// 並經過ObjectFactory的getObject方法返回bean對象
				ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
				if (singletonFactory != null) {
					singletonObject = singletonFactory.getObject();
					this.earlySingletonObjects.put(beanName, singletonObject);
					this.singletonFactories.remove(beanName);
				}
			}
		}
	}
	return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

3.校驗&標記

// 1.校驗正在建立的實例是否有相同beanName
if (isPrototypeCurrentlyInCreation(beanName)) {
	throw new BeanCurrentlyInCreationException(beanName);
}

// 若是當前BeanFactory不包含beanName的定義，且存在父BeanFactory
// 遞歸調用父BeanFactory的getBean方法
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
	// 從新轉換beanName
	String nameToLookup = originalBeanName(name);
	if (args != null) {
		// 若是有參數，先按照參數查詢
		return (T) parentBeanFactory.getBean(nameToLookup, args);
	}
	else {
		// 沒有參數，按傳入的bean的Type查詢
		return parentBeanFactory.getBean(nameToLookup, requiredType);
	}
}

if (!typeCheckOnly) {
	// 標記beanName已經被建立過至少一次
	markBeanAsCreated(beanName);
}

這段代碼主要作了如下內容

• 校驗是否已存在相同beanName的正在被建立。spring不容許多個相同beanName同時建立，若是存在，則拋出異常
• 若是父BeanFactory存在，且當前BeanFactory不包含beanName的BeanDefinition，則遞歸調用父BeanFactory的getBean方法獲取bean對象
• 將beanName加入到alreadyCreated集合中，標識beanName至少已經建立過一次

4.合併並校驗BeanDefinition

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);

(1)合併BeanDefinition

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
	// 從mergedBeanDefinitions緩存Map中查詢
	RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
	if (mbd != null) {
		return mbd;
	}
	return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

若是緩存不存在，getBeanDefinition方法先根據beanName獲取BeanDefinition。getBeanDefinition方法的具體實如今DefaultListableBeanFactory中。

public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
	BeanDefinition bd = this.beanDefinitionMap.get(beanName);
	if (bd == null) {
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("No bean named '" + beanName + "' found in " + this);
		}
		throw new NoSuchBeanDefinitionException(beanName);
	}
	return bd;
}

而後將BeanDefinition合併成RootBeanDefinition

protected RootBeanDefinition getMergedBeanDefinition(
		String beanName, BeanDefinition bd, BeanDefinition containingBd)
		throws BeanDefinitionStoreException {

	// 同步鎖保證beanName對應惟一的RootBeanDefinition
	synchronized (this.mergedBeanDefinitions) {
		RootBeanDefinition mbd = null;

		// 再次查詢緩存
		if (containingBd == null) {
			mbd = this.mergedBeanDefinitions.get(beanName);
		}

		if (mbd == null) {
			if (bd.getParentName() == null) {
				// 若是bd是RootBeanDefinition類型，則copy出新的RootBeanDefinition對象
				if (bd instanceof RootBeanDefinition) {
					mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
				}
				else {
					// bd只是BeanDefinition，構造一個新的RootBeanDefinition對象
					mbd = new RootBeanDefinition(bd);
				}
			}
			else {
				// BeanDefinition的parentName存在，合併父BeanDefinition和子BeanDefinition
				BeanDefinition pbd;
				try {
					String parentBeanName = transformedBeanName(bd.getParentName());
					if (!beanName.equals(parentBeanName)) {
						pbd = getMergedBeanDefinition(parentBeanName);
					}
					else {
						if (getParentBeanFactory() instanceof ConfigurableBeanFactory) {
							pbd = ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(parentBeanName);
						}
						else {
							throw new NoSuchBeanDefinitionException(bd.getParentName(),
									"Parent name '" + bd.getParentName() + "' is equal to bean name '" + beanName +
									"': cannot be resolved without an AbstractBeanFactory parent");
						}
					}
				}
				catch (NoSuchBeanDefinitionException ex) {
					throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
							"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
				}
				// Deep copy with overridden values.
				mbd = new RootBeanDefinition(pbd);
				mbd.overrideFrom(bd);
			}

			// 若是scope沒配置，默認爲singleton
			if (!StringUtils.hasLength(mbd.getScope())) {
				mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
			}
		}

		return mbd;
	}
}

(2)校驗MergedBeanDefinition，若是BeanDefinition設置了abstract=true，拋出異常

protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, Object[] args)
		throws BeanDefinitionStoreException {

	if (mbd.isAbstract()) {
		throw new BeanIsAbstractException(beanName);
	}
}

5.判斷bean是否指定依賴bean

String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
	for (String dependsOnBean : dependsOn) {
		if (isDependent(beanName, dependsOnBean)) {
			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
					"Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");
		}
		registerDependentBean(dependsOnBean, beanName);
		getBean(dependsOnBean);
	}
}

若是指定了依賴的bean，則循環遍歷，註冊依賴bean

public void registerDependentBean(String beanName, String dependentBeanName) {
	// 轉換dependsOnBean的beanName
	String canonicalName = canonicalName(beanName);
	Set<String> dependentBeans = this.dependentBeanMap.get(canonicalName);
	// 判斷dependsOnBean的被依賴的beanName集合包含當前要實例化的beanName
	// 則直接返回
	if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
		return;
	}

	// dependsOnBean的被依賴的beanName集合增長當前要實例化的beanName
	synchronized (this.dependentBeanMap) {
		dependentBeans = this.dependentBeanMap.get(canonicalName);
		if (dependentBeans == null) {
			dependentBeans = new LinkedHashSet<String>(8);
			this.dependentBeanMap.put(canonicalName, dependentBeans);
		}
		dependentBeans.add(dependentBeanName);
	}
	// 當前要實例化的beanName的依賴beanName集合增長dependsOnBean
	synchronized (this.dependenciesForBeanMap) {
		Set<String> dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
		if (dependenciesForBean == null) {
			dependenciesForBean = new LinkedHashSet<String>(8);
			this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
		}
		dependenciesForBean.add(canonicalName);
	}
}

同時遞歸調用getBean實例化dependsOnBean

6.建立bean對象

首先判斷BeanDefinition的scope

• 單例(singleton) IOC容器中有且只有一個對象，屢次調用getBean返回同一個對象
• 多例(prototype) 每次調用getBean返回一個新對象
• HTTP Request 每次HTTP請求共用同一個對象
• HTTP Session 每一個HTTP會話共用同一個對象
• Application ServletContext共用一個對象

scope爲單例

sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
	[@Override](https://my.oschina.net/u/1162528)
	public Object getObject() throws BeansException {
		try {
			return createBean(beanName, mbd, args);
		}
		catch (BeansException ex) {
			// Explicitly remove instance from singleton cache: It might have been put there
			// eagerly by the creation process, to allow for circular reference resolution.
			// Also remove any beans that received a temporary reference to the bean.
			destroySingleton(beanName);
			throw ex;
		}
	}
});

getSingleton方法的第二個參數是一個匿名內部類，匿名內部類實現的getObject方法中調用的createBean就是真正建立bean對象的方法。不過仍是先來看getSingleton方法，凡是單例的操做都是在DefaultSingletonBeanRegistry中。

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
	// 以singletonObjects做爲同步鎖，保證bean對象的建立不會併發
	synchronized (this.singletonObjects) {
		// 再次校驗緩存是否存在
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null) {
			// 若是BeanFactory正在銷燬，拋出異常
			// 不要在destroy方法中請求getBean
			if (this.singletonsCurrentlyInDestruction) {
				throw new BeanCreationNotAllowedException(beanName,
						"Singleton bean creation not allowed while the singletons of this factory are in destruction " +
						"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
			}
			if (logger.isDebugEnabled()) {
				logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
			}
			// 單例建立前的回調擴展點
			// 默認添加beanName到singletonsCurrentlyInCreation集合中
			beforeSingletonCreation(beanName);
			// 成功建立單例標識
			boolean newSingleton = false;
			boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
			if (recordSuppressedExceptions) {
				this.suppressedExceptions = new LinkedHashSet<Exception>();
			}
			try {
				// 真正建立單例對象方法
				singletonObject = singletonFactory.getObject();
				// 建立單例成功，設置標識爲true
				newSingleton = true;
			}
			catch (IllegalStateException ex) {
				// Has the singleton object implicitly appeared in the meantime ->
				// if yes, proceed with it since the exception indicates that state.
				singletonObject = this.singletonObjects.get(beanName);
				if (singletonObject == null) {
					throw ex;
				}
			}
			catch (BeanCreationException ex) {
				if (recordSuppressedExceptions) {
					for (Exception suppressedException : this.suppressedExceptions) {
						ex.addRelatedCause(suppressedException);
					}
				}
				throw ex;
			}
			finally {
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = null;
				}
				// 單例建立後的回掉擴展點
				// 默認從singletonsCurrentlyInCreation集合中移除beanName
				afterSingletonCreation(beanName);
			}
			if (newSingleton) {
				// 單例建立成功
				// 添加bean對象到緩存，並移除臨時狀態集合中的beanName
				addSingleton(beanName, singletonObject);
			}
		}
		return (singletonObject != NULL_OBJECT ? singletonObject : null);
	}
}

重點來關注下singletonFactory.getObject()，就是上面提到的匿名內部類中的方法

public Object getObject() throws BeansException {
	try {
		return createBean(beanName, mbd, args);
	}
	catch (BeansException ex) {
		// Explicitly remove instance from singleton cache: It might have been put there
		// eagerly by the creation process, to allow for circular reference resolution.
		// Also remove any beans that received a temporary reference to the bean.
		destroySingleton(beanName);
		throw ex;
	}
}

實際調用的createBean方法，而在AbstractBeanFactory中是抽象方法，真正實現的在AbstractAutowireCapableBeanFactory中

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

	if (logger.isDebugEnabled()) {
		logger.debug("Creating instance of bean '" + beanName + "'");
	}
	// 解析beanClass
	resolveBeanClass(mbd, beanName);

	// 處理methodOverride配置
	try {
		mbd.prepareMethodOverrides();
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
				beanName, "Validation of method overrides failed", ex);
	}

	try {
		// 在初始化bean以前，查看是否有InstantiationAwareBeanPostProcessor後置處理器
		// 若是存在，則直接返回代理對象
		Object bean = resolveBeforeInstantiation(beanName, mbd);
		if (bean != null) {
			return bean;
		}
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName,
				"BeanPostProcessor before instantiation of bean failed", ex);
	}

	// bean實例化真正執行方法
	Object beanInstance = doCreateBean(beanName, mbd, args);
	if (logger.isDebugEnabled()) {
		logger.debug("Finished creating instance of bean '" + beanName + "'");
	}
	return beanInstance;
}

來看resolveBeanClass方法

protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
		throws CannotLoadBeanClassException {
	// BeanDefinition存在beanClass，直接返回
	if (mbd.hasBeanClass()) {
		return mbd.getBeanClass();
	}
	
	return doResolveBeanClass(mbd, typesToMatch);
}

跳轉到doResolveBeanClass方法

private Class<?> doResolveBeanClass(RootBeanDefinition mbd, Class<?>... typesToMatch) throws ClassNotFoundException {
	return mbd.resolveBeanClass(getBeanClassLoader());
}

執行的是RootBeanDefinition的resolveBeanClass方法，實際是RootBeanDefinition的父類AbstractBeanDefinition

public Class<?> resolveBeanClass(ClassLoader classLoader) throws ClassNotFoundException {
	String className = getBeanClassName();
	if (className == null) {
		return null;
	}
	Class<?> resolvedClass = ClassUtils.forName(className, classLoader);
	this.beanClass = resolvedClass;
	return resolvedClass;
}

拿到beanClass後，重點來看doCreateBean方法

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
	// Instantiate the bean.
	BeanWrapper instanceWrapper = null;
	if (mbd.isSingleton()) {
		// 單例的bean移除FactoryBean name的緩存
		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
	}
	if (instanceWrapper == null) {
		// 實例化bean對象
		instanceWrapper = createBeanInstance(beanName, mbd, args);
	}
	final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
	Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

	// Allow post-processors to modify the merged bean definition.
	synchronized (mbd.postProcessingLock) {
		if (!mbd.postProcessed) {
			// 執行MergedBeanDefinitionPostProcessor後置處理器postProcessMergedBeanDefinition方法
			// 容許PostProcessor修改MergedBeanDefinition，即mbd
			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
			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.isDebugEnabled()) {
			logger.debug("Eagerly caching bean '" + beanName +
					"' to allow for resolving potential circular references");
		}
		// 將ObjectFactory對象存儲到singletonFactories工廠Map中
		addSingletonFactory(beanName, new ObjectFactory<Object>() {
			[@Override](https://my.oschina.net/u/1162528)
			public Object getObject() throws BeansException {
				return getEarlyBeanReference(beanName, mbd, bean);
			}
		});
	}

	// Initialize the bean instance.
	Object exposedObject = bean;
	try {
		// 填充bean對象，主要是依賴屬性的注入
		populateBean(beanName, mbd, instanceWrapper);
		if (exposedObject != null) {
			// 初始化bean對象
			// 1.執行bean的初始化方法
			// 2.觸發全部BeanPostProcessors的初始化前置和初始化後置方法
			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<String>(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 " +
							"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
				}
			}
		}
	}

	// Register bean as disposable.
	try {
		// 註冊bean的銷燬方法
		registerDisposableBeanIfNecessary(beanName, bean, mbd);
	}
	catch (BeanDefinitionValidationException ex) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
	}

	return exposedObject;
}

在doCreateBean中所作的操做很是多，咱們主要來關注三個方法

• createBeanInstance，bean對象的實例化
• populateBean，bean的依賴注入
• initializeBean，bean的初始化

先來看bean對象的實例化

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
	// Make sure bean class is actually resolved at this point.
	Class<?> beanClass = resolveBeanClass(mbd, beanName);

	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());
	}

	// 若是bean設置了工廠方法，經過工廠方法獲取bean對象
	if (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);
		}
	}

	// Need to determine the constructor...
	// 檢查全部SmartInstantiationAwareBeanPostProcessor後置處理器，是否有當前bean的候選構造方法
	Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
	if (ctors != null ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
			mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
		return autowireConstructor(beanName, mbd, ctors, args);
	}

	// No special handling: simply use no-arg constructor.
	// 沒有任何配置，直接經過無參構造函數實例化
	return instantiateBean(beanName, mbd);
}

進入instantiateBean方法

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
	try {
		Object beanInstance;
		final BeanFactory parent = this;
		if (System.getSecurityManager() != null) {
			beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
				[@Override](https://my.oschina.net/u/1162528)
				public Object run() {
					return getInstantiationStrategy().instantiate(mbd, beanName, parent);
				}
			}, getAccessControlContext());
		}
		else {
			beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
		}
		BeanWrapper bw = new BeanWrapperImpl(beanInstance);
		initBeanWrapper(bw);
		return bw;
	}
	catch (Throwable ex) {
		throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
	}
}

getInstantiationStrategy()方法返回實例化的策略類，在AbstractAutowireCapableBeanFactory中默認是CglibSubclassingInstantiationStrategy

private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

但最終執行instantiate方法的是CglibSubclassingInstantiationStrategy的父類SimpleInstantiationStrategy

public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
	// Don't override the class with CGLIB if no overrides.
	// 沒有methodOverrides配置，使用java自帶的JDK實例化方法
	// 若是存在methodOverrides配置，則使用CGLIB
	if (bd.getMethodOverrides().isEmpty()) {
		Constructor<?> constructorToUse;
		synchronized (bd.constructorArgumentLock) {
			constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
			if (constructorToUse == null) {
				final Class<?> clazz = bd.getBeanClass();
				if (clazz.isInterface()) {
					throw new BeanInstantiationException(clazz, "Specified class is an interface");
				}
				try {
					if (System.getSecurityManager() != null) {
						constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction<Constructor<?>>() {
							[@Override](https://my.oschina.net/u/1162528)
							public Constructor<?> run() throws Exception {
								return clazz.getDeclaredConstructor((Class[]) null);
							}
						});
					}
					else {
						constructorToUse =	clazz.getDeclaredConstructor((Class[]) null);
					}
					bd.resolvedConstructorOrFactoryMethod = constructorToUse;
				}
				catch (Exception ex) {
					throw new BeanInstantiationException(clazz, "No default constructor found", ex);
				}
			}
		}
		// JDK方式實例化對象
		return BeanUtils.instantiateClass(constructorToUse);
	}
	else {
		// Must generate CGLIB subclass.
		return instantiateWithMethodInjection(bd, beanName, owner);
	}
}

來看BeanUtils.instantiateClass方法，就是無參構造函數反射建立對象。對於CGLIB的方式，你們有興趣的能夠深刻了解，再次就很少說了。

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
	ReflectionUtils.makeAccessible(ctor);
	return ctor.newInstance(args);
}

建立完對象，接下來就是填充對象。populateBean方法中主要對依賴屬性進行處理，也就是常說的依賴注入

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
	// 拿到bean的依賴屬性
	PropertyValues pvs = mbd.getPropertyValues();

	// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
	// state of the bean before properties are set. This can be used, for example,
	// to support styles of field injection.
	boolean continueWithPropertyPopulation = true;

	// 這裏是在bean實例化後依賴屬性處理前能夠修改bean的狀態的回調操做點
	// 是InstantiationAwareBeanPostProcessor後置處理器postProcessAfterInstantiation方法的執行
	// 執行完後置處理器的postProcessAfterInstantiation方法，能夠返回true或false。若是返回false，表明將跳過以後的全部的InstantiationAwareBeanPostProcessor後置處理器並返回
	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;
				}
			}
		}
	}

	// 若是continueWithPropertyPopulation爲false，直接返回
	if (!continueWithPropertyPopulation) {
		return;
	}

	// 若是bean配置了autowire的方式，則經過byName或byType去容器中匹配依賴對象
	if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
			mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
		MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

		// Add property values based on autowire by name if applicable.
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
			autowireByName(beanName, mbd, bw, newPvs);
		}

		// Add property values based on autowire by type if applicable.
		if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
			autowireByType(beanName, mbd, bw, newPvs);
		}

		pvs = newPvs;
	}

	boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
	boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);

	if (hasInstAwareBpps || needsDepCheck) {
		PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
		// 若是存在InstantiationAwareBeanPostProcessor後置處理器，調用postProcessPropertyValues能夠對屬性進行校驗、修改甚至是替換
                    // 能夠支持屬性注入，好比@Autowired註解對應的AutowiredAnnotationBeanPostProcessor後置處理器就是在這裏進行依賴注入
		// 如@Required註解就在此處進行校驗
		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;
					}
				}
			}
		}
		// 若是bean配置了dependency-check，進行依賴校驗
		if (needsDepCheck) {
			checkDependencies(beanName, mbd, filteredPds, pvs);
		}
	}

	// 屬性依賴注入
	applyPropertyValues(beanName, mbd, bw, pvs);
}

來看applyPropertyValues方法

protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
	BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

	// Create a deep copy, resolving any references for values.
	List<PropertyValue> deepCopy = new ArrayList<PropertyValue>(original.size());
	boolean resolveNecessary = false;
	for (PropertyValue pv : original) {
		String propertyName = pv.getName();
		Object originalValue = pv.getValue();
		// 解析PropertyValue，返回String值或依賴的對象或者其餘類型好比Array，Set的值
		Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
		Object convertedValue = resolvedValue;
		resolveNecessary = true;
		deepCopy.add(new PropertyValue(pv, convertedValue));
	}

	// 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);
	}
}

在解析PropertyValue，咱們來關注下依賴bean的處理

if (value instanceof RuntimeBeanReference) {
	RuntimeBeanReference ref = (RuntimeBeanReference) value;
	return resolveReference(argName, ref);
}

resolveReference方法中遞歸調用了getBean方法得到了依賴bean的對象。

private Object resolveReference(Object argName, RuntimeBeanReference ref) {
	try {
		String refName = ref.getBeanName();
		refName = String.valueOf(doEvaluate(refName));
		if (ref.isToParent()) {
			if (this.beanFactory.getParentBeanFactory() == null) {
				throw new BeanCreationException(
						this.beanDefinition.getResourceDescription(), this.beanName,
						"Can't resolve reference to bean '" + refName +
						"' in parent factory: no parent factory available");
			}
			return this.beanFactory.getParentBeanFactory().getBean(refName);
		}
		else {
			// 遞歸調用getBean方法得到依賴bean對象
			Object bean = this.beanFactory.getBean(refName);
			this.beanFactory.registerDependentBean(refName, this.beanName);
			return bean;
		}
	}
	catch (BeansException ex) {
		throw new BeanCreationException(
				this.beanDefinition.getResourceDescription(), this.beanName,
				"Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);
	}
}

依賴真正被注入到bean對象中是BeanWrapperImpl中的setPropertyValue方法。這裏只節選了setter方法反射注入屬性值的部分，因爲調用層級比較多，詳細的就只能本身去看了。

final Method writeMethod = (pd instanceof GenericTypeAwarePropertyDescriptor ?
		((GenericTypeAwarePropertyDescriptor) pd).getWriteMethodForActualAccess() :
		pd.getWriteMethod());
if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers()) && !writeMethod.isAccessible()) {
	if (System.getSecurityManager()!= null) {
		AccessController.doPrivileged(new PrivilegedAction<Object>() {
			@Override
			public Object run() {
				writeMethod.setAccessible(true);
				return null;
			}
		});
	}
	else {
		writeMethod.setAccessible(true);
	}
}
final Object value = valueToApply;
if (System.getSecurityManager() != null) {
	try {
		AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
			@Override
			public Object run() throws Exception {
				writeMethod.invoke(object, value);
				return null;
			}
		}, acc);
	}
	catch (PrivilegedActionException ex) {
		throw ex.getException();
	}
}
else {
	writeMethod.invoke(this.object, value);
}

bean對象已經實例化，依賴屬性也所有注入，還有初始化方法沒有執行。回頭來看AbstractAutowireCapableBeanFactory類doCreateBean方法中的initializeBean方法。

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
	if (System.getSecurityManager() != null) {
		AccessController.doPrivileged(new PrivilegedAction<Object>() {
			@Override
			public Object run() {
				invokeAwareMethods(beanName, bean);
				return null;
			}
		}, getAccessControlContext());
	}
	else {
		// 處理實現Aware接口的Bean
		invokeAwareMethods(beanName, bean);
	}

	Object wrappedBean = bean;
	if (mbd == null || !mbd.isSynthetic()) {
		// BeanPostProcessor初始化前回調接口
		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
	}

	try {
		// 執行初始化方法
		// 1.實現InitializingBean接口的afterPropertiesSet方法
		// 2.配置的init-method方法
		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()) {
		// BeanPostProcessor初始化後回調接口
		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
	}
	return wrappedBean;
}

主要來看下invokeInitMethods方法

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
		throws Throwable {

	boolean isInitializingBean = (bean instanceof InitializingBean);
	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
		if (logger.isDebugEnabled()) {
			logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
		}
		if (System.getSecurityManager() != null) {
			try {
				AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
					@Override
					public Object run() throws Exception {
						((InitializingBean) bean).afterPropertiesSet();
						return null;
					}
				}, getAccessControlContext());
			}
			catch (PrivilegedActionException pae) {
				throw pae.getException();
			}
		}
		else {
			// 先調用InitializingBean的afterPropertiesSet方法
			((InitializingBean) bean).afterPropertiesSet();
		}
	}

	if (mbd != null) {
		String initMethodName = mbd.getInitMethodName();
		if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
				!mbd.isExternallyManagedInitMethod(initMethodName)) {
			// 再調用init-method方法，也是經過反射的方式去執行
			invokeCustomInitMethod(beanName, bean, mbd);
		}
	}
}

至此bean對象的全部操做都完成了，doCreateBean方法返回了單例bean的對象。最後一步，將建立好的bean對象放入緩存。

protected void addSingleton(String beanName, Object singletonObject) {
	synchronized (this.singletonObjects) {
		this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
		this.singletonFactories.remove(beanName);
		this.earlySingletonObjects.remove(beanName);
		this.registeredSingletons.add(beanName);
	}
}

scope爲多例

多例bean也是經過createBean方法建立對象，只是先後的回調方法不一樣而已

Object prototypeInstance = null;
try {
	// 多例bean建立前回調方法
	// 默認修改bean建立狀態
	beforePrototypeCreation(beanName);
	// createBean方法同單例bean一致
	prototypeInstance = createBean(beanName, mbd, args);
}
finally {
	// 多例bean建立後回調方法
	// 默認清除bean建立狀態
	afterPrototypeCreation(beanName);
}

其餘scope

其餘scope一樣建立對象過程同多例一致，只是對象建立成功後，緩存到指定的Scope中，從而保證Scope中的對象的惟一性。

String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
	throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
}
try {
	Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
		@Override
		public Object getObject() throws BeansException {
			beforePrototypeCreation(beanName);
			try {
				return createBean(beanName, mbd, args);
			}
			finally {
				afterPrototypeCreation(beanName);
			}
		}
	});
}
catch (IllegalStateException ex) {
	throw new BeanCreationException(beanName,
			"Scope '" + scopeName + "' is not active for the current thread; " +
			"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
			ex);
}

7.Bean的轉換

在bean對象已經建立完成後，若是指定了bean的Type，且指定的Type和建立的Bean的Class不匹配，能夠經過TypeConverter進行轉換。默認的TypeConverter實現類是SimpleTypeConverter。關於轉換操做將在後面的章節單獨介紹，這裏就暫時不細說了。

// Check if required type matches the type of the actual bean instance.
if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
	try {
		return getTypeConverter().convertIfNecessary(bean, requiredType);
	}
	catch (TypeMismatchException ex) {
		if (logger.isDebugEnabled()) {
			logger.debug("Failed to convert bean '" + name + "' to required type [" +
					ClassUtils.getQualifiedName(requiredType) + "]", ex);
		}
		throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
	}
}

到這裏，getBean方法基本完成了，還有FactoryBean的部分留待下一章單獨介紹。本來以爲應該不會不少的內容，居然寫了接近6個小時，並且仍是在部分點上省略待講的前提下，終於能體會到把知識講解透徹遠比想象中要難的多。而後對於本身來講也是受益良多，以前不太理解的地方又有了新的認識，以前的理解不少都不夠細緻。一直覺得除了JDK的源碼，最值得一看的就是spring的源碼。相信如今的付出必定能獲得回報。Keep Going！