xml文件解析

XML，eXtendsible markup language 可扩展的标记语言

1. 可以用来保存数据

2. 可以用来做配置文件

3. 数据传输载体

XML解析其实就是获取元素里的字符数据或者属性数据

常用的XML解析方式

1. DOM：Document Object Model，把整个xml全部读取到内存当中，形成树状结构。整个文档称为document对象，属性对应attribute对象，所有的元素节点对应element对象，文本称之为Text对象，以上所有对象称为Node节点；如果xml特别大可能会造成内存溢出；可以对文档进行增删操作
2. SAX：Simple API of XML 基于事件驱动。读取一行，解析一行，不会造成内存溢出，不能对文档进行增删，只能查询

DOM方式解析XML文件

Document Object Model，把整个xml全部读取到内存当中，形成树状结构。整个文档称为document对象，属性对应attribute对象，所有的元素节点对应element对象，文本称之为Text对象，以上所有对象称为Node节点；如果xml特别大可能会造成内存溢出；可以对文档进行增删操作

创建一个stus.xml文件，并引入dom4j的jar包

stus.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<stus>
    <stu>
        <name>wxf</name>
        <age>24</age>
    </stu>
    <stu>
        <name>qf</name>
        <age>18</age>
    </stu>
</stus>

Dom解析测试类

public class MainTest {
    public static void main(String[] args) {
        try {
            //1.创建SAXReader对象
            SAXReader reader = new SAXReader();
            //2.读取xml文件，获取Document对象
            Document doc = reader.read(new File("src/stus.xml"));
            //3.获取document对象的根元素
            Element rootElement = doc.getRootElement();
            System.out.println("rootElement.getName()==="+rootElement.getName());
            System.out.println("--------------");
            //4.获取rootElement下的所有子元素
            List<Element> elements = rootElement.elements();
            for (Element element : elements) {
                System.out.println("element.getName()==="+element.getName());
                System.out.println("name==="+element.element("name").getText());
                System.out.println("age==="+element.element("age").getText());
                System.out.println("--------------");
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
}

console测试结果

rootElement.getName()===stus
--------------
element.getName()===stu
name===wxf
age===24
--------------
element.getName()===stu
name===qf
age===18
--------------

dom解析xml文件还可以根据XPath来处理（需要导入jaxen的jar包，否则会抛出java.lang.NoClassDefFoundError: org/jaxen/NamespaceContext）

XPath的常用语法：

如果路径以斜线 / 开始, 那么该路径就表示到一个元素的绝对路径

如果路径以双斜线 // 开头, 则表示选择文档中所有满足双斜线//之后规则的元素(无论层级关系)

星号 * 表示选择所有由星号之前的路径所定位的元素

............

XPath测试类

public class MainTest2 {
    public static void main(String[] args) {
        try {
            //1.创建SAXReader对象
            SAXReader reader = new SAXReader();
            //2.读取xml文件，获取Document对象
            Document doc = reader.read(new File("src/stus.xml"));
            //3.根据XPath获取element元素
            //查找指定XPath("/")路径下第一个节点
            Node selectSingleNode = doc.selectSingleNode("/stus/stu/name");
            System.out.println("name==="+selectSingleNode.getText());
            System.out.println("==================");
            //根据XPath("/")查找所有name节点
            List<Node> selectNodes = doc.selectNodes("/stus/stu/name");
            for (Node node : selectNodes) {
                System.out.println("name==="+node.getText());
            }
            System.out.println("==================");
            //根据XPath("//")查找所有name节点
            List<Node> selectNodes2 = doc.selectNodes("//age");
            for (Node node : selectNodes2) {
                System.out.println("age==="+node.getText());
            }
            System.out.println("==================");
            //根据XPath("*")查找stu下的所有子节点
            List<Node> selectNodes3 = doc.selectNodes("/stus/stu/*");
            for (Node node : selectNodes3) {
                System.out.println(node.getName()+"==="+node.getText());
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
    }
}

console测试结果

name===wxf
==================
name===wxf
name===qf
==================
age===24
age===18
==================
name===wxf
age===24
name===qf
age===18

SAX解析XML方式

Java JDK自带的解析。Simple API of XML 基于事件驱动。读取一行，解析一行

优点：在读取文档的同时即可对XML进行处理，不必等到文档加载结束，相对快捷。不需要加载进内存，因此不存在占用内存的问题，可以解析超大XML

缺点：只能用来读取XML中数据，无法进行增删改

SAX解析过程： 

解析步骤：

1. 创建一个SAXParserFactory对象：SAXParserFactory factory=SAXParserFactory.newInstance();
2. 获得解析器 ：SAXParser parser=factory.newSAXParser();
3. 调用解析方法解析xml，这里的第一个参数可以传递文件、流、字符串、需要注意第二个参数（new DefaultHander）

   File file=new File("girls.xml");
   parser.parse(file,new DefaultHandler());
   /**注解：--->这里的DefaultHandler表示
   DefaultHandler类是SAX2事件处理程序的默认基类。它继承了EntityResolver、DTDHandler、
   ContentHandler和ErrorHandler这四个接口。包含这四个接口的所有方法，所以我们在编写事件处理程序时，
   可以不用直接实现这四个接口，而继承该类，然后重写我们需要的方法，所以在这之前我们先定义一个用于实现解析
   方法如下：*/

4. 创建一个MyHandler类来继承DefaultHandler并重写方法

   //定一个名为MyHandler类用来继承DefaultHandler
   (1)MyHandler extends DefaultHander
   (2)重写方法，快速记住方法（2个开始，2个结束，1一个文字(charactor--里面的内容)）
   (3)2个开始：StartDocment（文档的开始）StartElement(元素的开始) 2个结束:endElement(元素的结束)
   endDocment(文档的结束，标志着xml文件的结束) 1个文字内容：charactor(文字内容)

5. 创建一个集合把所解析的内容添加到集合

   分析：目的我们只是需要把xml里面的文字内容添加到我们的集合而不需要其他元素，所以我们需要进行判断得到

6. 接步骤三 输出集合System.out.pritnln(list); 解析完成

创建一个实体类Student.java

package com.qf.pojo;

public class Student {

    private String name;
    private int age;
    
    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;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + "]";
    }
}

自定义一个ListHandler类继承DefaultHandler

package com.qf.handler;

import java.util.ArrayList;
import java.util.List;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

import com.qf.pojo.Student;

public class ListHandler extends DefaultHandler {

    private List<Student> stus;
    private Student stu;
    private String tag;
    
    
    @Override
    public void startDocument() throws SAXException {
        //因为这个方法只调用一次，所以在开始的时候就可以实例化集合
        stus = new ArrayList<>();
    }
    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
    }
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        //这个方法，只有当开始一个元素的时候才会调用，
        //通过分析，当外部开始元素为student的时候，需要将student实例化
        //将tag赋值
        tag = qName;
        if("stu".equals(qName)) {
            stu = new Student();
        }
    }
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {
        //这句话，必须写，因为，当sax解析完一个元素的时候，会自动认为换行符是一个字符，会继续执行 character 方法 。如果不写，就会造成没有数据的现象。 
        tag = "";
        //这个方法，当到了元素结尾的时候，会调用，应该在这里，将对象添加到集合里面去。
        if ("stu".equals(qName)) {
            stus.add(stu);
        }
    }
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        //这里是内容，但是，无法直接判断属于哪一个元素。
        String string = new String(ch, start, length);
        if ("name".equals(tag)) {//判断当前内容，属于哪一个元素。
            stu.setName(string);
        }else if ("age".equals(tag)) {
            stu.setAge(Integer.valueOf(string));
        }//这两种情况，表示 当前语句执行在 stus 标签内。
    }
    public List<Student> getStus() {
        return stus;
    }
    public void setStus(List<Student> stus) {
        this.stus = stus;
    }
    public Student getStu() {
        return stu;
    }
    public void setStu(Student stu) {
        this.stu = stu;
    }
}

测试类

package com.qf.test;

import java.io.File;
import java.io.IOException;
import java.util.List;

import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.SAXException;

import com.qf.handler.ListHandler;
import com.qf.pojo.Student;

public class SAXTest {
    public static void main(String[] args) {
        //1.创建对象
        SAXParserFactory newInstance = SAXParserFactory.newInstance();
        try {
            //2.获取解析器 
            SAXParser saxParser = newInstance.newSAXParser();
            //3.调用方法开始解析xml   
            File file = new File("src/stus.xml");
            ListHandler dh = new ListHandler();
            saxParser.parse(file, dh);
            List<Student> stus=dh.getStus();
            //4.输出集合
            System.out.println(stus);
        } catch (ParserConfigurationException | SAXException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    
    }
}

控制台输出

[Student [name=wxf, age=24], Student [name=qf, age=18]]