天天看點
傳回

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

上篇部落格( 【死磕 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. <bean id="bookService" class="org.springframework.core.service.BookService"/>

  17. <bean id="studentService" class="org.springframework.core.service.StudentService">

  18. <constructor-arg index="0" value="chenssy"/>

  19. <constructor-arg name="age" value="100"/>

  20. <constructor-arg name="bookService" ref="bookService"/>

  21. </bean>

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. "<property> element for property '" + propertyName + "'" :

  4. "<constructor-arg> 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 <ref> element", ele);

  26. return null;

  27. }

  28. }

  29. if (!StringUtils.hasText(refName)) {

  30. error("<ref> 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. <bean id="studentService" class="org.springframework.core.service.StudentService">

  2. <property name="name" value="chenssy"/>

  3. <property name="age" value="18"/>

  4. </bean>

對于 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 中。

原文釋出時間為：2018-09-26

本文作者：Java技術驿站

本文來自雲栖社群合作夥伴“

Java技術驿站

”，了解相關資訊可以關注“

”。

java spring spring java分析 spring java問題 java spring錯誤 mapping無效java java spring緩存
上一篇: IdentityServer4實戰 - 談談 JWT Token 的安全政策
下一篇: 【死磕 Spring】----- IOC 之解析 bean 标簽：解析自定義标簽

繼續閱讀