歡迎光臨
每天分享高質量文章
當前位置：知識星球 > 後端 > 正文

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

2018-09-26 分類：後端 閱讀(336) 評論(0)

點選上方“Java技術驛站”，選擇“置頂公眾號”。

有內涵、有價值的文章第一時間送達！

精品專欄

 

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

constructor-arg 子元素

舉個小慄子：

  1. public class StudentService {
  2.     private String name;
  4.     private Integer age;
  6.     private BookService bookService;
  8.     StudentService(String name, Integer age, BookService bookService){
  9.         this.name = name;
  10.         this.age = age;
  11.         this.bookService = bookService;
  12.     }
  13. }
  15.     "bookService" class="org.springframework.core.service.BookService"/>
  17.     "studentService" class="org.springframework.core.service.StudentService">
  18.         "0" value="chenssy"/>
  19.         "age" value="100"/>
  20.         "bookService" ref="bookService"/>
  21.     

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

  1.     public void parseConstructorArgElements(Element beanEle, BeanDefinition bd) {
  2.         NodeList nl = beanEle.getChildNodes();
  3.         for (int i = 0; i < nl.getLength(); i++) {
  4.             Node node = nl.item(i);
  5.             if (isCandidateElement(node) && nodeNameEquals(node, CONSTRUCTOR_ARG_ELEMENT)) {
  6.                 parseConstructorArgElement((Element) node, bd);
  7.             }
  8.         }
  9.     }

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

  1.     public void parseConstructorArgElement(Element ele, BeanDefinition bd) {
  2.         // 提取 index、type、name 屬性值
  3.         String indexAttr = ele.getAttribute(INDEX_ATTRIBUTE);
  4.         String typeAttr = ele.getAttribute(TYPE_ATTRIBUTE);
  5.         String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
  7.         // 如果有index
  8.         if (StringUtils.hasLength(indexAttr)) {
  9.             try {
  10.                 int index = Integer.parseInt(indexAttr);
  11.                 if (index < 0) {
  12.                     error("'index' cannot be lower than 0", ele);
  13.                 }
  14.                 else {
  15.                     try {
  16.                         // 構造一個 ConstructorArgumentEntry 並將其加入到 ParseState 中
  17.                         this.parseState.push(new ConstructorArgumentEntry(index));
  19.                         // 解析 ele 對應屬性元素
  20.                         Object value = parsePropertyValue(ele, bd, null);
  22.                         // 根據解析的屬性元素構造一個 valueHolder 物件
  23.                         ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
  24.                         if (StringUtils.hasLength(typeAttr)) {
  25.                             valueHolder.setType(typeAttr);
  26.                         }
  27.                         if (StringUtils.hasLength(nameAttr)) {
  28.                             valueHolder.setName(nameAttr);
  29.                         }
  30.                         //
  31.                         valueHolder.setSource(extractSource(ele));
  33.                         // 不允許重覆指定相同引數
  34.                         if (bd.getConstructorArgumentValues().hasIndexedArgumentValue(index)) {
  35.                             error("Ambiguous constructor-arg entries for index " + index, ele);
  36.                         }
  37.                         else {
  38.                             // 加入到 indexedArgumentValues 中國
  39.                             bd.getConstructorArgumentValues().addIndexedArgumentValue(index, valueHolder);
  40.                         }
  41.                     }
  42.                     finally {
  43.                         this.parseState.pop();
  44.                     }
  45.                 }
  46.             }
  47.             catch (NumberFormatException ex) {
  48.                 error("Attribute 'index' of tag 'constructor-arg' must be an integer", ele);
  49.             }
  50.         }
  51.         else {
  52.             try {
  53.                 this.parseState.push(new ConstructorArgumentEntry());
  54.                 Object value = parsePropertyValue(ele, bd, null);
  55.                 ConstructorArgumentValues.ValueHolder valueHolder = new ConstructorArgumentValues.ValueHolder(value);
  56.                 if (StringUtils.hasLength(typeAttr)) {
  57.                     valueHolder.setType(typeAttr);
  58.                 }
  59.                 if (StringUtils.hasLength(nameAttr)) {
  60.                     valueHolder.setName(nameAttr);
  61.                 }
  62.                 valueHolder.setSource(extractSource(ele));
  63.                 bd.getConstructorArgumentValues().addGenericArgumentValue(valueHolder);
  64.             }
  65.             finally {
  66.                 this.parseState.pop();
  67.             }
  68.         }
  69.     }

首先獲取 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() 對子元素進一步解析。

  1.     public Object parsePropertyValue(Element ele, BeanDefinition bd, @Nullable String propertyName) {
  2.         String elementName = (propertyName != null) ?
  3.                 " element for property '" + propertyName + "'" :
  4.                 " element";
  6.         NodeList nl = ele.getChildNodes();
  7.         Element subElement = null;
  8.         for (int i = 0; i < nl.getLength(); i++) {
  9.             Node node = nl.item(i);
  10.             // meta 、description 不處理
  11.             if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&
  12.                     !nodeNameEquals(node, META_ELEMENT)) {
  13.                 // Child element is what we're looking for.
  14.                 if (subElement != null) {
  15.                     error(elementName + " must not contain more than one sub-element", ele);
  16.                 }
  17.                 else {
  18.                     subElement = (Element) node;
  19.                 }
  20.             }
  21.         }
  23.         // 解析 ref 元素
  24.         boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);
  25.         // 解析 value 元素
  26.         boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);
  28.         // constructor-arg 子元素有兩種情況不存在
  29.         // 1. 即存在 ref 又存在 value
  30.         // 2. 存在 ref 或者 value，但是又有子元素
  31.         if ((hasRefAttribute && hasValueAttribute) ||
  32.                 ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
  33.             error(elementName +
  34.                     " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);
  35.         }
  37.         if (hasRefAttribute) {
  38.             // 獲取 ref 屬性值
  39.             String refName = ele.getAttribute(REF_ATTRIBUTE);
  40.             if (!StringUtils.hasText(refName)) {
  41.                 error(elementName + " contains empty 'ref' attribute", ele);
  42.             }
  43.             // 將 ref 屬性值構造為 RuntimeBeanReference 實體物件
  44.             RuntimeBeanReference ref = new RuntimeBeanReference(refName);
  45.             ref.setSource(extractSource(ele));
  46.             return ref;
  47.         }
  48.         else if (hasValueAttribute) {
  49.             // 解析 value 屬性值，構造 TypedStringValue 實體物件
  50.             TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));
  51.             valueHolder.setSource(extractSource(ele));
  52.             return valueHolder;
  53.         }
  54.         else if (subElement != null) {
  55.             // 解析子元素
  56.             return parsePropertySubElement(subElement, bd);
  57.         }
  58.         else {
  59.             // Neither child element nor "ref" or "value" attribute found.
  60.             error(elementName + " must specify a ref or value", ele);
  61.             return null;
  62.         }
  63.     }

  1. 提取 constructor-arg 子元素的 ref 和 value 的屬性值，對其進行判斷，以下兩種情況是不允許存在的

  • ref 和 value 屬性同時存在

  • 存在 ref 或者 value 且又有子元素

  1. 若存在 ref 屬性，則獲取其值並將其封裝進 RuntimeBeanReference 實體物件中

  2. 若存在 value 屬性，則獲取其值並將其封裝進 TypedStringValue 實體物件中

  3. 如果子元素不為空，則呼叫 parsePropertySubElement() 進行子元素進一步處理

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

  1.     public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd) {
  2.         return parsePropertySubElement(ele, bd, null);
  3.     }
  5.     public Object parsePropertySubElement(Element ele, @Nullable BeanDefinition bd, @Nullable String defaultValueType) {
  6.         if (!isDefaultNamespace(ele)) {
  7.             return parseNestedCustomElement(ele, bd);
  8.         }
  9.         else if (nodeNameEquals(ele, BEAN_ELEMENT)) {
  10.             BeanDefinitionHolder nestedBd = parseBeanDefinitionElement(ele, bd);
  11.             if (nestedBd != null) {
  12.                 nestedBd = decorateBeanDefinitionIfRequired(ele, nestedBd, bd);
  13.             }
  14.             return nestedBd;
  15.         }
  16.         else if (nodeNameEquals(ele, REF_ELEMENT)) {
  17.             // A generic reference to any name of any bean.
  18.             String refName = ele.getAttribute(BEAN_REF_ATTRIBUTE);
  19.             boolean toParent = false;
  20.             if (!StringUtils.hasLength(refName)) {
  21.                 // A reference to the id of another bean in a parent context.
  22.                 refName = ele.getAttribute(PARENT_REF_ATTRIBUTE);
  23.                 toParent = true;
  24.                 if (!StringUtils.hasLength(refName)) {
  25.                     error("'bean' or 'parent' is required for  element", ele);
  26.                     return null;
  27.                 }
  28.             }
  29.             if (!StringUtils.hasText(refName)) {
  30.                 error(" element contains empty target attribute", ele);
  31.                 return null;
  32.             }
  33.             RuntimeBeanReference ref = new RuntimeBeanReference(refName, toParent);
  34.             ref.setSource(extractSource(ele));
  35.             return ref;
  36.         }
  37.         else if (nodeNameEquals(ele, IDREF_ELEMENT)) {
  38.             return parseIdRefElement(ele);
  39.         }
  40.         else if (nodeNameEquals(ele, VALUE_ELEMENT)) {
  41.             return parseValueElement(ele, defaultValueType);
  42.         }
  43.         else if (nodeNameEquals(ele, NULL_ELEMENT)) {
  44.             // It's a distinguished null value. Let's wrap it in a TypedStringValue
  45.             // object in order to preserve the source location.
  46.             TypedStringValue nullHolder = new TypedStringValue(null);
  47.             nullHolder.setSource(extractSource(ele));
  48.             return nullHolder;
  49.         }
  50.         else if (nodeNameEquals(ele, ARRAY_ELEMENT)) {
  51.             return parseArrayElement(ele, bd);
  52.         }
  53.         else if (nodeNameEquals(ele, LIST_ELEMENT)) {
  54.             return parseListElement(ele, bd);
  55.         }
  56.         else if (nodeNameEquals(ele, SET_ELEMENT)) {
  57.             return parseSetElement(ele, bd);
  58.         }
  59.         else if (nodeNameEquals(ele, MAP_ELEMENT)) {
  60.             return parseMapElement(ele, bd);
  61.         }
  62.         else if (nodeNameEquals(ele, PROPS_ELEMENT)) {
  63.             return parsePropsElement(ele);
  64.         }
  65.         else {
  66.             error("Unknown property sub-element: [" + ele.getNodeName() + "]", ele);
  67.             return null;
  68.         }
  69.     }

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

property 子元素

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

  1.      id="studentService" class="org.springframework.core.service.StudentService">
  2.          name="name" value="chenssy"/>
  3.          name="age" value="18"/>
  4.     

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

  1.     public void parsePropertyElements(Element beanEle, BeanDefinition bd) {
  2.         NodeList nl = beanEle.getChildNodes();
  3.         for (int i = 0; i < nl.getLength(); i++) {
  4.             Node node = nl.item(i);
  5.             if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {
  6.                 parsePropertyElement((Element) node, bd);
  7.             }
  8.         }
  9.     }

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

  1.     public void parsePropertyElement(Element ele, BeanDefinition bd) {
  2.         // 獲取 name 屬性
  3.         String propertyName = ele.getAttribute(NAME_ATTRIBUTE);
  4.         if (!StringUtils.hasLength(propertyName)) {
  5.             error("Tag 'property' must have a 'name' attribute", ele);
  6.             return;
  7.         }
  8.         this.parseState.push(new PropertyEntry(propertyName));
  9.         try {
  10.             // 如果存在相同的 name
  11.             if (bd.getPropertyValues().contains(propertyName)) {
  12.                 error("Multiple 'property' definitions for property '" + propertyName + "'", ele);
  13.                 return;
  14.             }
  16.             // 解析屬性值
  17.             Object val = parsePropertyValue(ele, bd, propertyName);
  18.             // 根據解析的屬性值構造 PropertyValue 實體物件
  19.             PropertyValue pv = new PropertyValue(propertyName, val);
  20.             parseMetaElements(ele, pv);
  21.             pv.setSource(extractSource(ele));
  22.             // 新增到 MutablePropertyValues 中
  23.             bd.getPropertyValues().addPropertyValue(pv);
  24.         }
  25.         finally {
  26.             this.parseState.pop();
  27.         }
  28.     }

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

            

往
期
精
彩

【死磕 Spring】—– IOC 之解析 bean 標簽：meta、lookup-method、replace-method）

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

【死磕 Spring】----- IOC 之解析 bean 標簽：BeanDefinition

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

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

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

【死磕 Spring】----- IOC 之 Spring 統一資源載入策略

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

END

我是 Java 技術驛站，感謝有你

贊(0)
標籤：

相關推薦

熱門標籤

iOS (11238)微軟 (4955)Linux (4274)安全 (4180)Python (4161)效能 (3165)運維 (2774)最佳化 (2419).NET (2262)Google (2136)機器學習 (1795)併發 (1613)分散式 (1559)叢集 (1240)SQL (1174)Mysql (1060)區塊鏈 (1017)Docker (977)微服務 (922)面試 (919)Apache (743)NLP (725)Redis (719)Android (668)Git (640)架構師 (632)Nginx (630)Facebook (599)JVM (595)爬蟲 (476)

熱門文章

分享創造快樂

© 2024 知識星球   網站地圖