原文作者：Javadoop

原文地址：Spring IOC 容器源碼分析

?

在繼續往下之前，我們需要先了解 BeanDefinition。我們說 BeanFactory 是 Bean 容器，那么 Bean 又是什么呢？這里的 BeanDefinition 就是我們所說的 Spring 的 Bean，我們自己定義的各個 Bean 其實會轉換成一個個 BeanDefinition 存在于 Spring 的 BeanFactory 中。所以，如果有人問你 Bean 是什么的時候，你要知道 Bean 在代碼層面上可以簡單認為是 BeanDefinition 的實例。

BeanDefinition 中保存了我們的 Bean 信息，比如這個 Bean 指向的是哪個類、是否是單例的、是否懶加載、這個 Bean 依賴了哪些 Bean 等等。

BeanDefinition 接口定義

我們來看下 BeanDefinition 的接口定義：

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {// 我們可以看到，默認只提供 sington 和 prototype 兩種，// 很多讀者可能知道還有 request, session, globalSession, application, websocket 這幾種，// 不過，它們屬于基于 web 的擴展。String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;// 比較不重要，直接跳過吧int ROLE_APPLICATION = 0;int ROLE_SUPPORT = 1;int ROLE_INFRASTRUCTURE = 2;// 設置父 Bean，這里涉及到 bean 繼承，不是 java 繼承。請參見附錄的詳細介紹// 一句話就是：繼承父 Bean 的配置信息而已void setParentName(String parentName);// 獲取父 BeanString getParentName();// 設置 Bean 的類名稱，將來是要通過反射來生成實例的void setBeanClassName(String beanClassName);// 獲取 Bean 的類名稱String getBeanClassName();// 設置 bean 的 scopevoid setScope(String scope);String getScope();// 設置是否懶加載void setLazyInit(boolean lazyInit);boolean isLazyInit();// 設置該 Bean 依賴的所有的 Bean，注意，這里的依賴不是指屬性依賴(如 @Autowire 標記的)，// 是 depends-on="" 屬性設置的值。void setDependsOn(String... dependsOn);// 返回該 Bean 的所有依賴String[] getDependsOn();// 設置該 Bean 是否可以注入到其他 Bean 中，只對根據類型注入有效，// 如果根據名稱注入，即使這邊設置了 false，也是可以的void setAutowireCandidate(boolean autowireCandidate);// 該 Bean 是否可以注入到其他 Bean 中boolean isAutowireCandidate();// 主要的。同一接口的多個實現，如果不指定名字的話，Spring 會優先選擇設置 primary 為 true 的 beanvoid setPrimary(boolean primary);// 是否是 primary 的boolean isPrimary();// 如果該 Bean 采用工廠方法生成，指定工廠名稱。對工廠不熟悉的讀者，請參加附錄// 一句話就是：有些實例不是用反射生成的，而是用工廠模式生成的void setFactoryBeanName(String factoryBeanName);// 獲取工廠名稱String getFactoryBeanName();// 指定工廠類中的 工廠方法名稱void setFactoryMethodName(String factoryMethodName);// 獲取工廠類中的 工廠方法名稱String getFactoryMethodName();// 構造器參數ConstructorArgumentValues getConstructorArgumentValues();// Bean 中的屬性值，后面給 bean 注入屬性值的時候會說到MutablePropertyValues getPropertyValues();// 是否 singletonboolean isSingleton();// 是否 prototypeboolean isPrototype();// 如果這個 Bean 是被設置為 abstract，那么不能實例化，// 常用于作為 父bean 用于繼承，其實也很少用......boolean isAbstract();int getRole();String getDescription();String getResourceDescription();BeanDefinition getOriginatingBeanDefinition(); }

這個 BeanDefinition 其實已經包含很多的信息了，暫時不清楚所有的方法對應什么東西沒關系，希望看完本文后讀者可以徹底搞清楚里面的所有東西。

這里接口雖然那么多，但是沒有類似 getInstance() 這種方法來獲取我們定義的類的實例，真正的我們定義的類生成的實例到哪里去了呢？別著急，這個要很后面才能講到。

有了 BeanDefinition 的概念以后，我們再往下看 refreshBeanFactory() 方法中的剩余部分：

customizeBeanFactory(beanFactory); loadBeanDefinitions(beanFactory);

雖然只有兩個方法，但路還很長啊。。。customizeBeanFactory(beanFactory) 比較簡單，就是配置是否允許 BeanDefinition 覆蓋、是否允許循環引用。

protected void customizeBeanFactory(DefaultListableBeanFactory beanFactory) {if (this.allowBeanDefinitionOverriding != null) {// 是否允許 Bean 定義覆蓋beanFactory.setAllowBeanDefinitionOverriding(this.allowBeanDefinitionOverriding);}if (this.allowCircularReferences != null) {// 是否允許 Bean 間的循環依賴beanFactory.setAllowCircularReferences(this.allowCircularReferences);} }

BeanDefinition 的覆蓋問題可能會有開發者碰到這個坑，就是在配置文件中定義 bean 時使用了相同的 id 或 name，默認情況下，allowBeanDefinitionOverriding 屬性為 null，如果在同一配置文件中重復了，會拋錯，但是如果不是同一配置文件中，會發生覆蓋。循環引用也很好理解：A 依賴 B，而 B 依賴 A?；?A 依賴 B，B 依賴 C，而 C 依賴 A。默認情況下，Spring 允許循環依賴，當然如果你在 A 的構造方法中依賴 B，在 B 的構造方法中依賴 A 是不行的。至于這兩個屬性怎么配置？我在附錄中進行了介紹，尤其對于覆蓋問題，很多人都希望禁止出現 Bean 覆蓋，可是 Spring 默認是不同文件的時候可以覆蓋的。之后的源碼中還會出現這兩個屬性，讀者有個印象就可以了，它們不是非常重要。

加載 Bean: loadBeanDefinitions

接下來是最重要的 loadBeanDefinitions(beanFactory) 方法了，這個方法將根據配置，加載各個 Bean，然后放到 BeanFactory 中。讀取配置的操作在 XmlBeanDefinitionReader 中，其負責加載配置、解析。// AbstractXmlApplicationContext.java 80

/** 我們可以看到，此方法將通過一個 XmlBeanDefinitionReader 實例來加載各個 Bean。*/ @Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {// 給這個 BeanFactory 實例化一個 XmlBeanDefinitionReaderXmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);// Configure the bean definition reader with this context's// resource loading environment.beanDefinitionReader.setEnvironment(this.getEnvironment());beanDefinitionReader.setResourceLoader(this);beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));// 初始化 BeanDefinitionReader，其實這個是提供給子類覆寫的，// 我看了一下，沒有類覆寫這個方法，我們姑且當做不重要吧initBeanDefinitionReader(beanDefinitionReader);// 重點來了，繼續往下loadBeanDefinitions(beanDefinitionReader); }

現在還在這個類中，接下來用剛剛初始化的 Reader 開始來加載 xml 配置，這塊代碼讀者可以選擇性跳過，不是很重要。也就是說，下面這個代碼塊，讀者可以很輕松地略過。// AbstractXmlApplicationContext.java 120

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {Resource[] configResources = getConfigResources();if (configResources != null) {// 往下看reader.loadBeanDefinitions(configResources);}String[] configLocations = getConfigLocations();if (configLocations != null) {// 2reader.loadBeanDefinitions(configLocations);} }// 上面雖然有兩個分支，不過第二個分支很快通過解析路徑轉換為 Resource 以后也會進到這里 @Override public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {Assert.notNull(resources, "Resource array must not be null");int counter = 0;// 注意這里是個 for 循環，也就是每個文件是一個 resourcefor (Resource resource : resources) {// 繼續往下看counter += loadBeanDefinitions(resource);}// 最后返回 counter，表示總共加載了多少的 BeanDefinitionreturn counter; }// XmlBeanDefinitionReader 303 @Override public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {return loadBeanDefinitions(new EncodedResource(resource)); }// XmlBeanDefinitionReader 314 public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {Assert.notNull(encodedResource, "EncodedResource must not be null");if (logger.isInfoEnabled()) {logger.info("Loading XML bean definitions from " + encodedResource.getResource());}// 用一個 ThreadLocal 來存放配置文件資源Set<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();if (currentResources == null) {currentResources = new HashSet<EncodedResource>(4);this.resourcesCurrentlyBeingLoaded.set(currentResources);}if (!currentResources.add(encodedResource)) {throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");}try {InputStream inputStream = encodedResource.getResource().getInputStream();try {InputSource inputSource = new InputSource(inputStream);if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());}// 核心部分是這里，往下面看return doLoadBeanDefinitions(inputSource, encodedResource.getResource());}finally {inputStream.close();}}catch (IOException ex) {throw new BeanDefinitionStoreException("IOException parsing XML document from " + encodedResource.getResource(), ex);}finally {currentResources.remove(encodedResource);if (currentResources.isEmpty()) {this.resourcesCurrentlyBeingLoaded.remove();}} }// 還在這個文件中，第 388 行 protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)throws BeanDefinitionStoreException {try {// 這里就不看了，將 xml 文件轉換為 Document 對象Document doc = doLoadDocument(inputSource, resource);// 繼續return registerBeanDefinitions(doc, resource);}catch (... } // 還在這個文件中，第 505 行 // 返回值：返回從當前配置文件加載了多少數量的 Bean public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();int countBefore = getRegistry().getBeanDefinitionCount();// 這里documentReader.registerBeanDefinitions(doc, createReaderContext(resource));return getRegistry().getBeanDefinitionCount() - countBefore; } // DefaultBeanDefinitionDocumentReader 90 @Override public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {this.readerContext = readerContext;logger.debug("Loading bean definitions");Element root = doc.getDocumentElement();// 從 xml 根節點開始解析文件doRegisterBeanDefinitions(root); }

經過漫長的鏈路，一個配置文件終于轉換為一顆 DOM 樹了，注意，這里指的是其中一個配置文件，不是所有的，讀者可以看到上面有個 for 循環的。下面開始從根節點開始解析：

doRegisterBeanDefinitions：

// DefaultBeanDefinitionDocumentReader 116 protected void doRegisterBeanDefinitions(Element root) {// 我們看名字就知道，BeanDefinitionParserDelegate 必定是一個重要的類，它負責解析 Bean 定義，// 這里為什么要定義一個 parent? 看到后面就知道了，是遞歸問題，// 因為 <beans /> 內部是可以定義 <beans /> 的，所以這個方法的 root 其實不一定就是 xml 的根節點，也可以是嵌套在里面的 <beans /> 節點，從源碼分析的角度，我們當做根節點就好了BeanDefinitionParserDelegate parent = this.delegate;this.delegate = createDelegate(getReaderContext(), root, parent);if (this.delegate.isDefaultNamespace(root)) {// 這塊說的是根節點 <beans ... profile="dev" /> 中的 profile 是否是當前環境需要的，// 如果當前環境配置的 profile 不包含此 profile，那就直接 return 了，不對此 <beans /> 解析// 不熟悉 profile 為何物，不熟悉怎么配置 profile 讀者的請移步附錄區String profileSpec = root.getAttribute(PROFILE_ATTRIBUTE);if (StringUtils.hasText(profileSpec)) {String[] specifiedProfiles = StringUtils.tokenizeToStringArray(profileSpec, BeanDefinitionParserDelegate.MULTI_VALUE_ATTRIBUTE_DELIMITERS);if (!getReaderContext().getEnvironment().acceptsProfiles(specifiedProfiles)) {if (logger.isInfoEnabled()) {logger.info("Skipped XML bean definition file due to specified profiles [" + profileSpec +"] not matching: " + getReaderContext().getResource());}return;}}}preProcessXml(root); // 鉤子// 往下看parseBeanDefinitions(root, this.delegate);postProcessXml(root); // 鉤子this.delegate = parent; }

preProcessXml(root) 和 postProcessXml(root) 是給子類用的鉤子方法，鑒于沒有被使用到，也不是我們的重點，我們直接跳過。這里涉及到了 profile 的問題，對于不了解的讀者，我在附錄中對 profile 做了簡單的解釋，讀者可以參考一下。接下來，看核心解析方法 parseBeanDefinitions(root, this.delegate) :

// default namespace 涉及到的就四個標簽 <import />、<alias />、<bean /> 和 <beans />， // 其他的屬于 custom 的 protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {if (delegate.isDefaultNamespace(root)) {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)) {// 解析 default namespace 下面的幾個元素parseDefaultElement(ele, delegate);}else {// 解析其他 namespace 的元素delegate.parseCustomElement(ele);}}}}else {delegate.parseCustomElement(root);} }

從上面的代碼，我們可以看到，對于每個配置來說，分別進入到 parseDefaultElement(ele, delegate); 和 delegate.parseCustomElement(ele); 這兩個分支了。parseDefaultElement(ele, delegate) 代表解析的節點是 <import />、<alias />、<bean />、<beans /> 這幾個。

這里的四個標簽之所以是 default 的，是因為它們是處于這個 namespace 下定義的：

http://www.springframework.org/schema/beans

又到初學者科普時間，不熟悉 namespace 的讀者請看下面貼出來的 xml，這里的第二行 xmlns 就是咯。

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://www.springframework.org/schema/beans"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans.xsd"default-autowire="byName">

而對于其他的標簽，將進入到 delegate.parseCustomElement(element) 這個分支。如我們經常會使用到的 <mvc />、<task />、<context />、<aop />等。

這些屬于擴展，如果需要使用上面這些 ”非 default“ 標簽，那么上面的 xml 頭部的地方也要引入相應的 namespace 和 .xsd 文件的路徑，如下所示。同時代碼中需要提供相應的 parser 來解析，如 MvcNamespaceHandler、TaskNamespaceHandler、ContextNamespaceHandler、AopNamespaceHandler 等。

假如讀者想分析 <context:property-placeholder location="classpath:xx.properties" /> 的實現原理，就應該到 ContextNamespaceHandler 中找答案。

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://www.springframework.org/schema/beans"xmlns:context="http://www.springframework.org/schema/context"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context.xsdhttp://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd "default-autowire="byName">

同理，以后你要是碰到 <dubbo /> 這種標簽，那么就應該搜一搜是不是有 DubboNamespaceHandler 這個處理類。

回過神來，看看處理 default 標簽的方法：

private void parseDefaultElement(Element ele, BeanDefinitionParserDelegate delegate) {if (delegate.nodeNameEquals(ele, IMPORT_ELEMENT)) {// 處理 <import /> 標簽importBeanDefinitionResource(ele);}else if (delegate.nodeNameEquals(ele, ALIAS_ELEMENT)) {// 處理 <alias /> 標簽定義// <alias name="fromName" alias="toName"/>processAliasRegistration(ele);}else if (delegate.nodeNameEquals(ele, BEAN_ELEMENT)) {// 處理 <bean /> 標簽定義，這也算是我們的重點吧processBeanDefinition(ele, delegate);}else if (delegate.nodeNameEquals(ele, NESTED_BEANS_ELEMENT)) {// 如果碰到的是嵌套的 <beans /> 標簽，需要遞歸doRegisterBeanDefinitions(ele);} }

如果每個標簽都說，那我不吐血，你們都要吐血了。我們挑我們的重點 <bean /> 標簽出來說。

processBeanDefinition 解析 bean 標簽

下面是 processBeanDefinition 解析 <bean /> 標簽：

// DefaultBeanDefinitionDocumentReader 298

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {// 將 <bean /> 節點中的信息提取出來，然后封裝到一個 BeanDefinitionHolder 中，細節往下看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));} }

繼續往下看怎么解析之前，我們先看下 <bean /> 標簽中可以定義哪些屬性：

Property?

class	類的全限定名
name	可指定 id、name(用逗號、分號、空格分隔)
scope	作用域
constructor arguments	指定構造參數
properties	設置屬性的值
autowiring mode	no(默認值)、byName、byType、 constructor
lazy-initialization mode	是否懶加載(如果被非懶加載的bean依賴了那么其實也就不能懶加載了)
initialization method	bean 屬性設置完成后，會調用這個方法
destruction method	bean 銷毀后的回調方法

上面表格中的內容我想大家都非常熟悉吧，如果不熟悉，那就是你不夠了解 Spring 的配置了。簡單地說就是像下面這樣子：

<bean id="exampleBean" name="name1, name2, name3" class="com.javadoop.ExampleBean"scope="singleton" lazy-init="true" init-method="init" destroy-method="cleanup"><!-- 可以用下面三種形式指定構造參數 --><constructor-arg type="int" value="7500000"/><constructor-arg name="years" value="7500000"/><constructor-arg index="0" value="7500000"/><!-- property 的幾種情況 --><property name="beanOne"><ref bean="anotherExampleBean"/></property><property name="beanTwo" ref="yetAnotherBean"/><property name="integerProperty" value="1"/> </bean>

當然，除了上面舉例出來的這些，還有 factory-bean、factory-method、<lockup-method />、<replaced-method />、<meta />、<qualifier /> 這幾個，大家是不是熟悉呢？自己檢驗一下自己對 Spring 中 bean 的了解程度。有了以上這些知識以后，我們再繼續往里看怎么解析 bean 元素，是怎么轉換到 BeanDefinitionHolder 的。

// BeanDefinitionParserDelegate 428

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele) {return parseBeanDefinitionElement(ele, null); }public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {String id = ele.getAttribute(ID_ATTRIBUTE);String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);List<String> aliases = new ArrayList<String>();// 將 name 屬性的定義按照 “逗號、分號、空格” 切分，形成一個 別名列表數組，// 當然，如果你不定義 name 屬性的話，就是空的了// 我在附錄中簡單介紹了一下 id 和 name 的配置，大家可以看一眼，有個20秒就可以了if (StringUtils.hasLength(nameAttr)) {String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);aliases.addAll(Arrays.asList(nameArr));}String beanName = id;// 如果沒有指定id, 那么用別名列表的第一個名字作為beanNameif (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {beanName = aliases.remove(0);if (logger.isDebugEnabled()) {logger.debug("No XML 'id' specified - using '" + beanName +"' as bean name and " + aliases + " as aliases");}}if (containingBean == null) {checkNameUniqueness(beanName, aliases, ele);}// 根據 <bean ...>...</bean> 中的配置創建 BeanDefinition，然后把配置中的信息都設置到實例中,// 細節后面細說，先知道下面這行結束后，一個 BeanDefinition 實例就出來了。AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);// 到這里，整個 <bean /> 標簽就算解析結束了，一個 BeanDefinition 就形成了。if (beanDefinition != null) {// 如果都沒有設置 id 和 name，那么此時的 beanName 就會為 null，進入下面這塊代碼產生// 如果讀者不感興趣的話，我覺得不需要關心這塊代碼，對本文源碼分析來說，這些東西不重要if (!StringUtils.hasText(beanName)) {try {if (containingBean != null) {// 按照我們的思路，這里 containingBean 是 null 的beanName = BeanDefinitionReaderUtils.generateBeanName(beanDefinition, this.readerContext.getRegistry(), true);}else {// 如果我們不定義 id 和 name，那么我們引言里的那個例子：// 1. beanName 為：com.javadoop.example.MessageServiceImpl#0// 2. beanClassName 為：com.javadoop.example.MessageServiceImplbeanName = this.readerContext.generateBeanName(beanDefinition);String beanClassName = beanDefinition.getBeanClassName();if (beanClassName != null &&beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {// 把 beanClassName 設置為 Bean 的別名aliases.add(beanClassName);}}if (logger.isDebugEnabled()) {logger.debug("Neither XML 'id' nor 'name' specified - " +"using generated bean name [" + beanName + "]");}}catch (Exception ex) {error(ex.getMessage(), ele);return null;}}String[] aliasesArray = StringUtils.toStringArray(aliases);// 返回 BeanDefinitionHolderreturn new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);}return null; }

然后，我們再看看怎么根據配置創建 BeanDefinition 實例的：

public AbstractBeanDefinition parseBeanDefinitionElement(Element ele, String beanName, BeanDefinition containingBean) {this.parseState.push(new BeanEntry(beanName));String className = null;if (ele.hasAttribute(CLASS_ATTRIBUTE)) {className = ele.getAttribute(CLASS_ATTRIBUTE).trim();}try {String parent = null;if (ele.hasAttribute(PARENT_ATTRIBUTE)) {parent = ele.getAttribute(PARENT_ATTRIBUTE);}// 創建 BeanDefinition，然后設置類信息而已，很簡單，就不貼代碼了AbstractBeanDefinition bd = createBeanDefinition(className, parent);// 設置 BeanDefinition 的一堆屬性，這些屬性定義在 AbstractBeanDefinition 中parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));/*** 下面的一堆是解析 <bean>......</bean> 內部的子元素，* 解析出來以后的信息都放到 bd 的屬性中*/// 解析 <meta />parseMetaElements(ele, bd);// 解析 <lookup-method />parseLookupOverrideSubElements(ele, bd.getMethodOverrides());// 解析 <replaced-method />parseReplacedMethodSubElements(ele, bd.getMethodOverrides());// 解析 <constructor-arg />parseConstructorArgElements(ele, bd);// 解析 <property />parsePropertyElements(ele, bd);// 解析 <qualifier />parseQualifierElements(ele, bd);bd.setResource(this.readerContext.getResource());bd.setSource(extractSource(ele));return bd;}catch (ClassNotFoundException ex) {error("Bean class [" + className + "] not found", ele, ex);}catch (NoClassDefFoundError err) {error("Class that bean class [" + className + "] depends on not found", ele, err);}catch (Throwable ex) {error("Unexpected failure during bean definition parsing", ele, ex);}finally {this.parseState.pop();}return null; }

到這里，我們已經完成了根據 <bean /> 配置創建了一個 BeanDefinitionHolder 實例。注意，是一個。我們回到解析 <bean /> 的入口方法:

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {// 將 <bean /> 節點轉換為 BeanDefinitionHolder，就是上面說的一堆BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);if (bdHolder != null) {// 如果有自定義屬性的話，進行相應的解析，先忽略bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);try {// 我們把這步叫做 注冊Bean 吧BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());}catch (BeanDefinitionStoreException ex) {getReaderContext().error("Failed to register bean definition with name '" +bdHolder.getBeanName() + "'", ele, ex);}// 注冊完成后，發送事件，本文不展開說這個getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));} }

大家再仔細看一下這塊吧，我們后面就不回來說這個了。這里已經根據一個 <bean /> 標簽產生了一個 BeanDefinitionHolder 的實例，這個實例里面也就是一個 BeanDefinition 的實例和它的 beanName、aliases 這三個信息，注意，我們的關注點始終在 BeanDefinition 上：

public class BeanDefinitionHolder implements BeanMetadataElement {private final BeanDefinition beanDefinition;private final String beanName;private final String[] aliases; ...

然后我們準備注冊這個 BeanDefinition，最后，把這個注冊事件發送出去。下面，我們開始說說注冊 Bean 吧。

注冊 Bean

// BeanDefinitionReaderUtils 143

public static void registerBeanDefinition(BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)throws BeanDefinitionStoreException {String beanName = definitionHolder.getBeanName();// 注冊這個 Beanregistry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());// 如果還有別名的話，也要根據別名全部注冊一遍，不然根據別名就會找不到 Bean 了String[] aliases = definitionHolder.getAliases();if (aliases != null) {for (String alias : aliases) {// alias -> beanName 保存它們的別名信息，這個很簡單，用一個 map 保存一下就可以了，// 獲取的時候，會先將 alias 轉換為 beanName，然后再查找registry.registerAlias(beanName, alias);}} }

別名注冊的放一邊，畢竟它很簡單，我們看看怎么注冊 Bean。

// DefaultListableBeanFactory 793

@Override public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {Assert.hasText(beanName, "Bean name must not be empty");Assert.notNull(beanDefinition, "BeanDefinition must not be null");if (beanDefinition instanceof AbstractBeanDefinition) {try {((AbstractBeanDefinition) beanDefinition).validate();}catch (BeanDefinitionValidationException ex) {throw new BeanDefinitionStoreException(...);}}// old? 還記得 “允許 bean 覆蓋” 這個配置嗎？allowBeanDefinitionOverridingBeanDefinition oldBeanDefinition;// 之后會看到，所有的 Bean 注冊后會放入這個 beanDefinitionMap 中oldBeanDefinition = this.beanDefinitionMap.get(beanName);// 處理重復名稱的 Bean 定義的情況if (oldBeanDefinition != null) {if (!isAllowBeanDefinitionOverriding()) {// 如果不允許覆蓋的話，拋異常throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription()...}else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {// log...用框架定義的 Bean 覆蓋用戶自定義的 Bean }else if (!beanDefinition.equals(oldBeanDefinition)) {// log...用新的 Bean 覆蓋舊的 Bean}else {// log...用同等的 Bean 覆蓋舊的 Bean，這里指的是 equals 方法返回 true 的 Bean}// 覆蓋this.beanDefinitionMap.put(beanName, beanDefinition);}else {// 判斷是否已經有其他的 Bean 開始初始化了.// 注意，"注冊Bean" 這個動作結束，Bean 依然還沒有初始化，我們后面會有大篇幅說初始化過程，// 在 Spring 容器啟動的最后，會 預初始化 所有的 singleton beansif (hasBeanCreationStarted()) {// Cannot modify startup-time collection elements anymore (for stable iteration)synchronized (this.beanDefinitionMap) {this.beanDefinitionMap.put(beanName, beanDefinition);List<String> updatedDefinitions = new ArrayList<String>(this.beanDefinitionNames.size() + 1);updatedDefinitions.addAll(this.beanDefinitionNames);updatedDefinitions.add(beanName);this.beanDefinitionNames = updatedDefinitions;if (this.manualSingletonNames.contains(beanName)) {Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames);updatedSingletons.remove(beanName);this.manualSingletonNames = updatedSingletons;}}}else {// 最正常的應該是進到這個分支。// 將 BeanDefinition 放到這個 map 中，這個 map 保存了所有的 BeanDefinitionthis.beanDefinitionMap.put(beanName, beanDefinition);// 這是個 ArrayList，所以會按照 bean 配置的順序保存每一個注冊的 Bean 的名字this.beanDefinitionNames.add(beanName);// 這是個 LinkedHashSet，代表的是手動注冊的 singleton bean，// 注意這里是 remove 方法，到這里的 Bean 當然不是手動注冊的// 手動指的是通過調用以下方法注冊的 bean ：// registerSingleton(String beanName, Object singletonObject)// 這不是重點，解釋只是為了不讓大家疑惑。Spring 會在后面"手動"注冊一些 Bean，// 如 "environment"、"systemProperties" 等 bean，我們自己也可以在運行時注冊 Bean 到容器中的this.manualSingletonNames.remove(beanName);}// 這個不重要，在預初始化的時候會用到，不必管它。this.frozenBeanDefinitionNames = null;}if (oldBeanDefinition != null || containsSingleton(beanName)) {resetBeanDefinition(beanName);} }

總結一下，到這里已經初始化了 Bean 容器，<bean /> 配置也相應的轉換為了一個個 BeanDefinition，然后注冊了各個 BeanDefinition 到注冊中心，并且發送了注冊事件。

總結

以上是生活随笔為你收集整理的Spring框架—SpringBean源码分析的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。