3.7 spring-property 子元素的使用与解析

1.0 Property子元素的使用

　　property 子元素是再常用不过的了, 在看Spring源码之前,我们先看看它的使用方法,

1. 实例类如下:

 public class Animal {

     public String type;

     public Set<Integer> age;

     private Map<String, Integer> sell;

     public Animal() {

     }

     /**
      * @return the type
      */
     public String getType() {
         return type;
     }

     /**
      * @param type the type to set
      */
     public void setType(String type) {
         this.type = type;
     }

     /**
      * @return the age
      */
     public Set<Integer> getAge() {
         return age;
     }

     /**
      * @param age the age to set
      */
     public void setAge(Set<Integer> age) {
         this.age = age;
     }

     /**
      * @return the sell
      */
     public Map<String, Integer> getSell() {
         return sell;
     }

     /**
      * @param sell the sell to set
      */
     public void setSell(Map<String, Integer> sell) {
         this.sell = sell;
     }

     /*
      * (non-Javadoc)
      *
      * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
         return "Animal [type=" + type + ", age=" + age + ", sell=" + sell + "]";
     }

 }

xml如下,

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">

    <bean id="animal" class="test.property.Animal">
        <property name="type" value="cat"></property>
        <property name="age">
            <set>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </set>
        </property>
        <property name="sell">
            <map>
                <entry key="blue" value="111"></entry>
                <entry key="red" value="22"></entry>
            </map>
        </property>
    </bean>
</beans> 

测试类如下:

 public class Main {

     public static String XML_PATH = "test\\property\\applicationContxt.xml";

     public static void main(String[] args) {
         try {
             Resource resource = new ClassPathResource(XML_PATH);
             XmlBeanFactory beanFactory = new XmlBeanFactory(resource);
             Animal bean = (Animal) beanFactory.getBean("animal");
             System.out.println(bean);
         }
         catch (Exception e) {
             e.printStackTrace();
         }
     }
 }

控制台输出的结果为

Animal [type=cat, age=[1, 2, 3], sell={blue=111, red=22}]

2.0 Spring具体的解析过程为:

　　2.1

 /**
      * Parse property sub-elements of the given bean element.
      */
     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);
             }
         }
     }

　　2.2

 /**
      * Parse a property element.
      */
     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 {
             // 不容许多次对同一属性配置
             if (bd.getPropertyValues().contains(propertyName)) {
                 error("Multiple 'property' definitions for property '" + propertyName
                         + "'", ele);
                 return;
             }
             Object val = parsePropertyValue(ele, bd, propertyName);
             PropertyValue pv = new PropertyValue(propertyName, val);
             parseMetaElements(ele, pv);
             pv.setSource(extractSource(ele));
             bd.getPropertyValues().addPropertyValue(pv);
         }
         finally {
             this.parseState.pop();
         }
     }

　　2.3 然后又回到parsePropertyValue 方法了

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

         // Should only have one child element: ref, value, list, etc.
         // 应该只有一个子元素：REF，值，列表等。
         NodeList nl = ele.getChildNodes();
         Element subElement = null;
         for (int i = 0; i < nl.getLength(); i++) {
             Node node = nl.item(i);
             // 对应的description 或者meta不处理
             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);
         if ((hasRefAttribute && hasValueAttribute)
                 || ((hasRefAttribute || hasValueAttribute) && subElement != null)) {
             /*
              * 1.不能同时有ref 又有 value 2.不能存在ref 或者 value 又有子元素
              */
             error(elementName
                     + " is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element",
                     ele);
         }

         if (hasRefAttribute) {
             String refName = ele.getAttribute(REF_ATTRIBUTE);
             if (!StringUtils.hasText(refName)) {
                 error(elementName + " contains empty 'ref' attribute", ele);
             }
             // ref 属性的处理 , 使用RuntimeBeanReference封装对应的ref名称
             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.
             // 对于没有ref 也没有子元素的,Spring只好丢出异常
             error(elementName + " must specify a ref or value", ele);
             return null;
         }
     }

这里之前构造函数的解析那里已经讲得很详细了,这里不多做解释,不同的是返回值使用PropertyValue 封装,并且记录在BeanDefinition 的 propertyValues属性当中.