`

Dom4j节点处理器实现

 
阅读更多
XMLApachelog4jJDKIDEA 
      Dom4j为XML文档解析提供了强大的API支持，在实际开发中，为了处理方便，常常以节点元素（Element）为单位进行处理，并且结合数据库和Java技术，为节点生成ID属性。这样，就很有必要在Dom4j的基础上，重新封装一些适用需要的方法，以提高开发效率。下面是我利用业余时间做的一个Dom4j节点处理器工具类的实现。希望能节省开发人员宝贵时间。

说明：为了写起来方便，可以单独运行，我没有写单独的测试类，实际用的时候，删除掉测试main（）和test（）方法即可。

注释很详细，不用废话了。下面是处理器的实现：
Java代码 复制代码 收藏代码
  1. package com.topsoft.icib.common.utils;    
  2.   
  3. import org.dom4j.*;    
  4. import org.apache.commons.logging.Log;    
  5. import org.apache.commons.logging.LogFactory;    
  6. import org.apache.commons.lang.StringUtils;    
  7.   
  8. import java.util.Random;    
  9. import java.util.Iterator;    
  10. import java.util.ArrayList;    
  11.   
  12. /**   
  13. * Created by IntelliJ IDEA.<br>   
  14. * <b>User</b>: leizhimin<br>   
  15. * <b>Date</b>: 2008-3-27 18:42:39<br>   
  16. * <b>Note</b>: XML节点处理器，包含XML元素的CRUD方法。   
  17. */    
  18. public class XmlNodeHandler {    
  19.     private static Log log = LogFactory.getLog(XmlNodeHandler.class);    
  20.   
  21.     /**   
  22.      * 在xml的指定位置插入一个元素   
  23.      *   
  24.      * @param srcXml  原xml   
  25.      * @param nodeXml 元素xml   
  26.      * @param xpath   要插入元素父节点的位置   
  27.      * @return 原xml插入节点后的完整xml文档   
  28.      */    
  29.     public static String addElement(String srcXml, String nodeXml, String xpath) {    
  30.         String resultXml = null;    
  31.         try {    
  32.             Document docSrc = DocumentHelper.parseText(srcXml);    
  33.             Document docNode = DocumentHelper.parseText(nodeXml);    
  34.             Element parentElement = (Element) docSrc.getRootElement().selectSingleNode(xpath);    
  35.             parentElement.add(docNode.getRootElement());    
  36.             resultXml = docSrc.asXML();    
  37.         } catch (DocumentException e) {    
  38.             log.error("在文档" + xpath + "位置添加新节点发生异常，请检查！");    
  39.             System.out.println(e.getMessage());    
  40.             e.printStackTrace();    
  41.         }    
  42.         return resultXml;    
  43.     }    
  44.   
  45.     /**   
  46.      * 删除xml文档中指定ID的元素   
  47.      *   
  48.      * @param srcXml    原xml   
  49.      * @param xmlNodeId 元素ID属性值   
  50.      * @return 删除元素后的xml文档   
  51.      */    
  52.     public static String removeElementById(String srcXml, String xmlNodeId) {    
  53.         String resultXml = null;    
  54.         try {    
  55.             Document docSrc = DocumentHelper.parseText(srcXml);    
  56.             Element removeElement = docSrc.getRootElement().elementByID(xmlNodeId);    
  57.             removeElement.detach();  //直接删除自己    
  58. //            removeElement.getParent().remove(removeElement);  //从父节点删除子节点    
  59.             resultXml = docSrc.asXML();    
  60.         } catch (DocumentException e) {    
  61.             log.error("删除文档中ID为" + xmlNodeId + "的节点发生异常，请检查！");    
  62.             System.out.println(e.getMessage());    
  63.             e.printStackTrace();    
  64.         }    
  65.         return resultXml;    
  66.     }    
  67.   
  68.     /**   
  69.      * 删除xml文档中以xpath为直接父节点的ID属性为空的子节点，ID属性为空包括值为空、空串、或者ID属性不存在。   
  70.      *   
  71.      * @param srcXml 原xml文档   
  72.      * @param xpath  要删除空节点的所在父节点的xpath   
  73.      * @return 删除空节点后的xml文档   
  74.      */    
  75.     public static String removeNullIdElement(String srcXml, String xpath) {    
  76.         String resultXml = null;    
  77.         try {    
  78.             Document srcDoc = DocumentHelper.parseText(srcXml);    
  79.             removeNullIdElement(srcDoc, xpath);    
  80.             resultXml = srcDoc.asXML();    
  81.         } catch (DocumentException e) {    
  82.             log.error("在" + xpath + "下删除空节点发生异常，请检查xpath是否正确！");    
  83.             System.out.println(e.getMessage());    
  84.             e.printStackTrace();    
  85.         }    
  86.         return resultXml;    
  87.     }    
  88.   
  89.     /**   
  90.      * 删除xml文档中以xpath为直接父节点的ID属性为空的子节点，ID属性为空包括值为空、空串、或者ID属性不存在。   
  91.      *   
  92.      * @param srcDoc 原xml的Document对象   
  93.      * @param xpath  要删除空节点的所在父节点的xpath   
  94.      * @return 删除空节点后的xml文档   
  95.      */    
  96.     public static Document removeNullIdElement(Document srcDoc, String xpath) {    
  97.         Node parentNode = srcDoc.getRootElement().selectSingleNode(xpath);    
  98.         if (!(parentNode instanceof Element)) {    
  99.             log.error("所传入的xpath不是Elementpath，删除空节点失败！");    
  100.         } else {    
  101.             int i = 0;    
  102.             for (Iterator<Element> it = ((Element) parentNode).elementIterator(); it.hasNext();) {    
  103.                 Element element = it.next();    
  104.                 if (element.attribute("ID") == null) {    
  105.                     element.detach();    
  106.                     i++;    
  107.                 } else {    
  108.                     if (StringUtils.isBlank(element.attribute("ID").getValue())) {                
  109.                             element.detach();    
  110.                             i++;    
  111.                      }   
  112.                 }    
  113.             }    
  114.             log.info("在" + xpath + "下成功删除" + i + "了个空节点!");    
  115.         }    
  116.         return srcDoc;    
  117.     }    
  118.   
  119.     /**   
  120.      * 删除xml文档中指定xpath路径下所有直接子节点为空的节点   
  121.      *   
  122.      * @param srcXml    原xml文档   
  123.      * @param xpathList xpaht列表   
  124.      * @return 删除空节点后的xml文档   
  125.      */    
  126.     public static String removeAllNullIdElement(String srcXml, ArrayList<String> xpathList) {    
  127.         String resultXml = null;    
  128.         try {    
  129.             Document srcDoc = DocumentHelper.parseText(srcXml);    
  130.             for (Iterator<String> it = xpathList.iterator(); it.hasNext();) {    
  131.                 String xpath = it.next();    
  132.                 removeNullIdElement(srcDoc, xpath);    
  133.             }    
  134.             resultXml = srcDoc.asXML();    
  135.         } catch (DocumentException e) {    
  136.             System.out.println(e.getMessage());    
  137.             e.printStackTrace();    
  138.         }    
  139.         return resultXml;    
  140.     }    
  141.   
  142.     /**   
  143.      * 更新xml文档中指定ID的元素,ID保持不变   
  144.      *   
  145.      * @param srcXml     原xml   
  146.      * @param newNodeXml 新xml节点   
  147.      * @param xmlNodeId  更新元素ID属性值   
  148.      * @return 更新元素后的xml文档   
  149.      */    
  150.     public static String updateElementById(String srcXml, String newNodeXml, String xmlNodeId) {    
  151.         String resultXml = null;    
  152.         try {    
  153.             Document docSrc = DocumentHelper.parseText(srcXml);    
  154.             Document newDocNode = DocumentHelper.parseText(newNodeXml);    
  155.             //获取要更新的目标节点    
  156.             Element updatedNode = docSrc.elementByID(xmlNodeId);    
  157.             //获取更新目标节点的父节点    
  158.             Element parentUpNode = updatedNode.getParent();    
  159.             //删除掉要更新的节点    
  160.             parentUpNode.remove(updatedNode);    
  161.   
  162.             //获取新节点的根节点（作为写入节点）    
  163.             Element newRoot = newDocNode.getRootElement();    
  164.             //处理新节点的ID属性值和BS子元素的值    
  165.             if (newRoot.attribute("ID") == null) {    
  166.                 newRoot.addAttribute("ID", xmlNodeId);    
  167.             } else {    
  168.                 newRoot.attribute("ID").setValue(xmlNodeId);    
  169.             }    
  170.             //在原文档中更新位置写入新节点    
  171.             parentUpNode.add(newRoot);    
  172.             resultXml = docSrc.asXML();    
  173.         } catch (DocumentException e) {    
  174.             log.error("更新xml文档中ID为" + xmlNodeId + "节点发生异常，请检查！");    
  175.             System.out.println(e.getMessage());    
  176.             e.printStackTrace();    
  177.         }    
  178.         return resultXml;    
  179.     }    
  180.   
  181.     /**   
  182.      * 更新xml文档中指定ID的元素,并检查ID和BS，加以设置   
  183.      *   
  184.      * @param srcXml     原xml   
  185.      * @param newNodeXml 新xml节点   
  186.      * @param xmlNodeId  更新元素ID属性值   
  187.      * @return 更新元素后的xml文档   
  188.      */    
  189.     public static String updateElementByIdAddIdBs(String srcXml, String newNodeXml, String xmlNodeId) {    
  190.         String resultXml = null;    
  191.         try {    
  192.             Document docSrc = DocumentHelper.parseText(srcXml);    
  193.             Document newDocNode = DocumentHelper.parseText(newNodeXml);    
  194.             //获取要更新的目标节点    
  195.             Element updatedNode = docSrc.elementByID(xmlNodeId);    
  196.             //获取更新目标节点的父节点    
  197.             Element parentUpNode = updatedNode.getParent();    
  198.             //删除掉要更新的节点    
  199.             parentUpNode.remove(updatedNode);    
  200.   
  201.             //获取新节点的根节点（作为写入节点）    
  202.             Element newRoot = newDocNode.getRootElement();    
  203.             //处理新节点的ID属性值和BS子元素的值    
  204.             if (newRoot.attribute("ID") == null) {    
  205.                 newRoot.addAttribute("ID", xmlNodeId);    
  206.             } else {    
  207.                 newRoot.attribute("ID").setValue(xmlNodeId);    
  208.             }    
  209.             if (newRoot.element("BS") == null) {    
  210.                 newRoot.addElement("BS", xmlNodeId);    
  211.             } else {    
  212.                 newRoot.element("BS").setText(xmlNodeId);    
  213.             }    
  214.             //在原文档中更新位置写入新节点    
  215.             parentUpNode.add(newRoot);    
  216.             resultXml = docSrc.asXML();    
  217.         } catch (DocumentException e) {    
  218.             log.error("更新xml文档中ID为" + xmlNodeId + "节点发生异常，请检查！");    
  219.             System.out.println(e.getMessage());    
  220.             e.printStackTrace();    
  221.         }    
  222.         return resultXml;    
  223.     }    
  224.   
  225.     /**   
  226.      * 为xml元素设置ID属性   
  227.      *   
  228.      * @param xmlElement 原xml元素   
  229.      * @return 设置id后的xml串   
  230.      */    
  231.     public static String addIdAttribute(String xmlElement) {    
  232.         String resultXml = null;    
  233.         try {    
  234.             Document srcDoc = DocumentHelper.parseText(xmlElement);    
  235.             Element root = srcDoc.getRootElement();    
  236. //            Long nextValue = SequenceUtils.getSequeceNextValue();    
  237.             Long nextValue = new Random().nextLong();    
  238.             root.addAttribute("ID", nextValue.toString());    
  239.             resultXml = root.asXML();    
  240.         } catch (DocumentException e) {    
  241.             log.error("给xml元素设置ID属性发生异常，请检查！");    
  242.             System.out.println(e.getMessage());    
  243.             e.printStackTrace();    
  244.         }    
  245.         return resultXml;    
  246.     }    
  247.   
  248.     /**   
  249.      * 为xml元素设置ID属性,并将此属性写入一个指定子节点文本值域   
  250.      *   
  251.      * @param xmlElement 原xml元素   
  252.      * @param nodeName   （直接）子节点的名称，或相对当前节点的xpath路径   
  253.      * @return 设置id和子节点后的xml串   
  254.      */    
  255.     public static String addIdAndWriteNode(String xmlElement, String nodeName) {    
  256.         String resultXml = null;    
  257.         try {    
  258.             Document srcDoc = DocumentHelper.parseText(xmlElement);    
  259.             Element root = srcDoc.getRootElement();    
  260. //            Long nextValue = SequenceUtils.getSequeceNextValue();    
  261.             Long nextValue = new Random().nextLong();    
  262.             root.addAttribute("ID", nextValue.toString());    
  263.             Node bsElement = root.selectSingleNode(nodeName);    
  264.             if (bsElement instanceof Element && bsElement != null) {    
  265.                 bsElement.setText(nextValue.toString());    
  266.             } else {    
  267.                 root.addElement(nodeName).setText(nextValue.toString());    
  268.             }    
  269.             resultXml = root.asXML();    
  270.         } catch (DocumentException e) {    
  271.             log.error("给xml元素设置ID属性和直接" + nodeName + "子元素值时发生异常，请检查！");    
  272.             System.out.println(e.getMessage());    
  273.             e.printStackTrace();    
  274.         }    
  275.         return resultXml;    
  276.     }    
  277.   
  278.   
  279.     public static void main(String args[]) {    
  280.         test();    
  281.     }    
  282.   
  283.     public static void test() {    
  284.         System.out.println("----------test()----------");    
  285.         String srcXml = "<?xml version=\"1.0\" encoding=\"GBK\"?>\n" +    
  286.                 "<doc>\n" +    
  287.                 "    <person>\n" +    
  288.                 "        <name>某人</name>\n" +    
  289.                 "        <adds>\n" +    
  290.                 "            <add ID=\"10001\">\n" +    
  291.                 "                <BS>10001</BS>\n" +    
  292.                 "                <note>郑州市经三路</note>\n" +    
  293.                 "            </add>\n" +    
  294.                 "            <add ID=\"10002\">\n" +    
  295.                 "                <BS>10002</BS>\n" +    
  296.                 "                <note>西安市太白路</note>\n" +    
  297.                 "            </add>\n" +    
  298.                 "            <add ID=\"\">\n" +    
  299.                 "                <BS>10002</BS>\n" +    
  300.                 "                <note>空ID节点啊</note>\n" +    
  301.                 "            </add>\n" +    
  302.                 "            <add>\n" +    
  303.                 "                <BS>10002</BS>\n" +    
  304.                 "                <note>空ID节点啊</note>\n" +    
  305.                 "            </add>\n" +    
  306.                 "        </adds>\n" +    
  307.                 "    </person>\n" +    
  308.                 "    <other>\n" +    
  309.                 "        <name ID=\"HEHE\">ASDF</name>\n" +    
  310.                 "        <name>空ID节点啊</name>\n" +    
  311.                 "        <name>空ID节点啊</name>\n" +    
  312.                 "    </other>\n" +    
  313.                 "</doc>";    
  314.         String nodeXml1 = "            <add >\n" +    
  315.                 "                <BS></BS>\n" +    
  316.                 "                <note>西安市太白路1</note>\n" +    
  317.                 "            </add>";    
  318.   
  319.         String nodeXml2 = "            <add>\n" +    
  320.                 "                <note>西安市太白路2</note>\n" +    
  321.                 "            </add>";    
  322.   
  323. //        System.out.println("输出三个测试对象");    
  324. //        System.out.println("----------srcXml------------");    
  325. //        System.out.println(srcXml);    
  326. //        System.out.println("----------nodeXml1------------");    
  327. //        System.out.println(srcXml);    
  328. //        System.out.println("----------nodeXml2------------");    
  329. //        System.out.println(srcXml);    
  330.   
  331.         System.out.println("----------addElement()测试----------");    
  332.         String addrs = addElement(srcXml, nodeXml1, "/doc/person/adds");    
  333.         System.out.println(addrs);    
  334.   
  335.         System.out.println("----------addIdAttribute()测试----------");    
  336.         String addIdrs = addIdAttribute(nodeXml1);    
  337.         System.out.println(addIdrs);    
  338.   
  339.         System.out.println("----------addIdAndWriteNode()测试----------");    
  340.         String addIdNoders = addIdAndWriteNode(nodeXml1, "BS");    
  341.         System.out.println(addIdNoders);    
  342.   
  343.         System.out.println("----------removeElementById()测试----------");    
  344.         String removeIdrs = removeElementById(srcXml, "10001");    
  345.         System.out.println(removeIdrs);    
  346.   
  347.         System.out.println("----------updateElementByIdAddIdBs()测试----------");    
  348.         String upbyidrs = updateElementByIdAddIdBs(srcXml, nodeXml2, "10001");    
  349.         System.out.println(upbyidrs);    
  350.   
  351.         System.out.println("----------updateElementById()测试----------");    
  352.         String upbyidrs1 = updateElementById(srcXml, nodeXml2, "10001");    
  353.         System.out.println(upbyidrs1);    
  354.   
  355.         System.out.println("----------removeNullIdElement()测试----------");    
  356.         String rvnullrs = removeNullIdElement(srcXml, "/doc/person/adds");    
  357.         System.out.println(rvnullrs);    
  358.   
  359.         System.out.println("----------removeAllNullIdElement()测试----------");    
  360.         ArrayList<String> xpathList = new ArrayList<String>();    
  361.         xpathList.add("/doc/person/adds");    
  362.         xpathList.add("/doc/other");    
  363.         String rvallnullrs = removeAllNullIdElement(srcXml, xpathList);    
  364.         System.out.println(rvallnullrs);    
  365.   
  366.         System.out.println("----------Dom4j生成一个xml测试----------");    
  367.         Document doc = DocumentHelper.createDocument();    
  368.         doc.addElement("root")    
  369.                 .addElement("person").setText("haha:)");    
  370.         System.out.println(doc.asXML());    
  371.     }    
  372. }  
package com.topsoft.icib.common.utils; 

import org.dom4j.*; 
import org.apache.commons.logging.Log; 
import org.apache.commons.logging.LogFactory; 
import org.apache.commons.lang.StringUtils; 

import java.util.Random; 
import java.util.Iterator; 
import java.util.ArrayList; 

/** 
* Created by IntelliJ IDEA.<br> 
* <b>User</b>: leizhimin<br> 
* <b>Date</b>: 2008-3-27 18:42:39<br> 
* <b>Note</b>: XML节点处理器，包含XML元素的CRUD方法。 
*/ 
public class XmlNodeHandler { 
    private static Log log = LogFactory.getLog(XmlNodeHandler.class); 

    /** 
     * 在xml的指定位置插入一个元素 
     * 
     * @param srcXml  原xml 
     * @param nodeXml 元素xml 
     * @param xpath   要插入元素父节点的位置 
     * @return 原xml插入节点后的完整xml文档 
     */ 
    public static String addElement(String srcXml, String nodeXml, String xpath) { 
        String resultXml = null; 
        try { 
            Document docSrc = DocumentHelper.parseText(srcXml); 
            Document docNode = DocumentHelper.parseText(nodeXml); 
            Element parentElement = (Element) docSrc.getRootElement().selectSingleNode(xpath); 
            parentElement.add(docNode.getRootElement()); 
            resultXml = docSrc.asXML(); 
        } catch (DocumentException e) { 
            log.error("在文档" + xpath + "位置添加新节点发生异常，请检查！"); 
            System.out.println(e.getMessage()); 
            e.printStackTrace(); 
        } 
        return resultXml; 
    } 

    /** 
     * 删除xml文档中指定ID的元素 
     * 
     * @param srcXml    原xml 
     * @param xmlNodeId 元素ID属性值 
     * @return 删除元素后的xml文档 
     */ 
    public static String removeElementById(String srcXml, String xmlNodeId) { 
        String resultXml = null; 
        try { 
            Document docSrc = DocumentHelper.parseText(srcXml); 
            Element removeElement = docSrc.getRootElement().elementByID(xmlNodeId); 
            removeElement.detach();  //直接删除自己 
//            removeElement.getParent().remove(removeElement);  //从父节点删除子节点 
            resultXml = docSrc.asXML(); 
        } catch (DocumentException e) { 
            log.error("删除文档中ID为" + xmlNodeId + "的节点发生异常，请检查！"); 
            System.out.println(e.getMessage()); 
            e.printStackTrace(); 
        } 
        return resultXml; 
    } 

    /** 
     * 删除xml文档中以xpath为直接父节点的ID属性为空的子节点，ID属性为空包括值为空、空串、或者ID属性不存在。 
     * 
     * @param srcXml 原xml文档 
     * @param xpath  要删除空节点的所在父节点的xpath 
     * @return 删除空节点后的xml文档 
     */ 
    public static String removeNullIdElement(String srcXml, String xpath) { 
        String resultXml = null; 
        try { 
            Document srcDoc = DocumentHelper.parseText(srcXml); 
            removeNullIdElement(srcDoc, xpath); 
            resultXml = srcDoc.asXML(); 
        } catch (DocumentException e) { 
            log.error("在" + xpath + "下删除空节点发生异常，请检查xpath是否正确！"); 
            System.out.println(e.getMessage()); 
            e.printStackTrace(); 
        } 
        return resultXml; 
    } 

    /** 
     * 删除xml文档中以xpath为直接父节点的ID属性为空的子节点，ID属性为空包括值为空、空串、或者ID属性不存在。 
     * 
     * @param srcDoc 原xml的Document对象 
     * @param xpath  要删除空节点的所在父节点的xpath 
     * @return 删除空节点后的xml文档 
     */ 
    public static Document removeNullIdElement(Document srcDoc, String xpath) { 
        Node parentNode = srcDoc.getRootElement().selectSingleNode(xpath); 
        if (!(parentNode instanceof Element)) { 
            log.error("所传入的xpath不是Elementpath，删除空节点失败！"); 
        } else { 
            int i = 0; 
            for (Iterator<Element> it = ((Element) parentNode).elementIterator(); it.hasNext();) { 
                Element element = it.next(); 
                if (element.attribute("ID") == null) { 
                    element.detach(); 
                    i++; 
                } else { 
                    if (StringUtils.isBlank(element.attribute("ID").getValue())) {             
                            element.detach(); 
                            i++; 
                     }
                } 
            } 
            log.info("在" + xpath + "下成功删除" + i + "了个空节点!"); 
        } 
        return srcDoc; 
    } 

    /** 
     * 删除xml文档中指定xpath路径下所有直接子节点为空的节点 
     * 
     * @param srcXml    原xml文档 
     * @param xpathList xpaht列表 
     * @return 删除空节点后的xml文档 
     */ 
    public static String removeAllNullIdElement(String srcXml, ArrayList<String> xpathList) { 
        String resultXml = null; 
        try { 
            Document srcDoc = DocumentHelper.parseText(srcXml); 
            for (Iterator<String> it = xpathList.iterator(); it.hasNext();) { 
                String xpath = it.next(); 
                removeNullIdElement(srcDoc, xpath); 
            } 
            resultXml = srcDoc.asXML(); 
        } catch (DocumentException e) { 
            System.out.println(e.getMessage()); 
            e.printStackTrace(); 
        } 
        return resultXml; 
    } 

    /** 
     * 更新xml文档中指定ID的元素,ID保持不变 
     * 
     * @param srcXml     原xml 
     * @param newNodeXml 新xml节点 
     * @param xmlNodeId  更新元素ID属性值 
     * @return 更新元素后的xml文档 
     */ 
    public static String updateElementById(String srcXml, String newNodeXml, String xmlNodeId) { 
        String resultXml = null; 
        try { 
            Document docSrc = DocumentHelper.parseText(srcXml); 
            Document newDocNode = DocumentHelper.parseText(newNodeXml); 
            //获取要更新的目标节点 
            Element updatedNode = docSrc.elementByID(xmlNodeId); 
            //获取更新目标节点的父节点 
            Element parentUpNode = updatedNode.getParent(); 
            //删除掉要更新的节点 
            parentUpNode.remove(updatedNode); 

            //获取新节点的根节点（作为写入节点） 
            Element newRoot = newDocNode.getRootElement(); 
            //处理新节点的ID属性值和BS子元素的值 
            if (newRoot.attribute("ID") == null) { 
                newRoot.addAttribute("ID", xmlNodeId); 
            } else { 
                newRoot.attribute("ID").setValue(xmlNodeId); 
            } 
            //在原文档中更新位置写入新节点 
            parentUpNode.add(newRoot); 
            resultXml = docSrc.asXML(); 
        } catch (DocumentException e) { 
            log.error("更新xml文档中ID为" + xmlNodeId + "节点发生异常，请检查！"); 
            System.out.println(e.getMessage()); 
            e.printStackTrace(); 
        } 
        return resultXml; 
    } 

    /** 
     * 更新xml文档中指定ID的元素,并检查ID和BS，加以设置 
     * 
     * @param srcXml     原xml 
     * @param newNodeXml 新xml节点 
     * @param xmlNodeId  更新元素ID属性值 
     * @return 更新元素后的xml文档 
     */ 
    public static String updateElementByIdAddIdBs(String srcXml, String newNodeXml, String xmlNodeId) { 
        String resultXml = null; 
        try { 
            Document docSrc = DocumentHelper.parseText(srcXml); 
            Document newDocNode = DocumentHelper.parseText(newNodeXml); 
            //获取要更新的目标节点 
            Element updatedNode = docSrc.elementByID(xmlNodeId); 
            //获取更新目标节点的父节点 
            Element parentUpNode = updatedNode.getParent(); 
            //删除掉要更新的节点 
            parentUpNode.remove(updatedNode); 

            //获取新节点的根节点（作为写入节点） 
            Element newRoot = newDocNode.getRootElement(); 
            //处理新节点的ID属性值和BS子元素的值 
            if (newRoot.attribute("ID") == null) { 
                newRoot.addAttribute("ID", xmlNodeId); 
            } else { 
                newRoot.attribute("ID").setValue(xmlNodeId); 
            } 
            if (newRoot.element("BS") == null) { 
                newRoot.addElement("BS", xmlNodeId); 
            } else { 
                newRoot.element("BS").setText(xmlNodeId); 
            } 
            //在原文档中更新位置写入新节点 
            parentUpNode.add(newRoot); 
            resultXml = docSrc.asXML(); 
        } catch (DocumentException e) { 
            log.error("更新xml文档中ID为" + xmlNodeId + "节点发生异常，请检查！"); 
            System.out.println(e.getMessage()); 
            e.printStackTrace(); 
        } 
        return resultXml; 
    } 

    /** 
     * 为xml元素设置ID属性 
     * 
     * @param xmlElement 原xml元素 
     * @return 设置id后的xml串 
     */ 
    public static String addIdAttribute(String xmlElement) { 
        String resultXml = null; 
        try { 
            Document srcDoc = DocumentHelper.parseText(xmlElement); 
            Element root = srcDoc.getRootElement(); 
//            Long nextValue = SequenceUtils.getSequeceNextValue(); 
            Long nextValue = new Random().nextLong(); 
            root.addAttribute("ID", nextValue.toString()); 
            resultXml = root.asXML(); 
        } catch (DocumentException e) { 
            log.error("给xml元素设置ID属性发生异常，请检查！"); 
            System.out.println(e.getMessage()); 
            e.printStackTrace(); 
        } 
        return resultXml; 
    } 

    /** 
     * 为xml元素设置ID属性,并将此属性写入一个指定子节点文本值域 
     * 
     * @param xmlElement 原xml元素 
     * @param nodeName   （直接）子节点的名称，或相对当前节点的xpath路径 
     * @return 设置id和子节点后的xml串 
     */ 
    public static String addIdAndWriteNode(String xmlElement, String nodeName) { 
        String resultXml = null; 
        try { 
            Document srcDoc = DocumentHelper.parseText(xmlElement); 
            Element root = srcDoc.getRootElement(); 
//            Long nextValue = SequenceUtils.getSequeceNextValue(); 
            Long nextValue = new Random().nextLong(); 
            root.addAttribute("ID", nextValue.toString()); 
            Node bsElement = root.selectSingleNode(nodeName); 
            if (bsElement instanceof Element && bsElement != null) { 
                bsElement.setText(nextValue.toString()); 
            } else { 
                root.addElement(nodeName).setText(nextValue.toString()); 
            } 
            resultXml = root.asXML(); 
        } catch (DocumentException e) { 
            log.error("给xml元素设置ID属性和直接" + nodeName + "子元素值时发生异常，请检查！"); 
            System.out.println(e.getMessage()); 
            e.printStackTrace(); 
        } 
        return resultXml; 
    } 


    public static void main(String args[]) { 
        test(); 
    } 

    public static void test() { 
        System.out.println("----------test()----------"); 
        String srcXml = "<?xml version=\"1.0\" encoding=\"GBK\"?>\n" + 
                "<doc>\n" + 
                "    <person>\n" + 
                "        <name>某人</name>\n" + 
                "        <adds>\n" + 
                "            <add ID=\"10001\">\n" + 
                "                <BS>10001</BS>\n" + 
                "                <note>郑州市经三路</note>\n" + 
                "            </add>\n" + 
                "            <add ID=\"10002\">\n" + 
                "                <BS>10002</BS>\n" + 
                "                <note>西安市太白路</note>\n" + 
                "            </add>\n" + 
                "            <add ID=\"\">\n" + 
                "                <BS>10002</BS>\n" + 
                "                <note>空ID节点啊</note>\n" + 
                "            </add>\n" + 
                "            <add>\n" + 
                "                <BS>10002</BS>\n" + 
                "                <note>空ID节点啊</note>\n" + 
                "            </add>\n" + 
                "        </adds>\n" + 
                "    </person>\n" + 
                "    <other>\n" + 
                "        <name ID=\"HEHE\">ASDF</name>\n" + 
                "        <name>空ID节点啊</name>\n" + 
                "        <name>空ID节点啊</name>\n" + 
                "    </other>\n" + 
                "</doc>"; 
        String nodeXml1 = "            <add >\n" + 
                "                <BS></BS>\n" + 
                "                <note>西安市太白路1</note>\n" + 
                "            </add>"; 

        String nodeXml2 = "            <add>\n" + 
                "                <note>西安市太白路2</note>\n" + 
                "            </add>"; 

//        System.out.println("输出三个测试对象"); 
//        System.out.println("----------srcXml------------"); 
//        System.out.println(srcXml); 
//        System.out.println("----------nodeXml1------------"); 
//        System.out.println(srcXml); 
//        System.out.println("----------nodeXml2------------"); 
//        System.out.println(srcXml); 

        System.out.println("----------addElement()测试----------"); 
        String addrs = addElement(srcXml, nodeXml1, "/doc/person/adds"); 
        System.out.println(addrs); 

        System.out.println("----------addIdAttribute()测试----------"); 
        String addIdrs = addIdAttribute(nodeXml1); 
        System.out.println(addIdrs); 

        System.out.println("----------addIdAndWriteNode()测试----------"); 
        String addIdNoders = addIdAndWriteNode(nodeXml1, "BS"); 
        System.out.println(addIdNoders); 

        System.out.println("----------removeElementById()测试----------"); 
        String removeIdrs = removeElementById(srcXml, "10001"); 
        System.out.println(removeIdrs); 

        System.out.println("----------updateElementByIdAddIdBs()测试----------"); 
        String upbyidrs = updateElementByIdAddIdBs(srcXml, nodeXml2, "10001"); 
        System.out.println(upbyidrs); 

        System.out.println("----------updateElementById()测试----------"); 
        String upbyidrs1 = updateElementById(srcXml, nodeXml2, "10001"); 
        System.out.println(upbyidrs1); 

        System.out.println("----------removeNullIdElement()测试----------"); 
        String rvnullrs = removeNullIdElement(srcXml, "/doc/person/adds"); 
        System.out.println(rvnullrs); 

        System.out.println("----------removeAllNullIdElement()测试----------"); 
        ArrayList<String> xpathList = new ArrayList<String>(); 
        xpathList.add("/doc/person/adds"); 
        xpathList.add("/doc/other"); 
        String rvallnullrs = removeAllNullIdElement(srcXml, xpathList); 
        System.out.println(rvallnullrs); 

        System.out.println("----------Dom4j生成一个xml测试----------"); 
        Document doc = DocumentHelper.createDocument(); 
        doc.addElement("root") 
                .addElement("person").setText("haha:)"); 
        System.out.println(doc.asXML()); 
    } 
}
 程序中尽量避免用Dom4j之外的第三方类库，但是还用到了，可以修改一下：
1、用到Log4j的地方，可以修改log对象的实现为Java中的Logger工具：
      private static Logger log = Logger.getLogger(XmlNodeHandler.class.getName());

2、用到apache的beanutils工具包中的StringUtils.isBlank()方法时候，可以改用JDK API String中的equel()方法做比较进行替换。具体操作很简单，我就不写了。

3、用到Sequence生成的Id的地方，我都改为java.util.Random类来实现，目的还是为了把眼光放到Dom的处理上。如果有博友对这个SequenceUtils工具类有兴趣，我可以把代码贴出去。

本处理器工具类涵盖Dom4j最常用部分80％以上的API。放到以方便查看。
分享到：
| Dom4j的使用(全而好的文章)
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    dom4j-1.6.1 与 dom4j-2.0.0-ALPHA

    4. 可扩展性：DOM4J允许用户自定义解析策略和处理器，以满足特定需求。 5. 支持XML Schema和DTD：能够验证XML文档是否符合预定义的模式或规范。 接下来，DOM4J 2.0.0-ALPHA是后续的一个实验性版本，引入了一些新...

    DOM4J 的使用

    * NodeFilter：定义了在 dom4j 节点中产生的一个滤镜或谓词的行为。 * ProcessingInstruction：定义 XML 处理指令。 * Text：定义 XML 文本节点。 * Visitor：用于实现 Visitor 模式。 * XPath：在分析一个字符串后...

    dom4j-2.1.3.zip

    《DOM4J：Java中的XML处理利器》 在Java编程中，XML（eXtensible Markup Language）作为一种数据交换和存储格式，广泛应用...通过深入理解和熟练运用DOM4J，开发者可以更好地驾驭XML世界，实现数据的灵活处理和传输。

    dom4j需要的包

    Jaxen提供了一种统一的API，支持多种XML处理器，包括DOM4J。 2. `dom4j-1.6.1.jar`：这是DOM4J的主要库文件，包含了处理XML的所有功能。这个版本1.6.1是DOM4J的一个稳定版本，提供了许多特性，如读写XML文件、构建...

    DOM4J帮助文档及使用教程

    8. **事件处理**：如果需要在解析或操作XML时执行某些动作，可以注册监听器或处理器，DOM4J提供了相应的API。 9. **高级功能**：包括命名空间管理、DTD处理、实体引用、XML Schema支持等进阶话题。 10. **性能优化...

    dom4j解析xml详解

    16. **Visitor**: 实现了访问者模式，允许对DOM4J树进行深度遍历，并在每个节点上执行特定的操作。 17. **XPath**: 提供了XPath表达式的查询能力，使得在复杂的数据结构中定位和提取数据变得更加容易。 #### 三、...

    Dom4j使用简介.pdf

    #### 四、Dom4j 的接口继承关系 为了更好地理解 Dom4j 的工作原理，我们需要了解它的接口继承关系。以下是部分关键接口的继承关系示意图： - `java.lang.Cloneable` → `org.dom4j.Node` - `org.dom4j.Attribute`...

    dom4j-2.1.0.jar dom4j-2.1.0-javadoc.jar

    2. **XPath支持**：DOM4J实现了XPath语言，允许开发者通过简洁的表达式来查询XML文档中的节点，大大简化了对XML数据的查找和操作。 3. **Element和Attribute对象**：DOM4J提供了Element和Attribute类，它们封装了...

    dom4j简单技术

    3. **面向接口编程**：DOM4J遵循“面向接口编程”的原则，通过提供一系列接口而非具体实现类，增强了代码的可维护性和重用性。 4. **集成多种XML标准**：DOM4J同时支持DOM、SAX和JAXP，这意味着开发者可以根据实际...

    dom4j中文api

    - **Document对象**：代表整个XML文档，是DOM4J的根节点。 - **Element对象**：表示XML文档中的元素，可以包含属性、文本和子元素。 - **Attribute对象**：用于存储元素的属性。 - **Text对象**：表示元素中的...

    dom4j-1.6.1

    4. **事件驱动编程**：DOM4J支持事件驱动的XML解析，可以注册事件处理器来响应XML解析过程中的特定事件，如元素开始、结束、文本节点发现等。 5. **文档操作**：DOM4J提供了创建、修改和删除XML文档节点的功能，...

    dom4j文档.xml

    13. **NodeFilter**: 定义节点过滤器，用于在DOM4J节点上应用条件筛选。 14. **ProcessingInstruction**: 定义XML处理指令，用于给处理器传递指令。 15. **Text**: 表示XML文本节点，包含纯文本内容。 16. **Visitor...

    DOM4J_xpath

    13. **NodeFilter**: 定义在DOM4J节点中产生的一个过滤器或谓词的行为。 14. **ProcessingInstruction**: 定义XML处理指令。 15. **Text**: 定义XML文本节点。 16. **Visitor**: 用于实现访问者模式。 17. **XPath**...

    dom4j下sax解析xml

    在dom4j库中，SAX解析器实现了SAX2接口，提供了一种高效且节省内存的方式解析XML。以下是使用dom4j进行SAX解析的基本步骤： 1. **引入依赖**：在项目中添加dom4j库，通常通过Maven或Gradle构建工具添加对应的依赖。...

    dom4j基础入门文档（SAX,DOM,XPATH）

    13. `org.dom4j.ProcessingInstruction`: 定义XML处理指令，用于指导处理器如何处理文档的某些部分。 14. `org.dom4j.Text`: 代表XML的文本节点。 15. `org.dom4j.Visitor`: 实现Visitor模式，允许对XML树进行深度...

    DOM4j属性的详细介绍及相关的例子

    10. **Node**：`Node`是DOM4j中所有XML节点的基类，提供了统一的访问和操作方法，包括元素、属性、文本、注释等。 11. **NodeFilter**：`NodeFilter`定义了一个过滤器接口，允许你在遍历DOM4j树时根据特定条件筛选...

    dom4j源代码

    8. **事件处理**：DOM4J允许注册事件处理器，可以监听XML解析过程中的特定事件，如开始解析、遇到元素、结束解析等。 9. **性能优化**：DOM4J在设计时考虑了性能，例如通过延迟加载（lazy loading）减少内存占用，...

Magicbox
Global site tag (gtag.js) - Google Analytics