XML解析详解--DOM解析、SAX、DOM4J、JDOM

 

四种解析方式：

DOM解析、SAX解析、DOM4J解析、JDOM解析（其中DOM解析和SAX解析时java官方提供给我们解析xml文档的方式，所以我们不需要额外引入一些jar包；但是DOM4J和JDOM解析是其他组织利用他们的方式去解析xml文件的，所以我们在运用这两种解析方式的时候，需要额外下载一些jar包，导入到我们的工程中）

示例：解析写好的book.xml文件，并存入JAVA对象。book.xml文件如下：

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
    <book id="1">
        <name>冰与火之歌</name>
        <author>乔治马丁</author>
        <year>2014</year>
        <price>89</price>
    </book>
    <book id="2">
        <name>安徒生童话</name>
        <year>2004</year>
        <price>77</price>
        <language>英文</language>
    </book>
</bookstore>

根据book.xml创建Book对象如下：

package day13;

/**
 * @ClassName: Book
 * @Description TODO
 * @Author: 
 * @Created: 2018/8/13 18:35
 * @Version: 1.0
 */
public class Book {
    private String id;
    private String name;
    private String author;
    private String price;
    private String year;
    private String language;

    public Book() {
    }

    public String getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getAuthor() {
        return author;
    }

    public String getPrice() {
        return price;
    }

    public String getYear() {
        return year;
    }

    public String getLanguage() {
        return language;
    }

    public void setId(String id) {
        this.id = id;
    }

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

    public void setAuthor(String author) {
        this.author = author;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    public void setYear(String year) {
        this.year = year;
    }

    public void setLanguage(String language) {
        this.language = language;
    }

    @Override
    public String toString() {
        return "Book [id=" + id + ", name=" + name + ", author=" + author + ", price=" + price + ", year=" + year
                +", language=" + language + "]";
    }

}

一、DOM方式解析xml步骤：

package day13;

import org.w3c.dom.*;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.util.ArrayList;

/**
 * @ClassName: DomParse
 * @Description TODO
 * @Author: 
 * @Created: 2018/8/13 18:46
 * @Version: 1.0
 */
public class DomParse {

    public static void main(String[] args) {
        //arrayList用于存放解析出来的BOOK对象
        ArrayList<Book> arrayList = new ArrayList<>();

        //1、创建一个DocumentBuilderFactory的对象
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        try{
            //2、创建一个DocumentBuilder的对象
            DocumentBuilder db = dbf.newDocumentBuilder();
            //3、通过DocumentBuilder对象的parse(String fileName)方法加载book.xml文件到当前项目下
            Document document = db.parse("src/day13/book.xml");

            //开始解析
            //4、通过标签名获取节点集合(获取所有book节点的集合)
            NodeList bookList = document.getElementsByTagName("book");
            System.out.println("book节点的个数："+bookList.getLength());
            //遍历每一个Book节点
            for(int i=0; i<bookList.getLength();i++){
                //new一个Book对象
                Book bookNode = new Book();
                //通过item(i)方法获取一个book节点
                Node book = bookList.item(i);
                //前提，已知book节点有且只能有1个id属性
                //可以直接获取id属性值
                Element element=(Element) bookList.item(i);
                String attrValue = element.getAttribute("id");
                System.out.println("id属性的属性值:"+attrValue);

                //获取的id属性set到Book对象
                bookNode.setId(attrValue);

                //解析book节点的子节点
                NodeList childNodes = book.getChildNodes();
                System.out.println("第"+(i+1)+"本书共有"+childNodes.getLength()+"个子节点");
                //遍历childNodes获取每个节点的节点名以及节点值
                for(int j=0; j<childNodes.getLength(); j++){
                    //判断当前节点是否为元素节点
                    if(childNodes.item(j).getNodeType() == Node.ELEMENT_NODE){
                        //获取节点属性名
                        String name = childNodes.item(j).getNodeName();
                        //根据节点属性名将获取的属性值set到Book对象中
                        switch (name) {
                            case "name":
                                bookNode.setName(childNodes.item(j).getTextContent());
                                break;
                            case "author":
                                bookNode.setAuthor(childNodes.item(j).getTextContent());
                                break;
                            case "year":
                                bookNode.setYear(childNodes.item(j).getTextContent());
                                break;
                            case "price":
                                bookNode.setPrice(childNodes.item(j).getTextContent());
                                break;
                            case "language":
                                bookNode.setLanguage(childNodes.item(j).getTextContent());
                                break;
                            default:
                                break;
                        }
                    }
                }
                arrayList.add(bookNode);
            }

        }catch (Exception e){
            e.printStackTrace();
        }

        System.out.println(arrayList);
    }
}

二、SAX解析

package day13;

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

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

/**
 * @ClassName: SAXParserHandler
 * @Description SAX处理程序(如何解析xml文档)
 * @Author: 
 * @Created: 2018/8/13 19:45
 * @Version: 1.0
 */
public class SAXParserHandler extends DefaultHandler {
    private String value = null;
    private List<Book> bookList = new ArrayList<>();
    private Book book = null;

    /**
     * 用来标识解析开始
     */
    @Override
    public void startDocument() throws SAXException {
        super.startDocument();
    }

    /**
     * 用来标识解析结束
     */
    @Override
    public void endDocument() throws SAXException {
        super.endDocument();
    }

    /**
     * 开始标签时调用
     *
     * @param qName:      表示开始标签的标签名
     * @param attributes: 表示开始标签内包含的（属性）【列表】
     */
    @Override
    public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException {
        //调用DefaultHandler中的startElement方法
        super.startElement(uri, localName, qName, attributes);

        //开始解析book元素属性
        if (qName.equals("book")) {
            //已知book元素下属性的属性名称,根据名称获取属性值
            String id = attributes.getValue("id");
            System.out.println("book的属性值："+id);

            //将id属性set到Book对象中
            book = new Book();
            book.setId(id);

            //不知道book元素下属性的属性名称
            int num = attributes.getLength();
            //遍历属性
            for (int i=0; i<num; i++){
                System.out.println("book元素的第"+(i+1)+"个属性名是:"+attributes.getQName(i));
                System.out.println("---属性值是："+attributes.getValue(i));
            }
        }else if (!qName.equals("book") && !qName.equals("bookstore")){
            System.out.println("节点名是:"+qName);
        }

    }

    /**
     * 结束标签时调用
     *
     * @param qName: 结束标签的标签名称
     */
    @Override
    public void endElement(String uri, String localName, String qName) throws SAXException {

        super.endElement(uri, localName, qName);

        switch (qName) {
            case "book":
                bookList.add(book);
                book = null;
                break;
            case "name":
                book.setName(value);
                break;
            case "author":
                book.setAuthor(value);
            case "year":
                book.setYear(value);
                break;
            case "language":
                book.setLanguage(value);
                break;
            case "price":
                book.setPrice(value);
                break;
        }
    }

    /**
     * 读到文本内容的时调用
     *
     * @param ch:     表示当前读完的所有文本内容
     * @param start：  表示当前文本内容的开始位置
     * @param length: 表示当前文本内容的长度
     */
    @Override
    public void characters(char[] ch, int start, int length) throws SAXException {
        super.characters(ch, start, length);
        value = new String(ch, start, length);
    }

    public List<Book> getBookList() {
        return bookList;
    }

    public void setBookList(List<Book> bookList) {
        this.bookList = bookList;
    }
}

三、DOM4J解析--注意：使用Dom4解析，需下载dom4j相应的jar文件

官网地址：https://dom4j.github.io/ 

Dom4j递归遍历所有节点方法如下：

package day13;

import org.dom4j.Attribute;
import org.dom4j.Element;

import java.util.List;

/**
 * @ClassName: Dom4jParse
 * @Description 通过element方法递归遍历所有节点
 * @Author:
 * @Created: 2018/8/14 7:39
 * @Version: 1.0
 */
public class Dom4jParse {

    /**
    *@Description 递归遍历所有父节点、子节点
    *@Author:
    *@Date:   2018/8/14
    *@param:  [element]
    *@return: void
    */
    public void dom4jParse(Element element) {

        System.out.println(element.getName() + ":" + element.getText().trim());
        //从book根节点开始遍历，以【属性=值】的形式存为一个Attribute对象存储在list中
        List<Attribute> attributeList = element.attributes();
        for (Attribute attribute : attributeList) {
            //每循环一次，解析次节点的一个【属性=值】,没有则输出空
            String name = attribute.getName();
            String value = attribute.getValue();
            System.out.println(name + "=" + value);
        }

        List<Element> elementList = element.elements();
        //递归遍历父节点下的所有子节点
        for (Element e : elementList) {
            dom4jParse(e);
        }
    }
}

DOM4J测试： 

package day13;


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

/**
 * @ClassName: Dom4jParseTest
 * @Description TODO
 * @Author: heyuan@iflytek.com
 * @Created: 2018/8/13 20:22
 * @Version: 1.0
 */
public class Dom4jParseTest {

    public static void main(String[] args) throws Exception{
        //构造SAXReader对象
        SAXReader saxReader = new SAXReader();

        try {
            //通过read方法读取xml文件转换成Document对象
            Document document = saxReader.read("src/day13/book.xml");
            //获取根节点元素对象
            Element element = document.getRootElement();
            //创建Dom4jParse解析对象
            Dom4jParse dom4jParse = new Dom4jParse();
            //调用解析方法
            dom4jParse.dom4jParse(element);
        }catch (DocumentException e){
            e.printStackTrace();
        }
    }

}

四、JDOM解析

package day13;

import org.dom4j.Element;
import org.jdom.Attribute;
import org.jdom.Document;
import org.jdom.input.SAXBuilder;

import java.io.FileInputStream;
import java.io.InputStream;
import java.util.List;

/**
 * @ClassName: JDomParse
 * @Description TODO
 * @Author: 
 * @Created: 2018/8/14 9:07
 * @Version: 1.0
 */
public class JDomParse {
    public static void main(String[] args) {
        //1、创建SAXBuilder对象
        SAXBuilder saxBuilder = new SAXBuilder();
        InputStream in;
        try {
            //2、创建输入流，并将xml文件加载到输入流中
            in = new FileInputStream("src/day13/book.xml");
            //3、将输入流加载到SAXBuilder对象中
            Document document = saxBuilder.build(in);
            //4、获取根元素
            org.jdom.Element element = document.getRootElement();
            //5、获取根元素所以的子元素
            List<org.jdom.Element> childList = element.getChildren();
            //6、遍历每一个子元素
            for (org.jdom.Element child : childList){
                System.out.println("=====开始读取第"+(childList.indexOf(child)+1)+"本书的信息");
                //7-1、如果不知道属性有哪些，使用Element.getAttributes获取属性，并遍历属性
                List<Attribute> attrList = child.getAttributes();
                for(Attribute attr : attrList) {
                    System.out.println("属性名：" + attr.getName() + "-->属性值：" + attr.getValue());
                }
                //7-2、如果知道属性有哪些，可以直接调用Element.getAttributeValue(String name)获取对应的属性值
                System.out.println("已知有id属性，id属性的值为" + child.getAttributeValue("id"));

                //8、获取所有子节点，并调用Element.getName()方法获取节点名，调用Element.getVlaue()方法获取节点值
                List<org.jdom.Element> list = child.getChildren();
                for(org.jdom.Element ele : list) {
                    System.out.println("子节点：" + ele.getName() + "--->子节点的值：" + ele.getValue());
                }
            }

        }catch (Exception e){
            e.printStackTrace();
        }
    }
}