Java-XML解析

一、XML

1、XML含义

1. XML是指可扩展标记语言（Extensible Markup Language）,类似于HTML。
2. 纯文本、跨平台、可读性强。
3. XML标签没有被预定义，用户需要自定义标签。

2、XML语法

1. 文档声明
   （1）在编写XML文档时，需要先使用文档声明来声明XML文档。且必须出现在文档的第一行。（前面注释都不允许）
   如：最简单的语法:< ? xml version=“1.0”? >
   （2）用encoding属性说明文档所使用的字符编码。保存在磁盘上的文件编码要与声明的编码一致。
   如：< ?xml version=“1.0” encoding=“utf-8”?>
   （3）用standalone属性说明文档是否独立，即是否依赖其他文档。
   如：< ?xml version=“1.0” encoding=“utf-8” standalone=“yes”?>
2. 元素
   （1）指XML文件中出现的标签。一个标签分为起始和结束标签(不能省略)。一个标签有如下几种书写形式：
   包含标签主体：< mytag>some content< /mytag>
   不含标签主体：< mytag />（有时也叫空标签）
   一个标签中可以嵌套若干子标签，但所有标签必须合理的嵌套，不允许有交叉嵌套。
   < mytag1>< mytag2>< /mytag1>< /mytag2>
   （2）一个XML文档必须有且仅有一个根标签，其他标签都是这个根标签的子标签或孙标签。
   （3）对于XML标签中出现的所有空格和换行，XML解析程序都会当作标签内容进行处理。例如：下面两段内容的意义是不一样的。
   （4）由于在XML中，空格和换行都作为原始内容被处理，所以，在解析XML文件时要特殊处理下，绕过这些空格和换行符。
   （5）元素命名规范：一个XML元素可以包含字母、数字以及其它一些可见字符，但必须遵守下面的一些规范：
   
   • 区分大小写，例如，< A>和< a>是两个不同的标记。（与java、c变量命名一致）
   • 不能以数字或”_” (下划线)开头。
   • 不能以xml(或XML、或Xml 等)开头。(xml 为关键字，所以不能重复)
   • 不能包含空格。
   • 名称中间不能包含冒号（:）。
3. 属性
   （1）一个元素可以有多个属性，每个属性都有它自己的名称和取值，例如：< mytag name=“value” …/>
   （2）属性值一定要用引号(单引号或双引号)引起来。
   （3）属性名称的命名规范与元素的命名规范相同。
   （4）元素中属性没有顺序要求，但是不准重复。
   （5）在XML技术中，标签属性所代表的信息也可以被改成用子元素的形式来描述。
4. 注释
   （1）XML中的注释语法为：< !–这是注释–>
   （2）XML声明之前不能有注释(xml声明必须放在文档第一行)
   （3）注释不能嵌套
5. 实体引用和CDATA区
   实体引用
   （1）在 XML 中，一些字符拥有特殊的意义。如果你把字符 “<” 放在 XML 元素中，会发生错误，这是因为解析器会把它当作新元素的开始。如下这样会产生 XML 错误：
   < message>if salary < 1000 then< /message>
   （2）为了避免此类错误，需要把字符 “<” 替换为实体引用，就像这样：
   < message>if salary & l t; 1000 then< /message>

替换字符	符号	含义
&lt ;	<	小于
&gt ;	>	大于
&amp ;	&	和号
&apos ;	‘	单引号
&quot ;	“	引号

严格地讲，在 XML 中仅有字符 “<”和”&” 是非法的。省略号、引号和大于号是合法的，但是把它们替换为实体引用是个好的习惯
CDATA区
术语CDATA 指的是不应由 XML 解析器进行解析的文本数据（Unparsed Character Data）。
在 XML 元素中，”<”和”&”是非法的。”<”会产生错误，因为解析器会把该字符解释为新元素的开始。”&”也会产生错误，因为解析器会把该字符解释为字符实体的开始。
某些文本，比如 JavaScript 代码，包含大量”<”或”&”字符。为了避免错误，可以将脚本代码定义为 CDATA。
CDATA 部分中的所有内容都会被解析器忽略。
CDATA 部分由 “< ![CDATA[” 开始，由 “]]>” 结束：

二、XML解析

XML解析有三种：
DOM（文档对象模型）：将整个文件以树的结构存储到内存中，适合小文件，程序可读性高。
SAX（基础事件流的解析）：省内存，程序可读性相比DOM差。
PULL（Android自带解析器）：也是基于事件流的解析。

1、SAX解析

1.1解析原理

以事件驱动的方式解析,即找开始结束标签的方式

SAX的工作原理简单地说就是对文档进行顺序扫描，当扫描到文档（document）开始与结束、元素（element）开始与结束、等地方时通知事件处理函数，由事件处理函数做相应动作，然后继续同样的扫描，直至文档结束。

所以有两个动作：顺序扫描，事件处理函数
例子：解析xml文件（根标签有属性）

Main类：

public class SaxParseTest {

    public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
        //创建解析工厂
        SAXParserFactory factory = SAXParserFactory.newInstance();
        //创建解析器
        SAXParser parser =  factory.newSAXParser();
        //创建处理对象
        MyHandler handler = new MyHandler();
        //解析
        parser.parse(new File("students.xml"), handler);
        //获取结果
        List<Student> students = handler.getList();
        for(Student s:students){
            System.out.println(s);
        }
    }
}

Handler类：

public class MyHandler extends DefaultHandler{
    private List<Student> list;
    private String tag;
    private Student student;
    @Override
    public void startDocument() throws SAXException {
        //初始化
        list = new ArrayList<Student>();
    }

    @Override
    public void startElement(String uri, String localName, String qName,Attributes attributes) throws SAXException {
//      System.out.println("uri:"+uri+" localName:"+localName+" qName:"+qName+" attributes:"+attributes);
        tag = qName;
        if("student".equals(qName)){
            student = new Student();
            if(attributes == null){
                return;
            }
            for (int i = 0; i < attributes.getLength(); i++) {
                String name = attributes.getQName(i);
                String value = attributes.getValue(i);
                if("id".equals(name)){
                    student.setId(value);
                }

            }
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName)throws SAXException {
        if("student".equals(qName)){
            list.add(student);
        }
    }

    @Override
    public void characters(char[] ch, int start, int length)throws SAXException {
        String content = new String(ch,start,length);
//      System.out.println(content);
        content = content.trim();
        if(content.length()!=0){
            if("name".equals(tag)){
                student.setName(content);           
            }else if("age".equals(tag)){
                student.setAge(Integer.parseInt(content));
            }else if("sex".equals(tag)){
                student.setSex(content);
            }
        }
    }

    public List<Student> getList() {
        return list;
    }
}

Student类：

public class Student {
    private String id;
    private String name;
    private int age;
    private String sex;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    @Override
    public String toString() {
        return "{id:'" + id + "', name:'" + name + "', age:'" + age
                + "', sex:'" + sex + "'}";
    }
}

XML文件：

<?xml version="1.0" encoding="UTF-8"?>
<students>
    <student id="10001">
        <name>zhangsan</name>
        <age>20</age>
        <sex>male</sex>
    </student>
    <student id="10002">
        <name>lisi</name>
        <age>21</age>
        <sex>female</sex>
    </student>
</students>

输出结果：

{id:'10001', name:'zhangsan', age:'20', sex:'male'}
{id:'10002', name:'lisi', age:'21', sex:'female'}

2、PULL解析

在android系统中，很多资源文件中,很多都是xml格式，在android系统中解析这些xml的方式，是使用pul解析器进行解析的，它和sax解析一样，也是采用事件驱动进行解析的。
例：解析XML文件（根标签带属性）

public class PullparseTest {
    public static void main(String[] args) throws XmlPullParserException,IOException {
        //创建pull解析器的工厂对象
        XmlPullParserFactory factory = XmlPullParserFactory.newInstance();
        //创建pull解析器
        XmlPullParser parser = factory.newPullParser();
        //指定数据源，解析students.xml
        parser.setInput(new FileReader("students.xml"));
        //获取事件状态码，在开始解析之前先获取一次
        int eventType = parser.getEventType();

        List<Student> stuList = null;
        Student stu = null;
        //循环获取事件状态码，直到文件解析结束
        while (eventType != XmlPullParser.END_DOCUMENT) {
            //获取标签
            String tag = parser.getName();
            switch (eventType) {
            case XmlPullParser.START_DOCUMENT://文档的开始
                stuList = new ArrayList<Student>();
                break;
            case XmlPullParser.START_TAG://标签的开始
                if ("student".equals(tag)) {
                    stu = new Student();
                    // 解析标签属性
                    int count = parser.getAttributeCount();
                    for (int i = 0; i < count; i++) {
                        String name = parser.getAttributeName(i);
                        String value = parser.getAttributeValue(i);
                        if ("id".equals(name)) {
                        stu.setId(value);
                        }
                    }

                } else if ("name".equals(tag)) {
                    stu.setName(parser.nextText());
                } else if ("age".equals(tag)) {
                    stu.setAge(Integer.parseInt(parser.nextText()));
                } else if ("sex".equals(tag)) {
                    stu.setSex(parser.nextText());
                }
                break;
            case XmlPullParser.END_TAG://标签的结束
                if ("student".equals(tag)) {
                    stuList.add(stu);//添加信息到list
                }
                break;
            }
            //获取下一个事件状态码，往下继续解析
            eventType = parser.next();
        }
        for (Student s : stuList) {
            System.out.println(s);
        }
    }
}

输出结果：

{id:'10001', name:'zhangsan', age:'20', sex:'male'}
{id:'10002', name:'lisi', age:'21', sex:'female'}