dom4j的简单使用案例

引入dom4j的jar包：
dom4j-1.6.1.jar和jaxen-1.1-beta-6.jar

测试类：

package com.ming.xmlParse;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URL;
import java.util.Iterator;
import java.util.List;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamSource;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.DocumentResult;
import org.dom4j.io.DocumentSource;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
import org.junit.Test;
import org.xml.sax.SAXException;

/*
 * xml文档内容：
 * 
 *          <?xml version="1.0" encoding="UTF-8"?> 
 *          <!DOCTYPE catalog SYSTEM "file://c:/Dtds/catalog.dtd">
 *          <catalog> 
 *              <!--An XML Catalog--> 
 *              <?target instruction?>
 *              <journal title="XML Zone" publisher="IBM developerWorks">
 *                  <article level="Intermediate" date="December-2001"> 
 *                      <title>Java configuration with XML Schema</title> 
 *                      <author>
 *                          <firstname>Marcello</firstname>
 *                          <lastname>Vitaletti</lastname> 
 *                      </author>
 *                  </article> 
 *              </journal> 
 *          </catalog>
 */



/**
 * @author Alexia
 * 
 *         Dom4j 解析XML文档
 */
public class Dom4jDemo implements XmlDocument {

    /**
     * 简单使用dom4j解析，不使用xpath
     */
    public void parserXml(String fileName) {
        try {
            File file = new File(fileName);
            Document document = parse(file);

            // 获取根元素
            Element root = document.getRootElement();

            // 遍历元素的子元素（只有一层）
            for (Iterator<Element> i = root.elementIterator(); i.hasNext();) {
                Element element = i.next();
                for (Iterator<Element> j = element.elementIterator(); j.hasNext();) {
                    Element element1 = j.next();
                    String name = element1.getName();
                    String text = element1.getTextTrim();
                    System.err.println("--" + name + ":" + text + "--");
                }
            }

            // 遍历元素的子元素（指定元素名称）（只有一层）
            for (Iterator<Element> i = root.elementIterator("journal"); i.hasNext();) {
                Element element = i.next();
                String name = element.getName();
                String text = element.getTextTrim();
                System.err.println("--" + name + ":" + text + "--");
            }

            // 遍历元素的属性
            for (Iterator<Attribute> i = root.attributeIterator(); i.hasNext();) {
                Attribute attribute = i.next();
                String name = attribute.getName();
                String value = attribute.getValue();
                System.err.println("--" + name + ":" + value + "--");
            }

            // 递归遍历根元素下的所有子节点，并进行行相应的操作
            treeWalk(root);

        } catch (DocumentException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        }
    }

    /**
     * 
     * @Title: treeWalk
     * @Description: TODO(递归遍历元素下的所有子节点，并进行行相应的操作)
     * @return void 返回类型
     * @param element
     */
    public void treeWalk(Element element) {
        for (int i = 0, size = element.nodeCount(); i < size; i++) {
            Node node = element.node(i);
            if (node instanceof Element) {
                treeWalk((Element) node);
            } else {

            }
        }
    }

    /**
     * 
     * @Title: createDoc
     * @Description: TODO(使用dom4j创建一个document)
     * @return void 返回类型
     */
    @Test
    public Document createDoc() {
        // 创建文档
        Document document = DocumentHelper.createDocument();

        // 添加子元素
        Element catalogElement = document.addElement("catalog");
        // 添加注释
        catalogElement.addComment("An XML catalog");
        // 添加处理指令
        catalogElement.addProcessingInstruction("target", "text");

        Element journalElement = catalogElement.addElement("journal");
        // 添加属性
        journalElement.addAttribute("title", "XML Zone");
        journalElement.addAttribute("publisher", "IBM developerWorks");

        Element articleElement = journalElement.addElement("article");
        articleElement.addAttribute("level", "Intermediate");
        articleElement.addAttribute("date", "December-2001");

        Element titleElement = articleElement.addElement("title");
        // 设置文本
        titleElement.setText("Java configuration with XML Schema");

        Element authorElement = articleElement.addElement("author");

        Element firstnameElement = authorElement.addElement("firstname");
        firstnameElement.setText("Marcello");
        Element lastnameElement = authorElement.addElement("lastname");
        lastnameElement.setText("Vitaletti");

        // 添加文档类型说明
        document.addDocType("catalog", null, "file://c:/Dtds/catalog.dtd");
        return document;
    }

    /**
     * 
     * @Title: parse
     * @Description: TODO(用SAXReader解析为document)
     * @return Document 返回类型
     * @param url
     * @return
     * @throws DocumentException
     * @throws SAXException
     */
    public Document parse(URL url) throws DocumentException, SAXException {
        SAXReader saxReader = new SAXReader();
        // 忽略<!DOCTYPE>等元素中的dtd校验（如果校验不成功会直接抛出异常）
        saxReader.setValidation(false);
        saxReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        Document document = saxReader.read(url);
        return document;
    }

    /**
     * 
     * @Title: parse
     * @Description: TODO(用SAXReader解析为document)
     * @return Document 返回类型
     * @param url
     * @return
     * @throws SAXException
     * @throws DocumentException
     */
    public Document parse(File file) throws SAXException, DocumentException {
        SAXReader saxReader = new SAXReader();
        // 忽略<!DOCTYPE>等元素中的dtd校验（如果校验不成功会直接抛出异常）
        saxReader.setValidation(false);
        saxReader.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);
        Document document = saxReader.read(file);
        return document;
    }

    /**
     * 
     * @Title: updateDoc
     * @Description: TODO(测试修改文档，使用SAXReader和xpath) 节点的增、删、改、查
     * @return void 返回类型
     * @param filename
     * @throws DocumentException
     * @throws SAXException
     */
    public void updateDoc(String filename) throws DocumentException, SAXException {
        File file = new File(filename);
        // 解析为document
        Document document = parse(file);

        // xpath选择文档中article元素中获得 level属性值是“Intermediate”的元素节点
        List<Element> list = document.selectNodes("//article[@level='Intermediate']");
        Iterator<Element> iterator = list.iterator();
        while (iterator.hasNext()) {
            Element next = iterator.next();
            // next.setAttributeValue("level",
            // "Introductory");//过时用addAttribute替代
            // 修改属性值
            next.addAttribute("level", "Introductory");
            // 添加color属性
            next.addAttribute("color", "red");
        }

        // 选取所有的lastname元素节点
        List<Element> list2 = document.selectNodes("//lastname");
        Iterator<Element> iterator2 = list2.iterator();
        while (iterator2.hasNext()) {
            Element next = iterator2.next();
            String textTrim = next.getTextTrim();
            if ("Vitaletti".equals(textTrim)) {
                // 删除节点
                next.getParent().remove(next);
            }
        }

        // 输出到控制台
        writeDoc(document);
    }

    /**
     * 
     * @Title: writeDoc
     * @Description: TODO(将document格式化输出到指定的文件中)
     * @return void 返回类型
     * @param document
     * @param filename
     */
    public void writeDoc(Document document, String filename) {
        OutputStream outputStream = null;
        XMLWriter xmlWriter = null;
        try {
            // 输出流
            outputStream = new FileOutputStream(filename);

            // 输出格式
            // 设置文件编码
            OutputFormat xmlFormat = new OutputFormat();
            xmlFormat.setEncoding("UTF-8");
            // 设置换行
            xmlFormat.setNewlines(true);
            // 生成缩进
            xmlFormat.setIndent(true);
            // 使用4个空格进行缩进, 可以兼容文本编辑器
            xmlFormat.setIndent("    ");

            xmlWriter = new XMLWriter(outputStream, xmlFormat);
            xmlWriter.write(document);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                xmlWriter.close();
                outputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 
     * @Title: writeDoc
     * @Description: TODO(将document格式化输出控制台)
     * @return void 返回类型
     * @param document
     */
    public void writeDoc(Document document) {
        XMLWriter xmlWriter = null;
        try {
            // 输出格式
            // 设置文件编码
            OutputFormat xmlFormat = new OutputFormat();
            xmlFormat.setEncoding("UTF-8");
            // 设置换行
            xmlFormat.setNewlines(true);
            // 生成缩进
            xmlFormat.setIndent(true);
            // 使用4个空格进行缩进, 可以兼容文本编辑器
            xmlFormat.setIndent("    ");

            xmlWriter = new XMLWriter(xmlFormat);
            xmlWriter.write(document);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                xmlWriter.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 
     * @Title: docToXml
     * @Description: TODO(文档转为xml字符串)
     * @return String 返回类型
     * @param document
     * @return
     */
    public String docToXml(Document document) {
        return document.asXML();
    }

    /**
     * 
     * @Title: xmlToDocument
     * @Description: TODO(xml字符串转为document)
     * @return Document 返回类型
     * @param xml
     * @return
     * @throws DocumentException
     */
    public Document xmlToDocument(String xml) throws DocumentException {
        return DocumentHelper.parseText(xml);
    }


    /**
     * 
    * @Title: styleDocument
    * @Description: TODO(格式转换（未测试，不清楚功能）)
    * @return Document    返回类型
    * @param document
    * @param stylesheet
    * @return
    * @throws Exception
     */
    public Document styleDocument(Document document, String stylesheet) throws Exception {
        // load the transformer using JAXP
        TransformerFactory factory = TransformerFactory.newInstance();
        Transformer transformer = factory.newTransformer(new StreamSource(stylesheet));

        // now lets style the given document
        DocumentSource source = new DocumentSource(document);
        DocumentResult result = new DocumentResult();
        transformer.transform(source, result);

        // return the transformed document
        Document transformedDoc = result.getDocument();
        return transformedDoc;
    }

    public static void main(String[] args) {
        Dom4jDemo dom4jDemo = new Dom4jDemo();

        // 将document写入xml文件中
        dom4jDemo.writeDoc(dom4jDemo.createDoc(), "C:\\Users\\Administrator\\Desktop\\catalog.xml");

        // 测试增、删、改、查docuemnt中的节点，使用xpath
        try {
            dom4jDemo.updateDoc("C:\\Users\\Administrator\\Desktop\\catalog.xml");
        } catch (Exception e) {
            e.printStackTrace();
        }

        // 使用Iterators遍历节点
        dom4jDemo.parserXml("C:\\Users\\Administrator\\Desktop\\catalog.xml");
    }

}