package com.tear.ioc.bean.xml.element.loader;import java.util.Collection;import org.dom4j.Document;import org.dom4j.Element;/** * 载入一个Document对象的所有Element提供保存 * @author rongdi */public interface ElementLoader {    /**     * 加入一个Document对象的所有Element     *      * @param document     */    public void addBeanElements(Document document);    /**     * 根据元素的id获得Element对象     *      * @param id     * @return     */    public Element getBeanElement(String id);    /**     * 返回全部的Element     *      * @return     */    public Collection<Element> getBeanElements();}

package com.tear.ioc.bean.xml.element.loader;import java.util.Collection;import java.util.HashMap;import java.util.List;import java.util.Map;import org.dom4j.Document;import org.dom4j.Element;public class ElementLoaderImpl implements ElementLoader {    /**     * 定义一个Map来保存一个Document对象中根节点（beans）下所有Element对象     * Map的key对应bean元素的id属性，而Map的value对应bean元素     */    Map<String,Element> beanElements = new HashMap<String,Element>();    /**     * 将一个Document对象的所有Element加入到保存Element对象的Map中     * @param document     */    @Override    public void addBeanElements(Document document) {        /**         * 先得到根节点beans再得到bean节点         */        @SuppressWarnings("unchecked")        List<Element> elementList = document.getRootElement().elements();        /**         * 循环将所有的元素的id属性和元素一一对应的加入到Map中         */        for(Element e:elementList) {            /**             * 得到元素的id属性             */            String id = e.attributeValue("id");            /**             * 将id属性和该元素一起添加到Map中             */            this.beanElements.put(id, e);        }    }    @Override    public Element getBeanElement(String id) {        /**         * 根据id从保存所有元素的Map中取出对应的元素         */        return beanElements.get(id);    }    @Override    public Collection<Element> getBeanElements() {        /**         * 得到保存所有元素的Map中的所有value的集合，也就是所有的元素的集合         */        return beanElements.values();    }}

package com.rongdi.ioc.xml.element.parser;import java.util.List;import org.dom4j.Element;import com.rongdi.ioc.xml.autowire.Autowire;import com.rongdi.ioc.xml.element.LeafElement;import com.rongdi.ioc.xml.element.PropertyElement;/** * 这是解析装载的element的接口，提供一系列的方法 * @author rongdi * */public interface BeanElementParser {    /**     * 判断一个bean元素是否需要延迟加载     * @param element     * @return     */    public boolean isLazy(Element beanElement);        /**     * 获得一个bean元素下的constructor-arg（构造方法参数）的子标签     * @param element     * @return     */    public List<Element> getConstructorArgsElements(Element bean);        /**     * 得到元素属性为name的属性值     * @param element     * @param name     * @return     */    public String getAttribute(Element element, String name);        /**     * 判断一个bean元素是否配置为单态     * @param element     * @return     */    public boolean isSingleton(Element bean);        /**     * 获得一个bean元素下所有property元素     * @param element     * @return     */    public List<Element> getPropertyElements(Element bean);        /**     * 返回一个bean元素对应的Autowire对象     * @param element     * @return     */    public Autowire getAutowire(Element bean);        /**     * 获取bean元素下所有constructor-arg的值(包括value和ref)     * @param element     * @return     */    public List<LeafElement> getConstructorValue(Element bean);        /**     * 获取bean元素下所有property元素的值(包括value和ref)     * @param element     * @return     */    List<PropertyElement> getPropertyValue(Element bean);}

<bean id="test12" class="com.rongdi.Test17">        <property name="property1">            <value type="java.lang.String">rongdi</value>        </property>        <property name="property2">            <ref bean="test13"/>        </property>        <property name="property3">            <value type="java.lang.Integer">22</value>        </property>        <property name="property4">            <collection type="list">                <value type="java.lang.Integer">1212</value>                <value type="java.lang.String">rongdi</value>            </collection>        </property>    </bean>

package com.tear.ioc.bean.xml.element;/** * 这是代表ref标签的节点元素，实现了LeafElement接口 * @author rongdi */public class RefElement implements LeafElement {    /**     * 定义一个成员变量用来保存ref元素的value值，也就是开始标签和结束标签之间的值     */    private Object value;    /**     * 用构造方法将ref元素的value值传给成员变量保存     * @param value     */    public RefElement(Object value) {        this.value =http://www.mamicode.com/ value;    }    /**     * 重写接口中的getType方法，返回自己的类型，由于该类型是ref的所以可以直接返回ref     */    @Override    public String getType() {        return "ref";    }    /**     * 重写自接口的getValue方法，返回元素的value值该value已经通过构造方法保存到成员变量     * 中了，所以直接返回该成员变量就可以了     */    @Override    public Object getValue() {                return this.value;    }}

package com.tear.ioc.bean.xml.element;/** * 这是代表value标签的节点元素，实现了LeafElement接口 * @author rongdi */public class ValueElement implements LeafElement {    /**     * 同RefNodeElement元素一样也要提供一个成员变量保存元素之间的value值     */    private Object value;    /**     * 用构造方法将value元素的value值传给成员变量保存     * @param value     */    public ValueElement(Object value) {        this.value =http://www.mamicode.com/ value;    }    /**     * 重写接口中的getType方法，返回自己的类型，由于该类型是value的所以可以直接返回value字符串     */    @Override    public String getType() {                return "value";    }    /**     * 重写自接口的getValue方法，返回元素的value值该value已经通过构造方法保存到成员变量     * 中了，所以直接返回该成员变量就可以了     */    @Override    public Object getValue() {            return this.value;    }}

package com.tear.ioc.bean.xml.element;/** * 这是ref和value节点元素的上层元素，该元素可能包含ref或者是value子元素 * @author rongdi * */public class PropertyElement {    /**     * 用来保存property元素的name属性值     */    private String name;    /**     * 用来保存Property元素下的ref或者是value子元素     */    private LeafElement leafElement;    /**     * 取出property元素的name属性值的方法     * @return     */    public String getName() {        return name;    }    /**     * 设置property元素的name属性值的方法     * @param name     */    public void setName(String name) {        this.name = name;    }    /**     * 取出property元素下面的子元素的方法，返回子元素的接口类型     * @return     */    public LeafElement getLeafElement() {        return leafElement;    }    /**     * 设置property元素下面的子元素的方法     * @param nodeElement     */    public void setLeafElement(LeafElement leafElement) {        this.leafElement = leafElement;    }    /**     * 构造方法将property元素的name值和下面的子元素保存到成员变量中     * @param name     * @param leafElement     */    public PropertyElement(String name, LeafElement leafElement) {        this.name = name;        this.leafElement = leafElement;    }}

package com.tear.ioc.bean.xml.autowire;/** * 这是代表自动装配的接口 * @author rongdi */public interface Autowire {    /**     * 返回类中需要自动装配的类型的值     * @return     */    public String getType();}

package com.tear.ioc.bean.xml.autowire;/** * 根据姓名自动装配的类，实现自动装配的接口 * @author rongdi * */public class ByNameAutowire implements Autowire {    /**     * 用一个构造方法保存传入的自动装配的类型值     */    private String type;    public ByNameAutowire(String type) {        this.type = type;    }    /**     * 返回传入的需要自动装配的value值     */    public String getType() {        return type;    }}

package com.tear.ioc.bean.xml.autowire;/** * 这个类代表不自动装配的类 * @author rongdi * */public class NoAutowire implements Autowire {        @SuppressWarnings("unused")    private String type;    public NoAutowire(String type) {        this.type = type;    }    /**     * 直接返回no，表示不需要自动装配     */    public String getType() {        return "no";    }}

<bean id="test2" class="com.xx.Test4">     <constructor-arg>         <value type="java.lang.String">xx</value>     </constructor-arg>     <constructor-arg>         <value type="java.lang.String">12</value>     </constructor-arg></bean>

package com.tear.ioc.bean.xml.element.parser;import java.util.ArrayList;import java.util.List;import org.dom4j.Element;import com.tear.ioc.bean.xml.autowire.Autowire;import com.tear.ioc.bean.xml.autowire.ByNameAutowire;import com.tear.ioc.bean.xml.autowire.NoAutowire;import com.tear.ioc.bean.xml.element.CollectionElement;import com.tear.ioc.bean.xml.element.LeafElement;import com.tear.ioc.bean.xml.element.PropertyElement;import com.tear.ioc.bean.xml.element.RefElement;import com.tear.ioc.bean.xml.element.ValueElement;public class BeanElementParserImpl implements BeanElementParser {    /**     * 判断某一个元素（bean）是否需要延迟加载     */    @Override    public boolean isLazy(Element beanElement) {        /**         * 得到该元素的lazy-init属性         */        String elementLazy = this.getAttribute(beanElement, "lazy-init");        /**         * 得到该元素的上层元素（beans）         */        Element parentElement = beanElement.getParent();        /**         * 得到该元素的上层元素（beans）的default-lazy-init属性         */        Boolean parentElementLazy = new Boolean(this.getAttribute(parentElement, "default-lazy-init"));        if (parentElementLazy) {            /**             * 在根元素需要延迟加载的情况下，子节点（bean）不需要延迟那么不延迟加载             */            if ("false".equals(elementLazy)) {                return false;            }            /**             * 子节点需要延迟加载那么就延迟加载             */            return true;        } else {            /**             * 根节点不需要延迟加载的情况下，子节点需要延迟加载那么就延迟加载             */            if ("true".equals(elementLazy)) {                return true;            }            /**             * 根节点不需要延迟加载的情况下，子节点也不需要延迟加载那么就不延迟加载             */            return false;        }            }    /**     * 得到bean元素下的所有的构造方法参数的元素constructor-arg     */    @SuppressWarnings("unchecked")    @Override    public List<Element> getConstructorArgsElements(Element element) {        /**         * 得到该元素的所有子元素         */        List<Element> children = element.elements();        /**         * 定义一个保存所需要的元素的ArrayList集合         */        List<Element> result = new ArrayList<Element>();        /**         * 遍历所有子元素，若果是constructor-arg元素直接加入到定义的ArrayList         * 集合中         */        for (Element e : children) {            if ("constructor-arg".equals(e.getName())) {                result.add(e);            }        }        /**         * 返回所有的constructor-arg元素的集合         */        return result;    }    /**     * 得到元素的name属性值     */    @Override    public String getAttribute(Element element, String name) {        String value = element.attributeValue(name);        return value;    }    /**     * 判断元素（bean）是否为单例的     */    @Override    public boolean isSingleton(Element element) {        /**         * 如果元素的singleton属性为true（忽略大小写），那么返回true，         * 如果是其他的字符串或者是空则返回false         */        Boolean singleton = new Boolean(this.getAttribute(element, "singleton"));        return singleton;    }    /**     * 得到某个元素（bean）下的所有property元素     */    @SuppressWarnings("unchecked")    @Override    public List<Element> getPropertyElements(Element element) {        /**         * 得到该元素的所有子元素         */        List<Element> children = element.elements();        /**         * 定义一个保存所需要的元素的ArrayList集合         */        List<Element> result = new ArrayList<Element>();            /**         * 遍历所有子元素，若果是property元素直接加入到定义的ArrayList         * 集合中         */        for (Element e : children) {            if("property".equals(e.getName())) {                result.add(e);            }        }        /**         * 返回所有的Property元素的集合         */        return result;    }    /**     * 得到某个元素（bean）的传入了自动装配类型值的对象     */    @Override    public Autowire getAutowire(Element element) {        /**         * 得到某个元素（bean）的自动装配的类型值         */        String type = this.getAttribute(element, "autowire");        /**         * 得到该元素的父元素（beans）的默认的自动装配类型值         */        String parentType = this.getAttribute(element.getParent(), "default-autowire");        if ("no".equals(parentType)) {            /**             * 如果根节点不需要自动装配，子节点需要以name自动装配那么返回一个以name自动装配的             * ByNameAutowire对象             */            if ("byName".equals(type)) {                return new ByNameAutowire(type);            }            /**             * 如果父节点和子节点都不需要自动装配那么就返回一个表示不需要自动装配的NoAutowire对象             */            return new NoAutowire(type);        } else if ("byName".equals(parentType)) {            /**             * 如果根节点需要自动装配而子节点不需要自动装配那么返回一个代表不需要自动装配的NoAutowire             * 对象             */            if ("no".equals(type)) {                return new NoAutowire(type);            }            /**             * 如果根节点需要自动装配子节点也需要自动装配那么返回一个代表需要以name自动装配的             *  ByNameAutowire对象             */            return new ByNameAutowire(type);        }        /**         * 其他情况返回一个不需要自动装配的对象         */        return new NoAutowire(type);    }    /**     * 得到所有的构造方法参数元素中的参数值，也就是ref或value元素     */    @SuppressWarnings("unchecked")    @Override    public List<LeafElement> getConstructorValue(Element element) {        /**         * 调用本类中的getConstructorElements方法取得全部的constructor-arg元素         */        List<Element> cons = this.getConstructorArgsElements(element);        /**         * 定义一个保存所有需要元素的ArrayList         */        List<LeafElement> result = new ArrayList<LeafElement>();        /**         * 遍历所有的construct-arg元素         */        for (Element e : cons) {            /**             * 获得constructor-arg下的ref元素或者value元素的其中一个，dtd定义两个元素             * 只能有其中一个             */            List<Element> eles = e.elements();            /**             * 调用本类定义的getLeafElement方法获得构造参数元素下的ref或者value元素，封装成             * RefLeafElement或ValueLeafElement             */            LeafElement leafElement = this.getLeafElement(eles.get(0));            /**             * 将封装好的RefLeafElement或ValueLeafElement元素加入到ArrayList中             */            result.add(leafElement);        }        /**         * 返回NodeList的集合，里面装的是RefLeafElement或ValueLeafElement元素         */        return result;    }    @SuppressWarnings("unchecked")    @Override    public List<PropertyElement> getPropertyValue(Element element) {        /**         * 得到某一个元素下的所有property元素         */        List<Element> properties = this.getPropertyElements(element);        /**         * 定义一个ArrayList的集合准备保存所需要的Property元素         */        List<PropertyElement> result = new ArrayList<PropertyElement>();        /**         * 遍历所有的Property元素         */        for (Element e : properties) {            /**             * 获得property下的ref元素或者value元素或者collection中的一个，因为三个元素是互斥的只能存在一个             */            List<Element> eles = e.elements();            /**             * 得到List中的第一个ref元素或者是value元素             */            LeafElement leafElement = getLeafElement(eles.get(0));            /**             * 得到property的name属性的值             */            String propertyNameAtt = this.getAttribute(e, "name");            /**             * 将数据值和property元素的name属性封装成PropertyElement对象             */            PropertyElement pe = new PropertyElement(propertyNameAtt, leafElement);            /**             * 将该PreopertyElement元素加入到ArrayList中             */            result.add(pe);        }        /**         * 返回PropertyElement元素的集合         */        return result;    }    /**     * 该方法是根据传过来的Element对象将其封装成RefNodeElement或ValueNodeElement元素     * 的对象     * @param nodeElement     * @return     */    private LeafElement getLeafElement(Element leafElement) {        /**         * 获得传过来的Element元素的名字         */        String name = leafElement.getName();        /**         * 如果是value元素         */        if ("value".equals(name)) {                        /**             *调用本类定义的方法getValueOfValueElement根据value的type类型返回一个             *Object数组形式的value值，在构造成为一个ValueElement对象返回             */            return new ValueElement(this.getValueOfValueElement(leafElement));        }        /**         * 如果是ref元素         */        else if("ref".equals(name)) {            /**             * 返回一个将ref元素的bean属性的值传入的RefNodeElement对象             */            return new RefElement(this.getAttribute(leafElement, "bean"));        }        /**         * 如果是collection元素         */        else if("collection".equals(name)) {            /**             * 调用本类的方法getCollectionElement得到一个CollectionElement元素返回             */            return this.getCollectionElement(leafElement);        }        /**         * 如果不是这两种元素则返回null         */        return null;    }    /**     * 这是一个ValueElement的值的Object数组     * @param leafElement     * @return     */    private Object getValueOfValueElement(Element leafElement) {        /**         * 得到该value元素的type属性的值         */        String typeName = leafElement.attributeValue("type");        /**         * 得到该value元素的值（即value标签之间的那个值）         */        String data = leafElement.getText();        /**         * 调用本类的方法返回一个ValueElement的值的数组形式         */        return IocUtil.getValue(typeName, data);    }    /**     * 这是根据传过来的一个leafElement元素构造一个CollectionElement元素返回     * @param leafElement     * @return     */    @SuppressWarnings("unchecked")    private CollectionElement getCollectionElement(Element leafElement) {        /**         * 定义一个保存所需的LeafElement元素的集合         */        List<LeafElement> temp = new ArrayList<LeafElement>();        /**         * 先得到该Collection元素的type属性值         */        String typeName = leafElement.attributeValue("type");        /**         * 根据type类型new一个CollectionElement         */        CollectionElement ce = new CollectionElement(typeName);        /**         * 得到该collection元素的所有子元素         */        List<Element> elements = leafElement.elements();        /**         * 遍历所有的子元素         */        for(Element e:elements) {            /**             * 得到Collection下子元素的元素名字             */            String tempName = e.getName();            /**             * 如果是value元素则调用对应方法得到该元素的值，并根据该值new一个ValueElement并保存到temp集合中             */            if("value".equals(tempName)) {                temp.add(new ValueElement(this.getValueOfValueElement(e)));            }            /**             * 如果是ref元素则调用对应的方法得到该元素的对应的值，并创建一个RefElement元素加到temp中             */            else if("ref".equals(tempName)) {                temp.add(new RefElement(this.getAttribute(e, "bean")));            }        }        /**         * 将所得到的ValueElement或Refelement元素加到CollectionElement的集合中去         */        ce.setList(temp);        /**         * 返回构造好的CollectionElement         */        return ce;    }    }

package com.tear.ioc.util;/** * 这是一个帮助类 */public class IocUtil {    /**     * 如果该类型是java中的几个基本数据类型那么返回它的类型，注意Integer.type就是获得他的class对象     * 如果不是基础类型则使用getClass（）返回它的Class对象     * @param obj     * @return     */    public static Class<?> getClass(Object obj) {        if (obj instanceof Integer) {            return Integer.TYPE;        } else if (obj instanceof Boolean) {            return Boolean.TYPE;        } else if (obj instanceof Long) {            return Long.TYPE;        } else if (obj instanceof Short) {            return Short.TYPE;        } else if (obj instanceof Double) {            return Double.TYPE;        } else if (obj instanceof Float) {            return Float.TYPE;        } else if (obj instanceof Character) {            return Character.TYPE;        } else if (obj instanceof Byte) {            return Byte.TYPE;        }        return obj.getClass();    }    /**     * 判断className的类型是否为基础类型。如java.lang.Integer, 是的话将数据进行转换     * 成对应的类型该方法是供本类中的方法调用的，作用是根据type类型的值将对应的value数据转换     * 成对应的type类型的值     * @param className     * @param data     * @return     */    public static Object getValue(String className, String data) {        /**         * 下面的所有if和else if都是判断是否是java的8中基本数据类型的包装类型         */        if (isType(className, "Integer")) {            return Integer.parseInt(data);        } else if (isType(className, "Boolean")) {            return Boolean.valueOf(data);        } else if (isType(className, "Long")) {            return Long.valueOf(data);        } else if (isType(className, "Short")) {            return Short.valueOf(data);        } else if (isType(className, "Double")) {            return Double.valueOf(data);        } else if (isType(className, "Float")) {            return Float.valueOf(data);        } else if (isType(className, "Character")) {            /**             * 如果是Character类型则取第一个字符             */            return data.charAt(0);        } else if (isType(className, "Byte")) {            return Byte.valueOf(data);        } else {            /**             * 如果不是8种基本数据类型的包装类那么就是自定义的类了，直接返回该值             */            return data;        }    }    /**     * 该方法是判断类名中是否含有对应的type字符串的方法，如判断className:java.lang.Integer中     * 是否包含Integer这样就返回true，不包含则返回false，该方法是供上面的方法调用的     * @param className     * @param type     * @return     */    private static boolean isType(String className, String type) {        if (className.lastIndexOf(type) != -1)            return true;        return false;    }}

<bean id="test3" class="com.xx.Test3" >        <property name="list">            <collection type="list">                <value type="java.lang.String">zhangsan</value>                <value type="java.lang.String">12</value>            </collection>        </property>        <property name="set">            <collection type="set">                <value type="java.lang.String">lisi</value>                <value type="java.lang.String">34</value>            </collection>        </property>        <property name="refTest">            <collection type="list">                <ref bean="test1"></ref>                <ref bean="test2"></ref>            </collection>        </property>    </bean>

package com.tear.ioc.bean.xml.element;import java.util.ArrayList;import java.util.List;/** * 这里我们使用的是组合模式，一个集合元素本身包含了多个叶子元素ref或者value * 本身可以不用实现LeafElement但是这里我们为了使CollectionElement和LeafElement * 以同样的方式被处理所以我们实现了LeafElement * @author rongdi */public class CollectionElement implements LeafElement {    private String type;    private List<LeafElement> list;    public void setList(List<LeafElement> list) {        this.list = list;    }    public void add(LeafElement leafElement) {        this.list.add(leafElement);    }    @Override    public String getType() {        return this.type;    }    public CollectionElement(String type) {        this.type = type;            }    public List<LeafElement> getList() {        return list;    }    @Override    public Object[] getValue() {        List<Object> value = http://www.mamicode.com/new ArrayList<Object>();        for(LeafElement le:this.getList()) {            value.add(le.getValue());        }        return value.toArray();    }}

package com.tear.ioc.xml.element.loader;import static org.junit.Assert.assertNotNull;import java.util.Iterator;import org.dom4j.Document;import org.dom4j.Element;import org.junit.After;import org.junit.Before;import org.junit.Test;import com.tear.ioc.bean.xml.document.XmlDocumentHolder;import com.tear.ioc.bean.xml.element.loader.ElementLoader;import com.tear.ioc.bean.xml.element.loader.ElementLoaderImpl;public class ElementLoaderImplTest {    XmlDocumentHolder xmlHolder;    ElementLoader elementLoader;    @Before    public void setUp() throws Exception {        xmlHolder = new XmlDocumentHolder();        elementLoader = new ElementLoaderImpl();            }    @After    public void tearDown() throws Exception {        xmlHolder = null;        elementLoader = null;    }    @Test    public void testAddElements() {        String filePath = "test/resources/element/ElementLoaderImpl.xml";        Document document = xmlHolder.getDocument(filePath);        assertNotNull(document);        elementLoader.addBeanElements(document);        Element e = elementLoader.getBeanElement("test1");        assertNotNull(e);        for(Iterator iter = elementLoader.getBeanElements().iterator();iter.hasNext();){            System.out.println(iter.next());        }    }}

package com.tear.ioc.xml.element.parser;import static org.junit.Assert.assertEquals;import static org.junit.Assert.assertFalse;import static org.junit.Assert.assertTrue;import java.util.List;import org.dom4j.Document;import org.dom4j.Element;import org.junit.After;import org.junit.Before;import org.junit.Test;import com.tear.ioc.bean.xml.autowire.Autowire;import com.tear.ioc.bean.xml.document.XmlDocumentHolder;import com.tear.ioc.bean.xml.element.LeafElement;import com.tear.ioc.bean.xml.element.PropertyElement;import com.tear.ioc.bean.xml.element.RefElement;import com.tear.ioc.bean.xml.element.ValueElement;import com.tear.ioc.bean.xml.element.loader.ElementLoader;import com.tear.ioc.bean.xml.element.loader.ElementLoaderImpl;import com.tear.ioc.bean.xml.element.parser.BeanElementParser;import com.tear.ioc.bean.xml.element.parser.BeanElementParserImpl;public class ElementParserImplTest {    private XmlDocumentHolder xmlHolder;        private ElementLoader elementLoader;            private BeanElementParser parser;    @Before    public void setUp() throws Exception {        xmlHolder = new XmlDocumentHolder();        elementLoader = new ElementLoaderImpl();        String filePath = "test/resources/element/elementParserImpl.xml";        Document doc = xmlHolder.getDocument(filePath);        elementLoader.addBeanElements(doc);        parser = new BeanElementParserImpl();    }    @After    public void tearDown() throws Exception {        xmlHolder = null;        elementLoader = null;    }    @Test    public void testIsLazy() {            //第一个元素        Element e = elementLoader.getBeanElement("test1-1");        boolean result = parser.isLazy(e);        assertTrue(result);        //第二个元素        e = elementLoader.getBeanElement("test1-2");        result = parser.isLazy(e);        assertFalse(result);        //第三个元素        e = elementLoader.getBeanElement("test1-3");        result = parser.isLazy(e);        assertFalse(result);    }    @Test    public void testGetConstructorElements() {        Element e = elementLoader.getBeanElement("test2");        List<Element> constructorElements = parser.getConstructorArgsElements(e);        assertEquals(constructorElements.size(), 2);    }    @Test    public void testGetAttribute() {        Element e = elementLoader.getBeanElement("test3");        String value =  parser.getAttribute(e, "class");        assertEquals(value, "com.tear.Test5");    }    @Test    public void testIsSingleton() {        Element e = elementLoader.getBeanElement("test4-1");        boolean result = parser.isSingleton(e);        assertFalse(result);                e = elementLoader.getBeanElement("test4-2");        result = parser.isSingleton(e);        assertTrue(result);    }    @Test    public void testGetPropertyElements() {        Element e = elementLoader.getBeanElement("test6");        List<Element> elements = parser.getPropertyElements(e);        assertEquals(elements.size(), 2);    }    @Test    public void testGetAutowire() {        Element e = elementLoader.getBeanElement("test10-1");        assertEquals(parser.getAttribute(e, "id"), "test10-1");        Autowire result = parser.getAutowire(e);        assertEquals(result.getType(), "byName");                e = elementLoader.getBeanElement("test10-2");        result = parser.getAutowire(e);        assertEquals(result.getType(), "no");                e = elementLoader.getBeanElement("test10-3");        result = parser.getAutowire(e);        assertEquals(result.getType(), "no");    }    @Test    public void testGetConstructorValue() {        Element e = elementLoader.getBeanElement("test11");        assertEquals(parser.getAttribute(e, "id"), "test11");        List<LeafElement> result = parser.getConstructorValue(e);        assertEquals(result.size(), 2);                ValueElement ve1 = (ValueElement)result.get(0);        System.out.println(ve1.getValue());        assertEquals((String)ve1.getValue(),"tear");                RefElement re = (RefElement)result.get(1);        assertEquals((String)re.getValue(), "test11");            }    @Test    public void testGetPropertyValue() {        Element e = elementLoader.getBeanElement("test12");        List<PropertyElement> eles = parser.getPropertyValue(e);        assertEquals(eles.size(), 4);        System.out.println(eles.get(0).getLeafElement().getValue());        assertEquals(eles.get(0).getName(), "property1");        assertEquals(eles.get(0).getLeafElement().getValue(), "tear");        assertEquals(eles.get(0).getLeafElement().getType(), "value");        System.out.println(eles.get(3).getLeafElement());        System.out.println(eles.get(3).getLeafElement().getType());        Object[] obj = (Object[])eles.get(3).getLeafElement().getValue();        System.out.println(obj[0]);        System.out.println(obj[1]);        }}

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//RONGDI//DTD BEAN//CN"     "http://www.cnblogs.com/rongdi/beans.dtd"><beans>    <bean id="test1" class="test1"></bean>    <bean id="test2" class="test2"></bean>    <bean id="test3" class="test3"></bean></beans>

<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE beans PUBLIC "-//RONGDI//DTD BEAN//CN"     "http://www.cnblogs.com/rongdi/beans.dtd"><beans>    <!-- isLazy-->    <bean id="test1-1" class="com.tear.Test1" lazy-init="true"></bean>    <bean id="test1-2" class="com.tear.Test2" lazy-init="default"></bean>    <bean id="test1-3" class="com.tear.Test3" lazy-init="false"></bean>    <!-- getConstructorElements-->    <bean id="test2" class="com.tear.Test4">        <constructor-arg>            <value type="java.lang.String">tear</value>        </constructor-arg>        <constructor-arg>            <value type="java.lang.String">1989229</value>        </constructor-arg>    </bean>    <!-- getAttribute -->    <bean id="test3" class="com.tear.Test5"></bean>    <!-- isSingleton -->    <bean id="test4-1" class="com.tear.Test6" singleton="false"></bean>    <bean id="test4-2" class="com.tear.Test7"></bean>    <!-- getConstructorArgs -->    <bean id="test5" class="com.tear.Test8">        <constructor-arg>            <value type="java.lang.String">wstear</value>        </constructor-arg>        <constructor-arg>            <value type="java.lang.String">1989229</value>        </constructor-arg>    </bean>    <!-- getPropertyElements-->    <bean id="test6" class="com.tear.Test9">        <property name="test1">            <ref bean="test1"/>        </property>        <property name="test2">            <ref bean="test2"/>        </property>    </bean>    <!-- getPropertyValues -->    <bean id="test7" class="com.tear.Test10">        <property name="test1">            <value type="java.lang.String">wstear</value>        </property>        <property name="test2">            <value type="java.lang.String">1989229</value>        </property>    </bean>    <!-- getPropertyRef -->    <bean id="test8" class="com.tear.Test11">        <property name="test1">            <ref bean="test1"/>        </property>        <property name="test2">            <ref bean="test2"/>        </property>    </bean>        <!-- getConstructorRef-->    <bean id="test9" class="com.tear.Test12">        <constructor-arg>            <ref bean="test1"/>        </constructor-arg>        <constructor-arg>            <ref bean="test2"/>        </constructor-arg>    </bean>    <!-- isAutowire -->    <bean id="test10-1" class="com.tear.Test13" autowire="byName">    </bean>    <bean id="test10-2" class="com.tear.Test14" autowire="no">    </bean>    <bean id="test10-3" class="com.tear.Test15" autowire="default">    </bean>    <bean id="test11" class="com.tear.Test11">        <constructor-arg>            <value type="java.lang.String">tear</value>        </constructor-arg>        <constructor-arg>            <ref bean="test11"/>        </constructor-arg>    </bean>        <!-- getPropertyValue -->    <bean id="test12" class="com.tear.Test17">        <property name="property1">            <value type="java.lang.String">tear</value>        </property>        <property name="property2">            <ref bean="test13"/>        </property>        <property name="property3">            <value type="java.lang.Integer">22</value>        </property>        <property name="property4">            <collection type="list">                <value type="java.lang.Integer">1212</value>                <value type="java.lang.String">tear</value>            </collection>        </property>    </bean>    <bean class="com.tear.Test18" id="test13"></bean></beans>