2. 程式人生 > >【死磕 Spring】—– IOC 之解析 bean 標籤：constructor-arg、property 子元素

【死磕 Spring】—– IOC 之解析 bean 標籤：constructor-arg、property 子元素

阿新 • • 發佈：2019-01-01

上篇部落格(【死磕 Spring】—– IOC 之解析 bean 標籤：meta、lookup-method、replace-method)分析了 meta 、 lookup-method、replace-method 三個子元素,這篇部落格分析 constructor-arg 、property、qualifier 三個子元素。

constructor-arg 子元素

舉個小栗子：

public class StudentService {
    private String name;

    private Integer age;

    private BookService bookService;

    StudentService(String name, Integer age, BookService bookService){
        this.name = name;
        this.age = age;
        this.bookService = bookService;
    }
}

    <bean id="bookService" class="org.springframework.core.service.BookService"/>

    <bean id="studentService" class="org.springframework.core.service.StudentService">
        <constructor-arg index="0" value="chenssy"/>
        <constructor-arg name="age" value="100"/>
        <constructor-arg name="bookService" ref="bookService"/>
    </bean>

StudentService 定義一個建構函式，配置檔案中使用 constructor-arg 元素對其配置，該元素可以實現對 StudentService 自動尋找對應的建構函式，並在初始化的時候將值當做引數進行設定。parseConstructorArgElements() 方法完成 constructor-arg 子元素的解析。

	public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int
 
 i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
				parseConstructorArgElement((Element) node, bd);
			}
		}
	}

遍歷所有子元素，如果為 constructor-arg 則呼叫 parseConstructorArgElement() 進行解析。

    public void
 
 parseConstructorArgElement(Element ele, BeanDefinition bd) {
        // 提取 index、type、name 屬性值
        String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
        String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
        String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);

        // 如果有index
        if (StringUtils.hasLength(indexAttr)) {
            try {
                int index = Integer.parseInt(indexAttr);
                if (index < 0) {
                    error("'index' cannot be lower than 0", ele);
                }
                else {
                    try {
                        // 構造一個 ConstructorArgumentEntry 並將其加入到 ParseState 中
                        this.parseState.push(new ConstructorArgumentEntry(index));

                        // 解析 ele 對應屬性元素
                        Object value = parsePropertyValue(ele, bd, null);

                        // 根據解析的屬性元素構造一個 valueHolder 物件
                        ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
                        if (StringUtils.hasLength(typeAttr)) {
                            valueHolder.setType(typeAttr);
                        }
                        if (StringUtils.hasLength(nameAttr)) {
                            valueHolder.setName(nameAttr);
                        }
                        //
                        valueHolder.setSource(extractSource(ele));

                        // 不允許重複指定相同引數
                        if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
                            error("Ambiguous constructor-arg entries for index " + index, ele);
                        }
                        else {
                            // 加入到 indexedArgumentValues 中國
                            bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
                        }
                    }
                    finally {
                        this.parseState.pop();
                    }
                }
            }
            catch (NumberFormatException ex) {
                error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
            }
        }
        else {
            try {
                this.parseState.push(new ConstructorArgumentEntry());
                Object value = parsePropertyValue(ele, bd, null);
                ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
                if (StringUtils.hasLength(typeAttr)) {
                    valueHolder.setType(typeAttr);
                }
                if (StringUtils.hasLength(nameAttr)) {
                    valueHolder.setName(nameAttr);
                }
                valueHolder.setSource(extractSource(ele));
                bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
            }
            finally {
                this.parseState.pop();
            }
        }
    }

首先獲取 index、type、name 三個屬性值，然後根據是否存在 index 來區分。其實兩者邏輯都差不多，總共分為如下幾個步驟（以有 index 為例）：

  1. 構造 ConstructorArgumentEntry 物件並將其加入到 ParseState 佇列中。ConstructorArgumentEntry 表示建構函式的引數。
  2. 呼叫 parsePropertyValue() 解析 constructor-arg 子元素，返回結果值
  3. 根據解析的結果值構造 ConstructorArgumentValues.ValueHolder 例項物件
  4. 將 type、name 封裝到 ConstructorArgumentValues.ValueHolder 中，然後將 ValueHolder 例項物件新增到 indexedArgumentValues 中。

無 index 的處理邏輯差不多，只有幾點不同：構造 ConstructorArgumentEntry 物件時是呼叫無參建構函式；最後是將 ValueHolder 例項新增到 genericArgumentValues 中。

parsePropertyValue() 對子元素進一步解析。

    public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
        String elementName = (propertyName != null) ?
                "<property> element for property '" + propertyName + "'" :
                "<constructor-arg> element";

        NodeList nl = ele.getChildNodes();
        Element subElement = null;
        for (int i = 0; i < nl.getLength(); i++) {
            Node node = nl.item(i);
            // meta 、description 不處理
            if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
                    !nodeNameEquals(node, META_ELEMENT)) {
                // Child element is what we're looking for.
                if (subElement != null) {
                    error(elementName + " must not contain more than one sub-element", ele);
                }
                else {
                    subElement = (Element) node;
                }
            }
        }

        // 解析 ref 元素
        boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
        // 解析 value 元素
        boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);

        // constructor-arg 子元素有兩種情況不存在
        // 1. 即存在 ref 又存在 value
        // 2. 存在 ref 或者 value，但是又有子元素
        if ((hasRefAttribute && hasValueAttribute) ||
                ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
            error(elementName +
                    " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
        }

        if (hasRefAttribute) {
            // 獲取 ref 屬性值
            String refName = ele.getAttribute(REF_ATTRIBUTE);
            if (!StringUtils.hasText(refName)) {
                error(elementName + " contains empty 'ref' attribute", ele);
            }
            // 將 ref 屬性值構造為 RuntimeBeanReference 例項物件
            RuntimeBeanReference ref = new RuntimeBeanReference(refName);
            ref.setSource(extractSource(ele));
            return ref;
        }
        else if (hasValueAttribute) {
            // 解析 value 屬性值，構造 TypedStringValue 例項物件
            TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
            valueHolder.setSource(extractSource(ele));
            return valueHolder;
        }
        else if (subElement != null) {
            // 解析子元素
            return parsePropertySubElement(subElement, bd);
        }
        else {
            // Neither child element nor "ref" or "value" attribute found.
            error(elementName + " must specify a ref or value", ele);
            return null;
        }
    }
  1. 提取 constructor-arg 子元素的 ref 和 value 的屬性值，對其進行判斷，以下兩種情況是不允許存在的
  • ref 和 value 屬性同時存在
  • 存在 ref 或者 value 且又有子元素
  1. 若存在 ref 屬性，則獲取其值並將其封裝進 RuntimeBeanReference 例項物件中
  2. 若存在 value 屬性，則獲取其值並將其封裝進 TypedStringValue 例項物件中
  3. 如果子元素不為空，則呼叫 parsePropertySubElement() 進行子元素進一步處理

對於 constructor-arg 子元素的巢狀子元素，需要呼叫 parsePropertySubElement() 進一步處理。

	public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {
		return parsePropertySubElement(ele, bd, null);
	}

	public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
		if (!isDefaultNamespace(ele)) {
			return parseNestedCustomElement(ele, bd);
		}
		else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
			BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
			if (nestedBd != null) {
				nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
			}
			return nestedBd;
		}
		else if (nodeNameEquals(ele, REF_ELEMENT)) {
			// A generic reference to any name of any bean.
			String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
			boolean toParent = false;
			if (!StringUtils.hasLength(refName)) {
				// A reference to the id of another bean in a parent context.
				refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
				toParent = true;
				if (!StringUtils.hasLength(refName)) {
					error("'bean' or 'parent' is required for <ref> element", ele);
					return null;
				}
			}
			if (!StringUtils.hasText(refName)) {
				error("<ref> element contains empty target attribute", ele);
				return null;
			}
			RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
			ref.setSource(extractSource(ele));
			return ref;
		}
		else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
			return parseIdRefElement(ele);
		}
		else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
			return parseValueElement(ele, defaultValueType);
		}
		else if (nodeNameEquals(ele, NULL_ELEMENT)) {
			// It's a distinguished null value. Let's wrap it in a TypedStringValue
			// object in order to preserve the source location.
			TypedStringValue nullHolder = new TypedStringValue(null);
			nullHolder.setSource(extractSource(ele));
			return nullHolder;
		}
		else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
			return parseArrayElement(ele, bd);
		}
		else if (nodeNameEquals(ele, LIST_ELEMENT)) {
			return parseListElement(ele, bd);
		}
		else if (nodeNameEquals(ele, SET_ELEMENT)) {
			return parseSetElement(ele, bd);
		}
		else if (nodeNameEquals(ele, MAP_ELEMENT)) {
			return parseMapElement(ele, bd);
		}
		else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
			return parsePropsElement(ele);
		}
		else {
			error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
			return null;
		}
	}

上面對各個子類進行分類處理，詳細情況如果各位有興趣可以移步原始碼進行深一步的探究。

property 子元素

我們一般使用如下方式來使用 property 子元素。

    <bean id="studentService" class="org.springframework.core.service.StudentService">
        <property name="name" value="chenssy"/>
        <property name="age" value="18"/>
    </bean>

對於 property 子元素的解析，Spring 呼叫 parsePropertyElements()。如下：

	public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
		NodeList nl = beanEle.getChildNodes();
		for (int i = 0; i < nl.getLength(); i++) {
			Node node = nl.item(i);
			if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
				parsePropertyElement((Element) node, bd);
			}
		}
	}

和 constructor-arg 子元素差不多，同樣是提取所有的 property 的子元素，然後呼叫 parsePropertyElement() 進行分析。

    public void parsePropertyElement(Element ele, BeanDefinition bd) {
        // 獲取 name 屬性
        String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
        if (!StringUtils.hasLength(propertyName)) {
            error("Tag 'property' must have a 'name' attribute", ele);
            return;
        }
        this.parseState.push(new PropertyEntry(propertyName));
        try {
            // 如果存在相同的 name
            if (bd.getPropertyValues().contains(propertyName)) {
                error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
                return;
            }

            // 解析屬性值
            Object val = parsePropertyValue(ele, bd, propertyName);
            // 根據解析的屬性值構造 PropertyValue 例項物件
            PropertyValue pv = new PropertyValue(propertyName, val);
            parseMetaElements(ele, pv);
            pv.setSource(extractSource(ele));
            // 新增到 MutablePropertyValues 中
            bd.getPropertyValues().addPropertyValue(pv);
        }
        finally {
            this.parseState.pop();
        }
    }

與解析 constructor-arg 子元素步驟差不多。呼叫 parsePropertyValue() 解析子元素屬性值，然後根據該值構造 PropertyValue 例項物件並將其新增到 BeanDefinition 中的 MutablePropertyValues 中。

相關推薦

【死磕 Spring】—– IOC 之解析 bean 標籤：constructor-arg、property 子元素

上篇部落格(【死磕 Spring】—– IOC 之解析 bean 標籤：meta、lookup-method、replace-method)分析了 meta 、 lookup-method、replace-method 三個子元素,這篇部落格分析 constr

【死磕 Spring】----- IOC 之解析 bean 標籤：開啟解析程序

import 標籤解析完畢了，再看 Spring 中最複雜也是最重要的標籤 bean 標籤的解析過程。 在方法 parseDefaultElement() 中，如果遇到標籤 為 bean 則呼叫 processBeanDefinition() 方法進行 bean 標籤解析，如下： protected

【死磕 Spring】—– IOC 之解析Bean：解析 import 標籤

在部落格【死磕Spring】----- IOC 之 註冊 BeanDefinition中分析到，Spring 中有兩種解析 Bean 的方式。如果根節點或者子節點採用預設名稱空間的話，則呼叫 parseDefaultElement() 進行預設標籤解析，否則呼叫 delegate.parseCustomEl

【死磕 Spring】----- IOC 之註冊解析的 BeanDefinition

DefaultBeanDefinitionDocumentReader.processBeanDefinition() 完成 Bean 標籤解析的核心工作，如下： protected void processBeanDefinition(Element el

【死磕 Spring】----- IOC 之 獲取驗證模型

close 步驟 call buffere n) 規範 frame create ring 原文出自：http://cmsblogs.com 在上篇博客【死磕Spring】----- IOC 之 加載 Bean 中提到，在核心邏輯方法 doLoadBeanDefinit

【死磕 Spring】----- IOC 之深入理解 Spring IoC

在一開始學習 Spring 的時候，我們就接觸 IoC 了，作為 Spring 第一個最核心的概念，我們在解讀它原始碼之前一定需要對其有深入的認識，本篇為【死磕 Spring】系列部落格的第一篇博文，主要介紹 IoC 基本概念和各個元件。 IOC 理論 Io

【死磕 Spring】----- IOC 之 獲取 Document 物件

在 XmlBeanDefinitionReader.doLoadDocument() 方法中做了兩件事情，一是呼叫 getValidationModeForResource() 獲取 XML 的驗證模式，二是呼叫 DocumentLoader.loadDocument() 獲取 Document 物件。上篇

【死磕 Spring】----- IOC 之 註冊 BeanDefinition

獲取 Document 物件後，會根據該物件和 Resource 資源物件呼叫 registerBeanDefinitions() 方法，開始註冊 BeanDefinitions 之旅。如下： pu

【死磕 Spring】----- IOC 之 IOC 初始化總結

前面 13 篇博文從原始碼層次分析了 IOC 整個初始化過程，這篇就這些內容做一個總結將其連貫起來。 在前文提過，IOC 容器的初始化過程分為三步驟：Resource 定位、BeanDefinition 的載入和解析，BeanDefinition 註冊。

spring深入學習（八）IOC 之解析 bean 標籤：meta、lookup-method、replace-method

BeanDefinition中已經完成了對 Bean 標籤屬性的解析工作，這篇博文開始分析子元素的解析。完成 Bean 標籤基本屬性解析後，會依次呼叫 parseMetaElements()、parseLookupOverrideSubElements()、parseReplacedMet

spring深入學習（七）IOC 之解析 bean 標籤：BeanDefinition

解析 bean 標籤的過程其實就是構造一個 BeanDefinition 物件的過程，<bean> 元素標籤擁有的配置屬性，BeanDefinition 均提供了相應的屬性，與之一一對應。所以我們有必要對 BeanDefinition 有一個整體的認識。 BeanDefin

spring深入學習（六） IOC 之解析 bean 標籤：開啟解析程序

import 標籤解析完畢了，再看 Spring 中最複雜也是最重要的標籤 bean 標籤的解析過程。 在方法 parseDefaultElement() 中，如果遇到標籤 為 bean 則呼叫 processBeanDefinition() 方法進行 b

spring深入學習（六） IOC 之解析 bean 標籤：開啟解析程序

import 標籤解析完畢了，再看 Spring 中最複雜也是最重要的標籤 bean 標籤的解析過程。 在方法 parseDefaultElement() 中，如果遇到標籤 為 bean 則呼叫 processBeanDefinition() 方法進行 bean 標籤解析，

spring深入學習（五） IOC 之解析Bean：解析 import 標籤

Spring 中有兩種解析 Bean 的方式。如果根節點或者子節點採用預設名稱空間的話，則呼叫 parseDefaultElement() 進行預設標籤解析，否則呼叫 delegate.parseCustomElement() 方法進行自定義解析。所以以下部落

【死磕演算法】旋轉字串判斷·kmp演算法應用

旋轉字串： 某字串str1的前面任意幾個連續字元移動到str1字串的後面，形成新的字串str2，str2即為str1的旋轉字串。 如“1234”的旋轉字串有“1234”、“2341”、“3412”、“4123”。現給定兩個字串str1，str2，判斷str2是str1的旋轉字串。 思路：

【死磕Netty】-----Netty的核心元件

在第一篇部落格中(【死磕Netty】—–NIO基礎詳解)，那一大坨的服務端、客戶端程式碼各位應該看著都會害怕。博主在 15 年寫過 NIO，那滋味的酸爽現在都還記憶猶新，而且執行後，中途還會出現異常，所以開發一個具有較好的穩定性和可靠性的 NIO 程式還是挺

【死磕JVM】——-2、Java程式碼編譯和執行的整個過程

Java程式碼編譯是由Java原始碼編譯器來完成的，流程圖如下： Java位元組碼的執行是由JVM執行引擎來完成的，流程圖如下： Java程式碼編譯和執行的整個過程包含以下三個重要機制： 1.Java程式碼編譯機制。 2.類載入機制。 3.類執行機制。 Java原始碼編

《spring原始碼解讀》 - IoC 之解析 import 標籤

![spring-framework.jpg](https://img2020.cnblogs.com/other/2024393/202009/2024393-20200902154305425-1091612735.jpg) 在上一文中我們分析了註冊 `BeanDefinition` 的過程，在其中我們

【死磕JVM】JVM快速入門之前戲篇

## 簡介 Java是一門可以跨平臺的語言，但是Java本身是不可以實現跨平臺的，需要JVM實現跨平臺。javac編譯好後的class檔案，在Windows、Linux、Mac等系統上，只要該系統安裝對應的Java虛擬機器，class檔案都可以執行。達到 ”**一次編譯，到處執行**” 的效果。 ## 什

【死磕JVM】五年 整整五年了 該知道JVM載入機制了!

## 類載入 > Java虛擬機器類載入過程是把Class類檔案載入到記憶體，並對Class檔案中的資料進行校驗、轉換解析和初始化，最終形成可以被虛擬機器直接使用的java型別的過程 和那些編譯時需要連線工作的語言不同，在Java語言裡，型別的載入，連線和初始化過程都是在程式 執行期間完成的，這種策略雖然會