XML简析

XML简析

1 特点
1.1 xml（可扩展标记语言）与操作系统、编程语言的开发平台都无关；
1.2 可以实现不同操作系统之间的交互。
2 作用
2.1 配置应用程序(servlet 配置,框架环境配置等)和网站
2.2 数据交互
2.3 Ajax基石
3 结构 : 一种树结构，从根拓展到枝叶。
3.1 一个良好的xml文档必须包含：
a. 必须有XML声明语句 (第一行)
b. 必须有且仅有一个根元素
c. 标签成对
d. 元素正确嵌套
4 标签、元素、属性

  标签
< 内容 >   这样的样式称为标签 标签一般成对出现< 内容 > </ 内容 >
< 内容 \>  有时若不在标签之间安置其他的标签，也会出现这样的一行结束的标签
  元素
< 内容 > </ 内容 > 从开始标签到结束标签作为一个整体
  属性
< 内容  属性名1=“属性值1”  属性名2=“属性值2”>   可存在多个属性 

5 实体解析器5个
xml中，一些字符拥有特殊的意义。需要通过其他方法代表。

实体	符号
&It;	<
>	>
&	&
"	*
'	. (点)

6 CDATA
PCDATA 指的是被解析的字符数据（Parsed Character Data）。
所有 XML 文档中的文本均会被解析器解析。只有 CDATA 区段 （CDATA section）中的文本会被解析器忽略。

CDATA 部分由 <![CDATA[ 开始，由 ]]> 结束

7 DTD
DTD即文档类型定义-- Document Type Definition
一个DTD文档可能包含如下内容

1. 元素的定义规则
2. 元素之间的关系规则
3. 属性的定义规则

8 xml解析

8.1 Dom4J 解析 Xml (推荐)

8.1.1 获得document 对象

SAXReader reader=new SAXReader(); 
Document document=reader.read(new File("input.xml"));

8.1.2 操作xml文档节点

//获得根节点 
Element rootElm=document.getRootElement();
//获得子节点 
Element memberElm=root.element("member"); 
//获得节点文本 
String text=memberElm.getText();
//添加子节点 
Element ageElm=newMemberElm.addElement("age");
//设置节点文本 
ageElm.setText("29");
//删除某节点
parentElm.remove(childElm)

9 例子
Student.java文件

public class Student {
	//属性
    private String name;
    private Integer age;
    private Boolean gender;
	//构造器
    public Student() {
    }

    public Student(String name, Integer age, Boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
	//set/get方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean getGender() {
        return gender;
    }

    public void setGender(Boolean gender) {
        this.gender = gender;
    }
	//重写toString
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender=" + gender +
                '}';
    }
}

student.xml 文件

<?xml version="1.0" encoding="utf-8" ?>
<!--根节点 与Java类文件相关联 属性值是包内类的地址 -->
<student className="com.bean.Student">
<!-- 子节点-->
    <beans>
        <!--子节点bean-->
        <bean>
            <!--子节点bean的子节点-->
            <propertys>
                <!--<property name="name" value="zs" />-->
                <property>
                    <!--<name> -> 告诉你这个标签里边装的属性的名字-->
                    <!--name -> 整整的属性的名字-->
                    <name>name</name>
                    <value>zs</value>
                </property>
                <property>
                    <name>age</name>
                    <value>18</value>
                </property>
                <property>
                    <name>gender</name>
                    <value>true</value>
                </property>
            </propertys>
        </bean>
        <!--  子节点bean的兄弟节点-->
        <bean>
            <propertys>
                <property>
                    <name>name</name>
                    <value>ls</value>
                </property>
                <property>
                    <name>age</name>
                    <value>17</value>
                </property>
                <property>
                    <name>gender</name>
                    <value>false</value>
                </property>
            </propertys>
        </bean>
    </beans>
</student>

import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

import java.io.File;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;

public class StudentTest {
    public static void main(String[] args) throws Exception {
        //获取xml文件
        File file=new File("src/student.xml");
        //调用解析器创建对象
        SAXReader saxReader=new SAXReader();
        //将xml文件转为文本文件
        Document docFile = saxReader.read(file);

        //获取文件的根节点
        Element rootElement = docFile.getRootElement();

        //获取根节点的属性,获取完整的类名
        String className = rootElement.attribute("className").getText();
        System.out.println(className);
        //获取完整的类名之后，可以通过Class反射，获取全部信息
        //获取对应的Class对象  通过Class.forName("")获取相关对象信息
        Class clz=Class.forName(className);
        System.out.println(clz);
        

        //获取子节点
        Element element = rootElement.element("beans");
        if(null==element){
            System.out.println("无内容");
            return;
        }
        // 定义集合存储多个bean
        List list=new ArrayList();

        List<Element> elements = element.elements();
        if(null==elements || elements.size()==0){
            System.out.println("无内容");
            return;
        }

        for(Element e:elements){
            // bean  就是一个bean
            // 只要有一个bean就有一个对象
            Object obj = clz.newInstance();
            //获取子节点对象
            Element element1 = e.element("propertys");
            List<Element> elements1 = element1.elements("property");
            for(Element e1:elements1){
                List<Element> elements2 = e1.elements();
                // 获取属性的名称
                Element name = elements2.get(0);
                String nameText = name.getText();
                // 获取属性的值
                Element value = elements2.get(1);
                String valueText = value.getText();

                //根据属性名称获取属性对象
                Field NameField = clz.getDeclaredField(nameText);
                NameField.setAccessible(true);
                // 给对象的属性设值  注意类型的问题！！！！
                // 通过属性对象获取属性的 类型
                Class<?> type = NameField.getType();
                Method valueOfMethod=null;
                //判断是否是String类型
                if(type.equals(String.class)){
                    //基本类型里都有一个valueOf方法，可以使用
                    //传过来的参数类型是Object
                    valueOfMethod=type.getMethod("valueOf",Object.class);
                }else{
                    //传过来的参数类型是String
                    valueOfMethod = type.getMethod("valueOf", String.class);
                }
                // 执行valueOf方法  将字符串转换为指定的类型
                //参数1  由于valueOf是一个静态方法，不需要传递对象，所以用null
                //参数2  将获取到的值转成指定类型
                Object objValue = valueOfMethod.invoke(null,valueText);
                //将指定数据参数赋值给obj对象
                NameField.set(obj,objValue);
            }
            //添加到集合中
            list.add(obj);
        }
        System.out.println(list);
    }
}