Java解析XML的几种方法

Java解析XML有几种方法，本文就讨论是怎么使用这四种方法来解析XML文件，并分析他们的优缺点以及应用场合。

1. DOM（Document Object Model）

优点：
1. 允许应用程序对数据和结构做出更改。
2. 访问是双向的，可以在任何时候再树中上、下导航获取、操作任意部分的数据。
缺点：
1. 解析XML文档的需要加载整个文档来构造层次结构，消耗内存资源大。
应用范围：
由于他的遍历能力，DOM解析器常应用于XML文档需要频繁改变的服务中。

Java使用步骤：
1. 创建一个DocumentBuilderFactory对象。
2. 创建一个DocumentBuilder对象。
3. 通过DocumentBuilder的parse方法加载XML到当前工程目录下。
4. 通过getElementsByTagName方法获取所有XML所有节点的集合。
5. 遍历所有节点。
6. 通过item方法获取某个节点的属性。
7. 通过getNodeName和getNodeValue方法获取属性名和属性值。
8. 通过getChildNodes方法获取子节点，并遍历所有子节点。
9. 通过getNodeName和getTextContent方法获取子节点名称和子节点值。

XML文档内容：

<?xml version="1.0" encoding="UTF-8"?>
<bookstore>
    <book id="1">
        <name>Java</name>
        <author>Bruce Eckel</author>
        <year>2014</year>
        <price>102</price>
    </book>
    <book id="2">
        <name>JavaScript</name>
        <year>2012</year>
        <price>86</price>
        <language>Chinese</language>
    </book> 
</bookstore>

DOM解析XML文档：

package gan.xml;

import java.io.IOException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;

import org.w3c.dom.Document;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class DOMTest {
    public static void main(String[] args) {
        //1.创建一个DocumentBuilderFactory对象
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();

        try {
            //2.创建一个DocumentBuilder对象
            DocumentBuilder db = dbf.newDocumentBuilder();  

            //3.通过DocumentBuilder的parse方法加载books.xml到当前工程目录下
            Document document = db.parse("books.xml");  

            //4.获取所有book所有节点的集合
            NodeList bookList = document.getElementsByTagName("book");

            //通过NodeList的getLength（）方法获取 bookList的长度
            int bookCnt = bookList.getLength();
            System.out.println("获取了" + bookCnt +"本书");

            for(int i=0; i<bookCnt; i++){
                //5.通过item方法获取一个book节点，bookList索引值从0开始
                Node book = bookList.item(i);

                //6.获取book节点的所有属性集合
                NamedNodeMap attrs = book.getAttributes();

                System.out.println("第"+ (i+1) +"本书共有"+ attrs.getLength()+"个属性");
                for(int j=0; j<attrs.getLength(); j++){
                    //7.通过这个item()方法获取book某一个属性
                    Node attr = attrs.item(j);

                    //8.获取属性名
                    System.out.print("属性名：" + attr.getNodeName()+"----");

                    //9.获取属性值
                    System.out.println("属性值：" + attr.getNodeValue());
                }

                //10.通过getChildNodes()方法解析book节点子节点
                NodeList childNodes = book.getChildNodes();

                //11.遍历childNodes获取每隔节点的节点名和节点值
                for(int k=0; k<childNodes.getLength(); k++){
                    //12.区分出text类型和element类型的node
                    if(childNodes.item(k).getNodeType() == Node.ELEMENT_NODE){
                        //13.获取element类型节点的节点名
                        System.out.print("第"+ (k+1) + "节点的节点名："+childNodes.item(k).getNodeName()+"  ");

                        //14.获取element类型节点的节点值
                        System.out.println("节点值：" + childNodes.item(k).getTextContent());
                    }                   
                }               
            }
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

2. SAX(Simple API for XML)

优点：
1. 不需要等待所有的数据被处理，解析就可以开始。
2. 只在读取数据的时检查数据，不需要保存在内存中。
3. 可以在某一个条件满足时停止解析，不必要解析整个文档。
4. 效率和性能较高，能解析大于系统内存的文档。
缺点
1. 解析逻辑复杂，需要应用层自己负责逻辑处理，文档越复杂程序越复杂。
2. 单向导航，无法定位文档层次，很难同时同时访问同一文档的不同部分数据，不支持XPath.

解析步骤：
1. 获取一个SAXParserFactory的实例。
2. 通过factory获取SAXParser实例。
3. 创建一个handler对象。
4. 通过parser的parse()方法来解析XML。

代码如下：

package gan.saxTest;

import java.io.IOException;

import gan.SAXHandler.SAXParserHandler;
import gan.entity.Book;

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

import org.xml.sax.SAXException;

public class SAXTest {

    public static void main(String[] args) {
        //1.获取一个SAXParserFactory的实例
        SAXParserFactory factory = SAXParserFactory.newInstance();

        //通过factory获取SAXParser实例
        try {
            //2.通过factory获取SAXParser实例
            SAXParser parser = factory.newSAXParser();

            //3.创建一个handler对象
            SAXParserHandler handler = new SAXParserHandler();

            //4.通过parser的parse()方法来解析XML
            parser.parse("books.xml", handler);

            System.out.println("共有"+ handler.getBookList().size()+ "书");
            for(Book book : handler.getBookList()){             
                System.out.println(book.getName());
                System.out.println("id="+book.getId());
                System.out.println(book.getAuthor());
                System.out.println(book.getYear());
                System.out.println(book.getPrice());
                System.out.println(book.getLanguage());
                System.out.println("----读取这本书在内存中的内容结束");
            }
        } catch (ParserConfigurationException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (SAXException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

handler处理代码：

package gan.SAXHandler;

import java.util.ArrayList;

import gan.entity.Book;


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

public class SAXParserHandler extends DefaultHandler {
    String value = null;
    Book book = null;
    private ArrayList<Book> bookList = new ArrayList<Book>();

    public ArrayList<Book> getBookList() {
        return bookList;
    }
    /*
     * XML解析开始
     */
    public void startDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.startDocument();
        System.out.println("xml解析开始");
    }

    /*
     * XML解析结束
     */
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub
        super.endDocument();
        System.out.println("xml解析结束");
    }

    /*
     * 解析XML元素开始
     */
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        super.startElement(uri, localName, qName, attributes);

        if(qName.equals("book")){
            book = new Book();

            System.out.println("===============开始某本书解析================");
            //这个一个本书开始检验
            for(int i=0; i<attributes.getLength();i++){
                System.out.print("book属性名："+attributes.getQName(i)+"---");
                System.out.println("book属性值：" + attributes.getValue(i));

                if(attributes.getQName(i).equals("id")){
                    book.setId(attributes.getValue(i));
                }               
            }
        }else if(!qName.equals("bookstore")){
            System.out.print("节点名："+ qName + "---");    
        }
    }

    /*
     *解析XML元素 结束
     */
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        // TODO Auto-generated method stub
        super.endElement(uri, localName, qName);
        if(qName.equals("book")){
            bookList.add(book);
            book = null;
            System.out.println("===============结束某本书解析================");
        }
        else if(qName.equals("name")){          
            book.setName(value);
        }else if(qName.equals("year")){
            book.setYear(value);
        }else if(qName.equals("author")){
            book.setAuthor(value);
        }else if(qName.equals("price")){
            book.setPrice(value);
        }else if(qName.equals("language")){
            book.setLanguage(value);
        }
    }


    public void characters(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        super.characters(ch, start, length);

        //获取节点值数组
        value = new String(ch, start, length);
        if(!value.trim().equals("")){
            System.out.println("节点值："+value);
        }       
    }
}

4. DOM4J（Document Object Model for Java）

优点：
1. 性能很好
2. 大量使用Java集合类，开发简便，同时也提供了一些提高性能的代替方法。
3. 支持XPath。
缺点：
1. API比较复杂。

代码如下：

package gan.Dom4j;

import gan.entity.Book;

import java.io.File;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

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

public class DOM4JTest {
    /*
     * 
     */
    public static void main(String[] args) {
        ArrayList<Book> bookList = new ArrayList<Book>();

        // 1.创建SAXReader的对象reader
        SAXReader reader = new SAXReader();
        try {
            // 2.通过reader对象的read（）方法加载books.xml文件，获取document对象
            Document document = reader.read(new File("books.xml"));

            // 3.通过document对象获取根节点bookstore
            Element bookStore = document.getRootElement();

            // 4.通过element对象的elementIterator获取迭代器
            Iterator it = bookStore.elementIterator();

            // 5.遍历迭代器，获取根节点中的信息
            while (it.hasNext()) {
                System.out.println("==========开始某一本书遍历===============");

                Element book = (Element) it.next();
                Book bookData = new Book();

                // 6.获取book的属性名和属性值
                List<Attribute> bookAttrs = book.attributes();
                for (Attribute attr : bookAttrs) {
                    System.out.println("属性名：" + attr.getName() + "--" + "属性值："
                            + attr.getValue());

                    if(attr.getName().equals("id")){
                        bookData.setId(attr.getValue());
                    }
                }

                // 7.通过book对象的elementIterator获取节点元素迭代器
                Iterator itt = book.elementIterator();

                // 8.遍历迭代器，获取子节点中的信息
                while (itt.hasNext()) {
                    Element bookChild = (Element) itt.next();

                    // 9.获取节点名和节点值
//                  System.out.println("节点名：" + bookChild.getName()
//                          + "--- 节点值： " + bookChild.getStringValue());
                    System.out.println("节点名：" + bookChild.getName()
                            + "--- 节点值： " + bookChild.getText());

                    if(bookChild.getName().equals("name")){
                        bookData.setName(bookChild.getText());
                    }else if(bookChild.getName().equals("author")){
                        bookData.setAuthor(bookChild.getText());
                    }else if(bookChild.getName().equals("year")){
                        bookData.setYear(bookChild.getText());
                    }else if(bookChild.getName().equals("price")){
                        bookData.setPrice(bookChild.getText());
                    }else if(bookChild.getName().equals("language")){
                        bookData.setLanguage(bookChild.getText());
                    }
                }               
                //遍历完一个节点，将该节点信息添加到列表中
                bookList.add(bookData);

                System.out.println("==========结束某一本书遍历===============");
            }
        } catch (DocumentException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("输出XML在内存中的数据");
        System.out.println("保存的数据大小是" + bookList.size());

        //输出保存在内存中XML信息
        for(Book book:bookList){
            System.out.println("===输出开始====");
            System.out.println(book.getName());
            System.out.println("id=" + book.getId());
            System.out.println(book.getAuthor());
            System.out.println(book.getYear());
            System.out.println(book.getPrice());
            System.out.println(book.getLanguage());
            System.out.println("===输出结束===");
        }
    }
}

总结：
1. DOM4J性能最好。
2. 如果XML文档较大且不考虑移植问题，建议采用DOM4J方法。
3. 如果XML文档较小，建议采用DOM。
4. 需要及时处理且不要保存数据考虑SAX。