Spring IOC核心源碼學習

1. 初始化

大致單步跟了下Spring IOC的初始化過程,整個脈絡很龐大,初始化的過程主要就是讀取XML資源,并解析,最終注冊到Bean Factory中:

在完成初始化的過程后,Bean們就在BeanFactory中蓄勢以待地等調(diào)用了。下面通過一個具體的例子,來詳細地學習一下初始化過程,例如當加載下面一個bean:

<bean?id="XiaoWang"?class="com.springstudy.talentshow.SuperInstrumentalist">

<property?name="instruments">

<list>

<ref?bean="piano"/>

<ref?bean="saxophone"/>

</list>

</property>

</bean>

加載時需要讀取、解析、注冊bean,這個過程具體的調(diào)用棧如下所示:

下面對每一步的關(guān)鍵的代碼進行詳細分析:

1.1 準備

保存配置位置,并刷新

在調(diào)用ClassPathXmlApplicationContext后,先會將配置位置信息保存到configLocations,供后面解析使用,之后,會調(diào)用AbstractApplicationContext的refresh方法進行刷新:

public?ClassPathXmlApplicationContext(String[] configLocations,?boolean refresh,

ApplicationContext parent)?throws BeansException {


super(parent);

// 保存位置信息,比如`com/springstudy/talentshow/talent-show.xml`

setConfigLocations(configLocations);

if (refresh) {

// 刷新

refresh();

}

}


public?void?refresh()?throws BeansException, IllegalStateException {

synchronized (this.startupShutdownMonitor) {

// Prepare this context for refreshing.

prepareRefresh();

// Tell the subclass to refresh the internal bean factory.

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context.

prepareBeanFactory(beanFactory);

try {

// Allows post-processing of the bean factory in context subclasses.

postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.

invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.

registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.

initMessageSource();

// Initialize event multicaster for this context.

initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.

onRefresh();

// Check for listener beans and register them.

registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.

finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.

finishRefresh();

}

catch (BeansException ex) {

// Destroy already created singletons to avoid dangling resources.

destroyBeans();

// Reset 'active' flag.

cancelRefresh(ex);

// Propagate exception to caller.

throw ex;

}

}

}

創(chuàng)建載入BeanFactory

protected?final?void?refreshBeanFactory()?throws BeansException {

// ... ...

DefaultListableBeanFactory beanFactory = createBeanFactory();

// ... ...

loadBeanDefinitions(beanFactory);

// ... ...

}

創(chuàng)建XMLBeanDefinitionReader

protected?void?loadBeanDefinitions(DefaultListableBeanFactory beanFactory)

throws BeansException, IOException {

// Create a new XmlBeanDefinitionReader for the given BeanFactory.

XmlBeanDefinitionReader beanDefinitionReader =?new XmlBeanDefinitionReader(beanFactory);

// ... ...

// Allow a subclass to provide custom initialization of the reader,

// then proceed with actually loading the bean definitions.

initBeanDefinitionReader(beanDefinitionReader);

loadBeanDefinitions(beanDefinitionReader);

}

1.2 讀取

創(chuàng)建處理每一個resource

public?int?loadBeanDefinitions(String location, Set<Resource> actualResources)

throws BeanDefinitionStoreException {

// ... ...

// 通過Location來讀取Resource

Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);

int loadCount = loadBeanDefinitions(resources);

// ... ...

}


public?int?loadBeanDefinitions(Resource... resources)?throws BeanDefinitionStoreException {

Assert.notNull(resources,?"Resource array must not be null");

int counter =?0;

for (Resource resource : resources) {

// 載入每一個resource

counter += loadBeanDefinitions(resource);

}

return counter;

}

處理XML每個元素

protected?void?parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {

// ... ...

NodeList nl = root.getChildNodes();

for (int i =?0; i < nl.getLength(); i++) {

Node node = nl.item(i);

if (node?instanceof Element) {

Element ele = (Element) node;

if (delegate.isDefaultNamespace(ele)) {

// 處理每個xml中的元素,可能是import、alias、bean

parseDefaultElement(ele, delegate);

}

else {

delegate.parseCustomElement(ele);

}

}

}

// ... ...

}

解析和注冊bean

protected?void?processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

// 解析

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

if (bdHolder !=?null) {

bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

try {

// 注冊

// Register the final decorated instance.

BeanDefinitionReaderUtils.registerBeanDefinition(

bdHolder, getReaderContext().getRegistry());

}

catch (BeanDefinitionStoreException ex) {

getReaderContext().error("Failed to register bean definition with name '" +

bdHolder.getBeanName() +?"'", ele, ex);

}

// Send registration event.

getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

}

}

本步驟中,通過parseBeanDefinitionElement將XML的元素解析為BeanDefinition,然后存在BeanDefinitionHolder中,然后再利用BeanDefinitionHolder將BeanDefinition注冊,實質(zhì)就是把BeanDefinition的實例put進BeanFactory中,和后面將詳細的介紹解析和注冊過程。

1.3 解析

處理每個Bean的元素

public AbstractBeanDefinition?parseBeanDefinitionElement(

Element ele, String beanName, BeanDefinition containingBean) {


// ... ...

// 創(chuàng)建beandefinition

AbstractBeanDefinition bd = createBeanDefinition(className, parent);


parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));


parseMetaElements(ele, bd);

parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

// 處理“Constructor”

parseConstructorArgElements(ele, bd);

// 處理“Preperty”

parsePropertyElements(ele, bd);

parseQualifierElements(ele, bd);

// ... ...

}

處理屬性的值

public Object?parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {

String elementName = (propertyName !=?null) ?

"<property> element for property '" + propertyName +?"'" :

"<constructor-arg> element";


// ... ...

if (hasRefAttribute) {

// 處理引用

String refName = ele.getAttribute(REF_ATTRIBUTE);

if (!StringUtils.hasText(refName)) {

error(elementName +?" contains empty 'ref' attribute", ele);

}

RuntimeBeanReference ref =?new RuntimeBeanReference(refName);

ref.setSource(extractSource(ele));

return ref;

}

else?if (hasValueAttribute) {

// 處理值

TypedStringValue valueHolder =?new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));

valueHolder.setSource(extractSource(ele));

return valueHolder;

}

else?if (subElement !=?null) {

// 處理子類型(比如list、map等)

return parsePropertySubElement(subElement, bd);

}

// ... ...

}

1.4 注冊

public?static?void?registerBeanDefinition(

BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)

throws BeanDefinitionStoreException {


// Register bean definition under primary name.

String beanName = definitionHolder.getBeanName();

registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());


// Register aliases for bean name, if any.

String[] aliases = definitionHolder.getAliases();

if (aliases !=?null) {

for (String alias : aliases) {

registry.registerAlias(beanName, alias);

}

}

}


public?void?registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

throws BeanDefinitionStoreException {


// ......


// 將beanDefinition注冊

this.beanDefinitionMap.put(beanName, beanDefinition);


// ......

}

注冊過程中,最核心的一句就是:this.beanDefinitionMap.put(beanName, beanDefinition),也就是說注冊的實質(zhì)就是以beanName為key,以beanDefinition為value,將其put到HashMap中。

2. 注入依賴

當完成初始化IOC容器后,如果bean沒有設(shè)置lazy-init(延遲加載)屬性,那么bean的實例就會在初始化IOC完成之后,及時地進行初始化。初始化時會先建立實例,然后根據(jù)配置利用反射對實例進行進一步操作,具體流程如下所示:

創(chuàng)建bean的實例

創(chuàng)建bean的實例過程函數(shù)調(diào)用棧如下所示:


注入bean的屬性

注入bean的屬性過程函數(shù)調(diào)用棧如下所示:

在創(chuàng)建bean和注入bean的屬性時,都是在doCreateBean函數(shù)中進行的,我們重點看下:

protected Object?doCreateBean(final String beanName,?final RootBeanDefinition mbd,

final Object[] args) {

// Instantiate the bean.

BeanWrapper instanceWrapper =?null;

if (mbd.isSingleton()) {

instanceWrapper =?this.factoryBeanInstanceCache.remove(beanName);

}

if (instanceWrapper ==?null) {

// 創(chuàng)建bean的實例

instanceWrapper = createBeanInstance(beanName, mbd, args);

}


// ... ...


// Initialize the bean instance.

Object exposedObject = bean;

try {

// 初始化bean的實例,如注入屬性

populateBean(beanName, mbd, instanceWrapper);

if (exposedObject !=?null) {

exposedObject = initializeBean(beanName, exposedObject, mbd);

}

}


// ... ...

}

理解了以上兩個過程,我們就可以自己實現(xiàn)一個簡單的Spring框架了。

歡迎工作一到五年的Java工程師朋友們加入Java程序員開發(fā): 854393687

群內(nèi)提供免費的Java架構(gòu)學習資料(里面有高可用、高并發(fā)、高性能及分布式、Jvm性能調(diào)優(yōu)、Spring源碼,MyBatis,Netty,Redis,Kafka,Mysql,Zookeeper,Tomcat,Docker,Dubbo,Nginx等多個知識點的架構(gòu)資料)合理利用自己每一分每一秒的時間來學習提升自己,不要再用"沒有時間“來掩飾自己思想上的懶惰!趁年輕,使勁拼,給未來的自己一個交代!

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明:文章內(nèi)容(如有圖片或視頻亦包括在內(nèi))由作者上傳并發(fā)布,文章內(nèi)容僅代表作者本人觀點,簡書系信息發(fā)布平臺,僅提供信息存儲服務。

推薦閱讀更多精彩內(nèi)容