Java Dom4j 操作XML

经常使用的操作包括：
* 1，读取节点的值
* 2，新增节点：
*   2.1，添加子节点:根据子节点名称和内容添加；根据子节点xml添加
*   2.2，添加兄弟节点
*   2.3，为节点/hyman/user/username添加父节点/hyman/user/usermanage，那么原来的节点路径变为：/hyman/user/usermanage/username
* 3，删除节点
* 4，设置节点的值
*   4.1，设置叶子节点的值
*   4.2，设置非叶子结点（即存在子节点）的值
*     4.2.1，删除原来的子节点和子节点的子节点，设置文本值
*     4.2.2，删除原来的子节点和子节点的子节点，设置新的子节点
* 5，把xml文件转化为string输出
* 6，把string转化为xml输出

Dom4j操作XML主要有三大对象：Document,Node,Element。
可以利用SAXReader 从文件中创建Document，或者XMLHelper创建。
可以利用XMLWriter写xml文件。
三者关系：Document,Element –> Branch –> Node
具体可以查看api：http://www.oschina.net/uploads/doc/dom4j-1.6.1/index.html。

需要引入的jar包：

<dependency>
    <groupId>dom4j</groupId>
    <artifactId>dom4j</artifactId>
    <version>1.6.1</version>
</dependency>
<dependency>
    <groupId>jaxen</groupId>
    <artifactId>jaxen</artifactId>
    <version>1.1.6</version>
</dependency>

项目目录如下：

注意：操作实际影响的是target/classes目录下的xml文件，src目录下的xml文件不会受影响。

下面展示各种操作主要的代码：

1，获取文件的真实路径：

public static String getRealPath(String filePath){
    ClassLoader classLoader=Thread.currentThread().getContextClassLoader();
    URL url=classLoader.getResource(filePath);
    return url.getPath();
}

2，已知xml文件路径，获取Document对象

/**
     * 根据文件路径获取document对象
     * @param filePath xml文件路径
     * @return
     */
public static Document getDocument(String filePath) {
    String realPath = getRealPath(filePath);
    SAXReader builder = new SAXReader();
    InputStream in = new FileInputStream(realPath);
    InputStreamReader reader = new InputStreamReader(in, "UTF-8");
    Document  document = builder.read(reader);
    return document;
}

3，写入xml文件

/**
     * 写入xml文件
     * @param document  document对象
     * @param filePath  xml文件路径
     */
public static void writeDocument(Document document,String filePath){
    OutputFormat format = OutputFormat.createPrettyPrint();
    format.setEncoding("UTF-8");
    XMLWriter writer = new XMLWriter(new OutputStreamWriter(new FileOutputStream(FileUtils.getRealPath(filePath))), format);
    writer.write(document);
    writer.close();
}

4，获取指定节点的值

/**
 * 根据节点路径获取节点值
 * @param filePath  xml文件路径
 * @param nodePath  节点路径
 * @return
 */
public static String getNodeValueByPath(String filePath, String nodePath) {
    Document document = getDocument(filePath);
    Element element = (Element) document.selectSingleNode(nodePath);
    return element.getText();
}

5，添加子节点
5.1根据自己名称和内容添加

/**
 * 添加子节点--传入子节点名称和内容进行添加，一次只能添加一个子节点，并且只能添加一层
 * @param filePath  文件路径
 * @param nodePath  要添加子节点的路径
 * @param nodeName  添加的字节点名称
 * @param text  添加的子节点内容
 */
public static void addChildNodeByNodeAndValue(String filePath, String nodePath, String nodeName,String text) {
    Document document = getDocument(filePath);
    Element element = (Element) document.selectSingleNode(nodePath);
    element.addElement(nodeName).setText(text);
    writeDocument(document, filePath);
}

5.2 根据子节点xml字符串添加

/**
 * 添加子节点--传入子节点xml字符串 进行添加，一次只能添加一个子节点，但是可以添加多层
 * @param filePath  XML文件路径
 * @param nodePath    节点路径
 * @param childStr  子节点xml字符串
 */
public static void addChildNodeByChildStr(String filePath, String nodePath, String childStr) {
    Document document = getDocument(filePath);
    Element element = (Element) document.selectSingleNode(nodePath);
    Document childDocument = DocumentHelper.parseText(childStr);
    Node node=childDocument.getRootElement();
    element.add(node);
    writeDocument(document, filePath);
}

6，添加兄弟节点
添加兄弟节点的方法很简单，先找到父节点，然后为父节点添加子节点即可

/**
 * 为指定节点添加兄弟节点
 * @param filePath  xml文件路径
 * @param nodePath  要添加兄弟节点的节点路径
 * @param brotherStr  要添加的兄弟节点的xml字符串，例如：<usercode>12345678</usercode>
 */
public static void addBrotherNodeByNodeStr(String filePath, String nodePath, String brotherStr){
    Document document = getDocument(filePath);
    Element element = (Element) document.selectSingleNode(nodePath);
    Document brotherDocument = DocumentHelper.parseText(brotherStr);
    Node node=brotherDocument.getRootElement();
    if(element.getParent()==null){
        System.out.println("不能为根节点添加兄弟节点");
        return;
    }
    element.getParent().add(node);
    writeDocument(document, filePath);
}

7，添加父节点
添加父节点类似于在链表中插入节点，先保留当前节点的所有信息，创建新节点，让当前节点作为新节点的父节点，删除当前节点，当前节点的原来的父节点作为新节点的父节点：

/**
 * 为指定节点添加父节点,原理类似链表插入节点
 * @param filePath  xml文件路径
 * @param nodePath  节点路径
 * @param parentXmlStr  要添加的父节点的xml字符串
 */
public static void addParentNodeByParentXmlStr(String filePath,String nodePath,String parentXmlStr) {
    Document document = null;

    Element element = (Element) document.selectSingleNode(nodePath);
    Element formerParentElement = element.getParent();

    //代表是根节点
    if(formerParentElement==null){
        System.out.println("不能为根节点添加父节点。。。");
        return;
    } else {
        //创建新的父节点
        Element newParentElement=DocumentHelper.parseText(parentXmlStr).getRootElement();
        //删除当前节点和它的子节点
        element.detach();

        //新的父节点添加原来的节点
        newParentElement.add(element);
        //节点的原来的父节点添加新的父节点
        formerParentElement.add(newParentElement);
    }

       writeDocument(document, filePath);
}

8，删除节点：
删除节点可以使用detach方法，此方法会删除当前节点以及子节点。

/**
 * 根据节点路径删除节点
 * @param filePath  xml文件路径
 * @param nodePath  节点路径
 */
public static void removeNodeByXPath(String filePath, String nodePath){
    Document document = getDocument(filePath);
    Element element = (Element) document.selectSingleNode(nodePath);
    element.detach();
    writeDocument(document, filePath);
}

9，删除节点的所有子节点

/**
 * 删除指定节点的所有子节点
 * @param filePath
 * @param nodePath
 */
public static void removeChildNodeByXPath(String filePath, String nodePath){
    Document document = getDocument(filePath);

    Element element = (Element) document.selectSingleNode(nodePath);
    @SuppressWarnings("unchecked")
    List<Element> list = element.elements();
    if(list!=null){
        for(Element el : list){
            el.detach();
        }
    }

    writeDocument(document, filePath);

}

10，更新叶子节点内容
所谓叶子节点，代表该节点没有子节点。

/**
 * 根据节点路径修改叶子节点内容
 * 
 * @param filePath xml文件相对于根目录的路径,例如：xml/test.xml
 * @param nodePath 节点路径，例如：/hyman/user/username
 * @param text 要更新的节点内容
 */
public static void setLeafNodeValue(String filePath, String nodePath, String text) {
    Document document = getDocument(filePath);

    Element element = (Element) document.selectSingleNode(nodePath);
    element.setText(text);
    writeDocument(document, filePath);
}

11，更新非叶子结点内容
（1）删除原来的子节点，设置成text

/**
 * 根据节点路径和新增内容字符串修改非叶子节点内容,删除原来子节点，设置新的text值
 * 
 * @param filePath  xml文件路径
 * @param nodePath  节点路径
 * @param text  设置后的节点内容
 */
public static void setNonLeafNodeValueToText(String filePath, String nodePath, String text) {
    Document document = getDocument(filePath);

    removeChildNodeByXPath(document, nodePath);
    setLeafNodeValue(document, nodePath, text);

    writeDocument(document, filePath);
}

（2）删除原来的子节点，添加新子节点

/**
 * 设置非叶子结点的值，删除原来的子节点，设置新的子节点
 * @param filePath  xml文件路径
 * @param nodePath  节点路径
 * @param childStr  新的子节点的xml字符串
 */
public static void setNonLeafNodeValueToNewChild(String filePath, String nodePath, String childStr) {
    Document document = getDocument(filePath);

    removeChildNodeByXPath(document, nodePath);
    addChildNodeByChildStr(document, nodePath, childStr);

    writeDocument(document, filePath);
}

12，XML转String
用asXml方法即可完成。

public static String xmlToStr(String filePath){
    Document document = getDocument(filePath);
    return document.asXML();
}

13，String转xml
利用DocumentHelper.parseText方法可以完成。

/**
 * 把xml格式的字符串转化为xml对象
 * @param xmlStr  xml格式的字符串
 * @param filePath  节点路径
 * @return
 */
public static Document strToXml(String xmlStr,String filePath){
    xmlStr = preTreatXmlStr(xmlStr);
    Document document=null;
    document=DocumentHelper.parseText(xmlStr);
    writeDocument(document, filePath);
    return document;
}

其中预处理函数如下：

/**
 * 预处理xml字符串，去掉乱码特殊字符，加上xml抬头
 * 
 * @param xmlStr
 * @return
 */
public static String preTreatXmlStr(String xmlStr) {
    if (StringUtils.isBlank(xmlStr) || "null".equalsIgnoreCase(xmlStr)) {
        xmlStr = "<hyman></hyman>";
    }
    // 去掉乱码
    xmlStr.replace("�", "");
    // 添加xml文件开头
    if (!xmlStr.startsWith("<?xml")) {
        xmlStr = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + xmlStr;
    }
    return xmlStr;
}

14，完整代码如下：
（1）FileUtils.java：

import java.net.URL;

public class FileUtils {
    /**
     * 获取文件的实际路径
     * @param filePath 文件相对于根目录的路径
     * @return
     */
    public static String getRealPath(String filePath){
        ClassLoader classLoader=Thread.currentThread().getContextClassLoader();
        URL url=classLoader.getResource(filePath);
        return url.getPath();
    }
}

（2）XmlUtils.java：

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

/**
 * 读取和操作XML文件
 * 
 * @author Administrator
 *
 * 包括如下方法： 
 * 1，读取节点的值 
 * 2，新增节点：
 *      2.1，在/hyman/user节点下添加子节点:根据子节点名称和内容添加；根据子节点xml添加
 *      2.2，为/hyman/user/username节点添加兄弟节点/hyman/user/usercode
 *      2.3，为节点/hyman/user/username添加父节点/hyman/user/usermanage，那么原来的节点路径变为：/hyman/user/usermanage/username 
 * 3，删除节点 
 * 4，设置节点的值
 *      4.1，设置叶子节点/hyman/user/username的值 
 *      4.2，设置非叶子结点（即存在子节点）/hyman/user的值
 *          4.2.1，删除原来的子节点和子节点的子节点，设置文本值 
 *          4.2.2，删除原来的子节点和子节点的子节点，设置新的子节点
 * 5，把xml文件转化为string输出 
 * 6，把string转化为xml输出
 *
 */

public class XmlUtils {
    /**
     * 根据文件路径获取document对象
     * @param filePath xml文件路径
     * @return
     */
    public static Document getDocument(String filePath) {
        String realPath = FileUtils.getRealPath(filePath);
        SAXReader builder = new SAXReader();
        Document document=null;
        try {
            InputStream in = new FileInputStream(realPath);
            InputStreamReader reader = new InputStreamReader(in, "UTF-8");
            document = builder.read(reader);
        } catch (Exception e) {
            System.out.println("获取document对象出错！");
            e.printStackTrace();
        }
        return document;
    }


    /**
     * 写入xml文件
     * @param document  document对象
     * @param filePath  xml文件路径
     */
    public static void writeDocument(Document document,String filePath){
        OutputFormat format = OutputFormat.createPrettyPrint();
        format.setEncoding("UTF-8");
        try {
            XMLWriter writer = new XMLWriter(new OutputStreamWriter(new FileOutputStream(FileUtils.getRealPath(filePath))), format);
            writer.write(document);
            writer.close();
        } catch (Exception e) {
            System.out.println("写入xml文件失败");
            e.printStackTrace();
        }
    }


    /**
     * 根据节点路径获取节点值
     * @param filePath  xml文件路径
     * @param nodePath  节点路径
     * @return
     */
    public static String getNodeValueByPath(String filePath, String nodePath) {
        Document document = getDocument(filePath);
        if(document==null){
            return null;
        }
        Element element = (Element) document.selectSingleNode(nodePath);
        System.out.println(nodePath + ": " + element.getText());
        return element.getText();
    }


    /**
     * 添加子节点--传入子节点名称和内容进行添加，一次只能添加一个子节点，并且只能添加一层
     * @param filePath  文件路径
     * @param nodePath  要添加子节点的路径
     * @param nodeName  添加的字节点名称
     * @param text  添加的子节点内容
     */
    public static void addChildNodeByNodeAndValue(String filePath, String nodePath, String nodeName,String text) {
        Document document = getDocument(filePath);
        if(document==null){
            return;
        }
        try {
            Element element = (Element) document.selectSingleNode(nodePath);
            element.addElement(nodeName).setText(text);
            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("添加子节点失败。。。");
            e.printStackTrace();
        }
    }

    /**
     * 
     * @param document
     * @param nodePath
     * @param nodeName
     * @param text
     */
    public static void addChildNodeByNodeAndValue(Document document, String nodePath, String nodeName,String text) {
        try {
            Element element = (Element) document.selectSingleNode(nodePath);
            element.addElement(nodeName).setText(text);
        } catch (Exception e) {
            System.out.println("添加子节点失败。。。");
            e.printStackTrace();
        }
    }

    /**
     * 添加子节点--传入子节点xml字符串 进行添加，一次只能添加一个子节点，但是可以添加多层
     * @param filePath  XML文件路径
     * @param nodePath  节点路径
     * @param childStr  子节点xml字符串
     */
    public static void addChildNodeByChildStr(String filePath, String nodePath, String childStr) {
        Document document = getDocument(filePath);
        if(document==null){
            return;
        }
        try {
            if(StringUtils.isBlank(childStr) || !childStr.startsWith("<")){
                return;
            }
            Element element = (Element) document.selectSingleNode(nodePath);
            Document childDocument = DocumentHelper.parseText(childStr);
            Node node=childDocument.getRootElement();
            element.add(node);

            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("添加子节点失败。。。");
            e.printStackTrace();
        }
    }


    /**
     * 添加子节点--传入子节点xml字符串 进行添加，一次只能添加一个子节点，但是可以添加多层
     * @param document  document对象
     * @param nodePath  节点路径
     * @param childStr  子节点字符串
     * @throws DocumentException 
     */
    public static void addChildNodeByChildStr(Document document, String nodePath, String childStr) throws DocumentException {
        if(StringUtils.isBlank(childStr) || !childStr.startsWith("<")){
            return;
        }
        Element element = (Element) document.selectSingleNode(nodePath);
        Document childDocument = DocumentHelper.parseText(childStr);
        Node node=childDocument.getRootElement();
        element.add(node);
    }


    /**
     * 为指定节点添加兄弟节点
     * @param filePath  xml文件路径
     * @param nodePath  要添加兄弟节点的节点路径
     * @param brotherStr  要添加的兄弟节点的xml字符串，例如：<usercode>12345678</usercode>
     */
    public static void addBrotherNodeByNodeStr(String filePath, String nodePath, String brotherStr){
        Document document = getDocument(filePath);
        if(document==null){
            return;
        }
        try {
            if(StringUtils.isBlank(brotherStr) || !brotherStr.startsWith("<")){
                return;
            }
            if(StringUtils.isBlank(nodePath)){
                return;
            }
            Element element = (Element) document.selectSingleNode(nodePath);

            Document brotherDocument = DocumentHelper.parseText(brotherStr);
            Node node=brotherDocument.getRootElement();
            if(element.getParent()==null){
                System.out.println("不能为根节点添加兄弟节点");
                return;
            }
            element.getParent().add(node);

            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("添加子节点失败。。。");
            e.printStackTrace();
        }
    }


    /**
     * 为指定节点添加父节点,原理类似链表插入节点
     * @param filePath  xml文件路径
     * @param nodePath  节点路径
     * @param parentXmlStr  要添加的父节点的xml字符串
     */
    public static void addParentNodeByParentXmlStr(String filePath,String nodePath,String parentXmlStr) {
        Document document = null;
        try {
            document = getDocument(filePath);
            if(document==null){
                return;
            }
            Element element = (Element) document.selectSingleNode(nodePath);
            Element formerParentElement = element.getParent();

            //代表是根节点
            if(formerParentElement==null){
                System.out.println("不能为根节点添加父节点。。。");
                return;
            } else {
                //创建新的父节点
                Element newParentElement=DocumentHelper.parseText(parentXmlStr).getRootElement();
                //删除当前节点和它的子节点
                element.detach();

                //新的父节点添加原来的节点
                newParentElement.add(element);
                //节点的原来的父节点添加新的父节点
                formerParentElement.add(newParentElement);
            }

             writeDocument(document, filePath);
         } catch (Exception e){
             e.printStackTrace();
         }
    }


    /**
     * 根据节点路径删除节点
     * @param filePath  xml文件路径
     * @param nodePath  节点路径
     */
    public static void removeNodeByXPath(String filePath, String nodePath){
        Document document = getDocument(filePath);
        if(document==null){
            return;
        }
        try {
            if(StringUtils.isBlank(nodePath)){
                return;
            }
            Element element = (Element) document.selectSingleNode(nodePath);
            element.detach();

            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("删除子节点失败。。。");
            e.printStackTrace();
        }
    }


    /**
     * 根据节点路径删除节点
     * @param filePath  xml文件路径
     * @param nodePath  节点路径
     */
    public static void removeNodeByXPath(Document document, String nodePath){
        if(StringUtils.isBlank(nodePath)){
            return;
        }
        Element element = (Element) document.selectSingleNode(nodePath);
        element.detach();
    }



    /**
     * 删除指定节点的所有子节点
     * @param filePath
     * @param nodePath
     */
    public static void removeChildNodeByXPath(String filePath, String nodePath){
        Document document = getDocument(filePath);
        if(document==null){
            return;
        }
        try {
            if(StringUtils.isBlank(nodePath)){
                return;
            }
            Element element = (Element) document.selectSingleNode(nodePath);
            @SuppressWarnings("unchecked")
            List<Element> list = element.elements();
            if(list!=null){
                for(Element el : list){
                    el.detach();
                }
            }

            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("添加子节点失败。。。");
            e.printStackTrace();
        }
    }


    /**
     * 删除指定节点的所有子节点
     * @param filePath
     * @param nodePath
     */
    public static void removeChildNodeByXPath(Document document, String nodePath){
        if(StringUtils.isBlank(nodePath)){
            return;
        }
        Element element = (Element) document.selectSingleNode(nodePath);
        @SuppressWarnings("unchecked")
        List<Element> list = element.elements();
        if(list!=null){
            for(Element el : list){
                el.detach();
            }
        }
    }

    /**
     * 根据节点路径修改叶子节点内容
     * 
     * @param filePath xml文件相对于根目录的路径,例如：xml/test.xml
     * @param nodePath 节点路径，例如：/hyman/user/username
     * @param text 要更新的节点内容
     */
    public static void setLeafNodeValue(String filePath, String nodePath, String text) {
        Document document = getDocument(filePath);
        if(document==null){
            return;
        }

        try {
            Element element = (Element) document.selectSingleNode(nodePath);
            element.setText(text);

            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("设置节点值失败。。。nodepath: " + nodePath);
            e.printStackTrace();
        }
    }

    /**
     * 根据节点路径修改叶子节点内容
     * 
     * @param filePath  xml文件路径
     * @param nodePath  节点路径
     * @param text  更新后的节点内容
     */
    public static void setLeafNodeValue(Document document, String nodePath, String text) {
        Element element = (Element) document.selectSingleNode(nodePath);
        element.setText(text);
    }

    /**
     * 根据节点路径和新增内容字符串修改非叶子节点内容,删除原来子节点，设置新的text值
     * 
     * @param filePath  xml文件路径
     * @param nodePath  节点路径
     * @param text  设置后的节点内容
     */
    public static void setNonLeafNodeValueToText(String filePath, String nodePath, String text) {
        Document document = getDocument(filePath);
        if(document==null){
            return;
        }

        try {
            removeChildNodeByXPath(document, nodePath);
            setLeafNodeValue(document, nodePath, text);

            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("设置节点值失败。。。nodepath: " + nodePath);
            e.printStackTrace();
        }
    }


    /**
     * 设置非叶子结点的值，删除原来的子节点，设置新的子节点
     * @param filePath  xml文件路径
     * @param nodePath  节点路径
     * @param childStr  新的子节点的xml字符串
     */
    public static void setNonLeafNodeValueToNewChild(String filePath, String nodePath, String childStr) {
        Document document = getDocument(filePath);
        if(document==null){
            return;
        }

        try {
            removeChildNodeByXPath(document, nodePath);
            addChildNodeByChildStr(document, nodePath, childStr);

            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("设置节点值失败。。。nodepath: " + nodePath);
            e.printStackTrace();
        }
    }


    /**
     * xml对象转化为字符串
     * @param filePath
     * @return
     */
    public static String xmlToStr(String filePath){
        Document document = getDocument(filePath);
        if(document==null){
            return "";
        }

        return document.asXML();
    }


    /**
     * 把xml格式的字符串转化为xml对象
     * @param xmlStr  xml格式的字符串
     * @param filePath  节点路径
     * @return
     */
    public static Document strToXml(String xmlStr,String filePath){
        xmlStr = preTreatXmlStr(xmlStr);
        Document document=null;
        try {
            document=DocumentHelper.parseText(xmlStr);
            writeDocument(document, filePath);
        } catch (Exception e) {
            System.out.println("字符串转化为Document对象失败");
            e.printStackTrace();
        }

        return document;
    }


    /**
     * 预处理xml字符串，去掉乱码特殊字符，加上xml抬头
     * 
     * @param xmlStr
     * @return
     */
    public static String preTreatXmlStr(String xmlStr) {
        if (StringUtils.isBlank(xmlStr) || "null".equalsIgnoreCase(xmlStr)) {
            xmlStr = "<hyman></hyman>";
        }
        // 去掉乱码
        xmlStr.replace("�", "");
        // 添加xml文件开头
        if (!xmlStr.startsWith("<?xml")) {
            xmlStr = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" + xmlStr;
        }

        return xmlStr;
    }

}

15，测试代码如下：

public class XmlUtilsTest {

    @Test
    public void testGetNodeValueByPath() {
        String filePath = "xml/test.xml";
        String nodePath="/hyman/user/username";
        try {
            XmlUtils.getNodeValueByPath(filePath, nodePath);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void testAddChildNode(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user";
        String nodeName="mobile";
        String text="18888888888";
        try {
            XmlUtils.addChildNodeByNodeAndValue(filePath, nodePath, nodeName, text);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testAddChildNodeByChildStr(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user";
        String childStr="<teacher><name>zhangsan</name><mobile>18889898989</mobile></teacher>";
        try {
            XmlUtils.addChildNodeByChildStr(filePath, nodePath, childStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testAddBrotherNodeByNodeStr(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user/username";
        String brotherStr="<usercode>12345678</usercode>";
        try {
            XmlUtils.addBrotherNodeByNodeStr(filePath, nodePath, brotherStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void testRemoveNodeByXPath(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user";
        try {
            XmlUtils.removeNodeByXPath(filePath, nodePath);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }



    @Test
    public void testRemoveChildNodeByXPath(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user";
        try {
            XmlUtils.removeChildNodeByXPath(filePath, nodePath);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }



    @Test
    public void testSetLeafNodeValue(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user/password";
        String text="hello world";
        XmlUtils.setLeafNodeValue(filePath, nodePath, text);
    }



    @Test
    public void testSetNonLeafNodeValueToText(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user";
        String text="hello world";
        XmlUtils.setNonLeafNodeValueToText(filePath, nodePath, text);
    }



    @Test
    public void testSetNonLeafNodeValueToNewChild(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user";
        String childStr="<userinfo><usercode>12345678</usercode><addr>beijing</addr></userinfo>";
        XmlUtils.setNonLeafNodeValueToNewChild(filePath, nodePath, childStr);
    }


    @Test
    public void testXmlToStr(){
        String filePath = "xml/test.xml";
        String xmlStr=XmlUtils.xmlToStr(filePath);
        System.out.println(xmlStr);
    }



    @Test
    public void testStrToXml(){
        String xmlStr="<hyman><user><userinfo><usercode>88888888</usercode><addr>beijing</addr></userinfo></user></hyman>";
        XmlUtils.strToXml(xmlStr,"xml/test2.xml");
    }


    @Test
    public void testAddParentNodeByXmlStr(){
        String filePath = "xml/test.xml";
        String nodePath = "hyman/user/username";
        String parentStr = "<userinfo></userinfo>";
        XmlUtils.addParentNodeByParentXmlStr(filePath, nodePath, parentStr);
    }
}