四种解析和创建方式（DOM，SAX，DOM4J，JDOM）

一、先导入jar包

 DOM基于树形，SAX基于事件，DOM4J和JDOM基于底层ＡＰＩ

二、代码如下
  1 package com.sxt.test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import javax.naming.spi.DirStateFactory.Result;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamResult;

import org.dom4j.DocumentException;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.jdom2.Attribute;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
import org.junit.Test;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.AttributesImpl;

import com.sxt.bean.Book;
import com.sxt.bean.SAXParserHandler;

public class Demo1 {

    private ArrayList<Book> booksList = new ArrayList<Book>();

    /*
     * DOM解析
     */
    @Test
    public void testfun1() throws ParserConfigurationException, SAXException,
            IOException {
        // 创建DocumentBuilderFactory对象
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        // 创建DocumentBuilder对象
        DocumentBuilder db = dbf.newDocumentBuilder();
        // 通过DocumentBuilder对象的parser方法加载books.xml文件到当前的目录下
        Document document = db.parse("src/com/sxt/test/bookes.xml");
        // 获取所有的book节点集合
        NodeList bookList = document.getElementsByTagName("book");
        // 通过nodelist的getLength()方法可以获取bookList的长度
        System.out.println("一共有" + bookList.getLength() + "本书");
        // 遍历每一个book节点
        for (int i = 0; i < bookList.getLength(); i++) {
            System.out.println("============开始遍历==================");
            /*
             * //通过item(i)方法获取一个book节点，nodelist的索引值从0开始 Node book =
             * bookList.item(i); //获取book节点的所有属性集合 NamedNodeMap attr =
             * book.getAttributes();
             * System.out.println("第"+(i+1)+"本书共有"+attr.getLength()+"个属性");
             * //遍历book属性 for(int j=0;j<attr.getLength();j++){
             * //通过item(index)方法获取book节点的某一个属性 Node at = attr.item(j); //获取属性名
             * System.out.println("属性名："+at.getNodeName()); //获取属性值
             * System.out.println("属性值："+at.getNodeValue()); }
             */
            Element book = (Element) bookList.item(i);
            /*
             * String attrValue = book.getAttribute("id");
             * System.out.println("属性值为:"+attrValue);
             */
            // 解析book节点的子节点
            NodeList childnNode = book.getChildNodes();
            System.out.println("第" + (i + 1) + "本书共有" + childnNode.getLength()
                    + "个子节点");
            for (int k = 0; k < childnNode.getLength(); k++) {
                // 区分出text类型的node以及element类型的node
                if (childnNode.item(k).getNodeType() == Node.ELEMENT_NODE) {
                    // 获取element类型节点的节点名
                    System.out.println(childnNode.item(k).getNodeName());
                    // System.out.println(childnNode.item(k).getFirstChild().getNodeValue());
                    System.out.println(childnNode.item(k).getTextContent());
                }
            }
            System.out.println("============结束遍历==================");
        }
    }

    /*
     * DOM创建XML文件
     */
    @Test
    public void testfun6() throws ParserConfigurationException,
            TransformerException {
        // 创建DocumentBuilderFactory对象
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        // 创建DocumentBuilder对象
        DocumentBuilder db = dbf.newDocumentBuilder();
        Document document = db.newDocument();
        document.setXmlStandalone(true);
        Element bookstore = document.createElement("bookStore");
        // 向bookstore根节点中添加子节点
        Element book = document.createElement("book");
        Element name = document.createElement("name");
        // name.setNodeValue("小王子");
        name.setTextContent("小王子");
        book.appendChild(name);
        book.setAttribute("id", "1");
        bookstore.appendChild(book);
        document.appendChild(bookstore);

        // 创建TransformerFactory对象
        TransformerFactory tff = TransformerFactory.newInstance();
        // 创建Transformer对象
        Transformer tf = tff.newTransformer();
        tf.setOutputProperty(OutputKeys.INDENT, "yes");
        tf.transform(new DOMSource(document), new StreamResult(new File(
                "src/com/sxt/test/book.xml")));

    }

    /*
     * SAX解析
     */
    @Test
    public void testfun2() throws ParserConfigurationException, SAXException,
            IOException {
        // 获取一个SAXParserFactory的实例
        SAXParserFactory factory = SAXParserFactory.newInstance();
        // 通过factory获取SAXParser实例
        SAXParser parser = factory.newSAXParser();
        // 创建SAXParserHandler对象
        SAXParserHandler handler = new SAXParserHandler();
        parser.parse("src/com/sxt/test/bookes.xml", handler);
        System.out.println("~~~~~~共有" + handler.getBookList().size());
        for (Book book : handler.getBookList()) {
            System.out.println(book.getId());
            System.out.println(book.getAuthor());
            System.out.println(book.getName());
            System.out.println(book.getLanguage());
            System.out.println(book.getPrice());
            System.out.println(book.getYear());
        }

    }

    public ArrayList<Book> parseXML() throws Exception {
        // 获取一个SAXParserFactory的实例
        SAXParserFactory factory = SAXParserFactory.newInstance();
        // 通过factory获取SAXParser实例
        SAXParser parser = factory.newSAXParser();
        // 创建SAXParserHandler对象
        SAXParserHandler handler = new SAXParserHandler();
        parser.parse("src/com/sxt/test/bookes.xml", handler);
        
        return handler.getBookList();

    }

    /*
     * SAX创建ＸＭＬ文件
     */
    @Test
    public void testfun7() throws Exception {
        ArrayList<Book> bookList = parseXML();
        //创建一个TransformerFactory类的对象
        SAXTransformerFactory tff = (SAXTransformerFactory) SAXTransformerFactory.newInstance();
        //通过SAXTransformerFactory对象创建一个TransformerHandler对象
        TransformerHandler handler = tff.newTransformerHandler();
        //通过handler对象创建一个Transformer对象
        Transformer tr = handler.getTransformer();
        //通过Transformer对象对生成的XML文件进行设置（编码）
        tr.setOutputProperty(OutputKeys.ENCODING,"UTF-8");
        //通过Transformer对象进行换行
        tr.setOutputProperty(OutputKeys.INDENT,"yes");
        //创建一个Result对象
        File f = new File("src/com/sxt/test/booke.xml");
        if(!f.exists()){
            f.createNewFile();
        }
        //创建一个Result对象，并且使其与handler关联
        StreamResult result = new StreamResult(new FileOutputStream(f));
        handler.setResult(result);
        //打开document
        handler.startDocument();
        AttributesImpl attr = new AttributesImpl();
        handler.startElement("", "", "bookstore", attr);
        for(Book book:bookList){
            attr.clear();
            attr.addAttribute("", "", "id", "", book.getId());
            handler.startElement("", "", "book", attr);
            
            if(book.getName()!=null&& !book.getName().trim().equals("")){
                attr.clear();
                //创建name节点
                handler.startElement("", "", "name", attr);
                handler.characters(book.getName().toCharArray(), 0, book.getName().length());
                handler.endElement("", "", "name");
            }
            if(book.getAuthor()!=null&& !book.getAuthor().trim().equals("")){
                attr.clear();
                //创建name节点
                handler.startElement("", "", "author", attr);
                handler.characters(book.getAuthor().toCharArray(), 0, book.getAuthor().length());
                handler.endElement("", "", "author");
            }
            if(book.getLanguage()!=null&& !book.getLanguage().trim().equals("")){
                attr.clear();
                //创建name节点
                handler.startElement("", "", "language", attr);
                handler.characters(book.getLanguage().toCharArray(), 0, book.getLanguage().length());
                handler.endElement("", "", "language");
            }
            if(book.getPrice()!=null&& !book.getPrice().trim().equals("")){
                attr.clear();
                //创建name节点
                handler.startElement("", "", "price", attr);
                handler.characters(book.getPrice().toCharArray(), 0, book.getPrice().length());
                handler.endElement("", "", "price");
            }
            if(book.getYear()!=null&& !book.getYear().trim().equals("")){
                attr.clear();
                //创建name节点
                handler.startElement("", "", "year", attr);
                handler.characters(book.getYear().toCharArray(), 0, book.getYear().length());
                handler.endElement("", "", "year");
            }
            
        }
        handler.endElement("", "", "bookstore");
        //关闭document
        handler.endDocument();
    }
    
    /*
     * 创建JDOM
     */
    @Test
    public void createXML() throws Exception{
        //生成一个根节点
        org.jdom2.Element rss = new org.jdom2.Element("rss");
        //为节点添加属性
        rss.setAttribute("version", "2.0");
        //生成一个document对象
        org.jdom2.Document document = new org.jdom2.Document(rss);
        org.jdom2.Element channel = new org.jdom2.Element("channel");
        rss.addContent(channel);
        org.jdom2.Element title = new org.jdom2.Element("title");
        title.setText("国内国际新闻");
        channel.addContent(title);
        
        Format format = Format.getPrettyFormat();
        format.setIndent("");
        format.setEncoding("GBK");
        
        //创建XMLOutputter的对象
        XMLOutputter outputter = new XMLOutputter(format);
        //利用outputer将document对象转换为xml文档
        outputter.output(document, new FileOutputStream(new File("src/com/sxt/test/res.xml")));
    }


    /*
     * JDOM解析
     */
    @Test
    public void testfun3() throws JDOMException, IOException {
        // 创建一个SAXBuilder的对象
        SAXBuilder saxBuilder = new SAXBuilder();
        // 创建一个输入流，将XML文件加载到输入流中
        InputStream in = new FileInputStream("src/com/sxt/test/bookes.xml");
        InputStreamReader isr = new InputStreamReader(in);
        // 通过saxBuilder的build方法，将输入流加载到saxBuilder中
        org.jdom2.Document document = saxBuilder.build(isr);
        // 通过docment对象获取xml文件的根节点
        org.jdom2.Element rootElement = document.getRootElement();
        // 获取根节点下面的字节点
        List<org.jdom2.Element> bookList = rootElement.getChildren();
        // 继续进行解析
        for (org.jdom2.Element book : bookList) {
            Book bookEntity = new Book();
            System.out.println("=====开始解析第" + (bookList.indexOf(book) + 1)
                    + "书=====");
            // 解析book的属性
            List<Attribute> attrList = book.getAttributes();
            // 遍历attribute(针对不清楚book节点下属性名字及数量)
            for (Attribute attr : attrList) {
                // 获取属性名
                String attrName = attr.getName();
                // 获取属性值
                String attrvValue = attr.getValue();
                System.out.println("属性名：" + attrName + "----属性值：" + attrvValue);
                if (attrName.equals("id")) {
                    bookEntity.setId(attrvValue);
                }
            }
            List<org.jdom2.Element> bookchilds = book.getChildren();
            for (org.jdom2.Element child : bookchilds) {
                System.out.println("节点名：" + child.getName() + "----节点值："
                        + child.getValue());
                if (child.getName().equals("name")) {
                    bookEntity.setName(child.getValue());
                } else if (child.getName().equals("author")) {
                    bookEntity.setAuthor(child.getValue());
                } else if (child.getName().equals("year")) {
                    bookEntity.setYear(child.getValue());
                } else if (child.getName().equals("price")) {
                    bookEntity.setPrice(child.getValue());
                } else if (child.getName().equals("language")) {
                    bookEntity.setLanguage(child.getValue());
                }
            }
            System.out.println("=====结束解析第" + (bookList.indexOf(book) + 1)
                    + "书=====");
            booksList.add(bookEntity);
            bookEntity = null;
            System.out.println(bookList.size());
            System.out.println("=======" + booksList.get(0).getId());
            System.out.println("=======" + booksList.get(0).getAuthor());
        }
    }

    /*
     * 创建DOM4J
     */
    @Test
    public void parseXML4J() throws DocumentException {
        // 创建SAXReader的对象reader
        SAXReader reader = new SAXReader();
        // 通过reader对象的read方法加载book.xml文件
        org.dom4j.Document document = reader.read(new File(
                "src/com/sxt/test/bookes.xml"));
        // 通过document对象获取根节点bookstore
        org.dom4j.Element bookStore = document.getRootElement();
        // 通过element对象的elementIterator方法获取迭代器
        Iterator<org.dom4j.Element> it = bookStore.elementIterator();
        // 遍历迭代器，获取根节点中的信息（书籍）
        while (it.hasNext()) {
            System.out.println("=========开始遍历某一本书===========");
            org.dom4j.Element book = (org.dom4j.Element) it.next();
            // 获取book的属性值和属性名
            List<org.dom4j.Attribute> bookattrs = book.attributes();
            for (org.dom4j.Attribute attr : bookattrs) {
                System.out.println("--节点名：" + attr.getName() + "--节点值："
                        + attr.getValue());
            }
            Iterator itt = book.elementIterator();
            while (itt.hasNext()) {
                org.dom4j.Element bookChild = (org.dom4j.Element) itt.next();
                System.out.println("节点名" + bookChild.getName() + "---节点值"
                        + bookChild.getStringValue());
            }
            System.out.println("=========结束遍历某一本书===========");
        }
    }
    
    /*
     * 创建DOM4J
     */
    @Test
    public void testfun8() throws Exception {
        //创建document对象，代表整个xml文档
        org.dom4j.Document document = org.dom4j.DocumentHelper.createDocument();
        //创建根节点rss
        org.dom4j.Element rss = document.addElement("rss");
        //向rss节点中添加version属性
        rss.addAttribute("version", "2.0");
        //生成子节点及节点内容
        org.dom4j.Element channel = rss.addElement("channel");
        org.dom4j.Element title = channel.addElement("title");
        title.setText("国内最新新闻");
        //设置生成xml格式
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("GBK");
        //生成xml文件
        File file = new File("src/com/sxt/test/rssnews.xml");
        XMLWriter writer = new XMLWriter(new FileOutputStream(file),format);
        writer.write(document);
        writer.close();
    }
    
    /*
     * DOM4J解析
     */
    @Test
    public void testfun4() throws DocumentException {
        // 创建SAXReader的对象reader
        SAXReader reader = new SAXReader();
        // 通过reader对象的read方法加载book.xml文件
        org.dom4j.Document document = reader.read(new File(
                "src/com/sxt/test/bookes.xml"));
        // 通过document对象获取根节点bookstore
        org.dom4j.Element bookStore = document.getRootElement();
        // 通过element对象的elementIterator方法获取迭代器
        Iterator<org.dom4j.Element> it = bookStore.elementIterator();
        // 遍历迭代器，获取根节点中的信息（书籍）
        while (it.hasNext()) {
            System.out.println("=========开始遍历某一本书===========");
            org.dom4j.Element book = (org.dom4j.Element) it.next();
            // 获取book的属性值和属性名
            List<org.dom4j.Attribute> bookattrs = book.attributes();
            for (org.dom4j.Attribute attr : bookattrs) {
                System.out.println("--节点名：" + attr.getName() + "--节点值："
                        + attr.getValue());
            }
            Iterator itt = book.elementIterator();
            while (itt.hasNext()) {
                org.dom4j.Element bookChild = (org.dom4j.Element) itt.next();
                System.out.println("节点名" + bookChild.getName() + "---节点值"
                        + bookChild.getStringValue());
            }
            System.out.println("=========结束遍历某一本书===========");
        }
    }

    @Test
    public void testDemo() throws Exception {
        System.out.println("性能测试");
        // 测试DOM的性能
        long start1 = System.currentTimeMillis();
        testfun1();
        System.out.println("DOM: " + (System.currentTimeMillis() - start1));
        // 测试DOM的性能
        long start2 = System.currentTimeMillis();
        testfun2();
        System.out.println("SAX: " + (System.currentTimeMillis() - start2));
        // 测试DOM的性能
        long start3 = System.currentTimeMillis();
        testfun3();
        System.out.println("JDOM: " + (System.currentTimeMillis() - start3));
        // 测试DOM的性能
        long start4 = System.currentTimeMillis();
        testfun4();
        System.out.println("DOM4J: " + (System.currentTimeMillis() - start4));
    }
}

package com.sxt.test;

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

public  class MyContentHandler extends DefaultHandler{
    @Override
    public void startDocument() throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("开始解析");
    }
    @Override
    public void endDocument() throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("结束解析");
    }
    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("元素解析开始");
    }
    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("元素解析结束");
    }
    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        String s = new String(ch,start,length);
        if(s.trim().isEmpty()){
            return;
        }
        System.out.println("文本内容为"+s);
    }
    @Override
    public void ignorableWhitespace(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("文本内容为空");
    }
    @Override
    public void processingInstruction(String target, String data)
            throws SAXException {
        // TODO Auto-generated method stub
        System.out.println("处理指令");
    }
}