Dom4j节点处理器实现

最新推荐文章于 2023-09-20 08:59:47 发布
最新推荐文章于 2023-09-20 08:59:47 发布
阅读量86 收藏
点赞数
分类专栏： XML 文章标签： XML Apache log4j JDK IDEA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gaojie1190/article/details/83455603
版权
      Dom4j为XML文档解析提供了强大的API支持，在实际开发中，为了处理方便，常常以节点元素（Element）为单位进行处理，并且结合数据库和Java技术，为节点生成ID属性。这样，就很有必要在Dom4j的基础上，重新封装一些适用需要的方法，以提高开发效率。下面是我利用业余时间做的一个Dom4j节点处理器工具类的实现。希望能节省开发人员宝贵时间。

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

注释很详细，不用废话了。下面是处理器的实现： 
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。放到以方便查看。
gaojie1190
关注
专栏目录
Dom4j 解析大容量xml（ElementHandler使用）
糖糖糖糖糖糖分
04-10 3661
参考了这篇https://blog.csdn.net/mark_lq/article/details/45040731dom4j本身提供了两种解析xml的方式:dom解析和sax解析。关于dom解析和sax解析各自的优缺点这里不再多述，只强调的一点是由于越来越多的应用会遇到大数据场景，SAX解析方式刚好是解决此类场景的完美方案，因此“DOM4J解析大数据的方案”就是"如何利用SAX方式解析大数据的...
DOM4J_ElementHandler
rongrong_love_lc的专栏
06-08 1619
DOM4J解析XML利用ElementHandler接口。重写onStart()和onEnd()两个方法。 注意：要读取元素节点的内容，必须在onEnd()方法中，因为onStart()只解析到开始节点。 1、解析： `SAXReader saxReader = new SAXReader(); //addHandler必须在read之前，否则无效。 saxReader.addHand
Dom4j节点处理器的实现
Java-Jinguo
07-12 123
Dom4j节点处理器的实现 Dom4j为XML文档解析提供了强大的API支持，在实际开发中，为了处理方便，常常以节点元素（Element）为单位进行处理，并且结合数据库和Java技术，为节点生成ID属性。这样，就很有必要在Dom4j的基础上，重新封装一些适用需要的方法，以提高开发效率。下面是我利用业余时间做的一个Dom4j节点处理器工具类的实现。希望能节省开发人员宝贵时间。 说明：...
DOM4J解析xml
06-04
该文档是关于DOM4J如何使用的，需要使用dom4j解析xml的人有福了，里面的信息很详细！
手把手教您Dom4j的使用
欢迎朋友，我是一名十多年开发经验的新手，希望多多指教。
09-20 444
DOM4J使用起来非常简单。只要你了解基本的XML-DOM模型，就能使用。然而他自己带的指南只有短短一页（html），不过说的到挺全。国内的中文资料很少。因而俺写这个短小的教程方便大家使用。
dom4j-2.1.3.zip
07-10
《DOM4J：Java中的XML处理利器》 在Java编程中，XML（eXtensible Markup Language）作为一种数据交换和存储格式，广泛应用...通过深入理解和熟练运用DOM4J，开发者可以更好地驾驭XML世界，实现数据的灵活处理和传输。
dom4j.zip压缩包
08-30
DOM4J支持SAX事件处理，允许在解析XML时触发自定义的事件处理器。这在处理大量数据时非常有用，可以及时处理数据而无需等待整个文档解析完成。 6. **与JAXB和JDOM的比较** DOM4J相较于JAXB（Java Architecture ...
dom4j-dom4j_1_6_1.tar.gz
最新发布
04-20
4. **全面支持 XPath**：DOM4J 集成了 XPath 表达式引擎，可以直接通过 XPath 查询 XML 文档中的节点，大大简化了数据查找和操作。 5. **支持 SAX 和 DOM**：DOM4J 不仅支持基于事件的 SAX 解析，还支持传统的 DOM ...
dom4j需要的包
03-10
Jaxen提供了一种统一的API，支持多种XML处理器，包括DOM4J。 2. `dom4j-1.6.1.jar`：这是DOM4J的主要库文件，包含了处理XML的所有功能。这个版本1.6.1是DOM4J的一个稳定版本，提供了许多特性，如读写XML文件、构建...
dom4j-API.zip_DOM4J
09-14
- DOM4J提供了基于SAX的事件处理器，可以监听XML解析过程中的事件，如开始元素、结束元素、字符数据等。 9. **转换（Transformation）** - 通过`Transformer`类，DOM4J支持将XML文档转换为其他格式，如XSLT转换，...
dom4j基于事件流解析大XML的文件 示例
08-12
解决普通方法解析大xml的文件时，内存严重不足。
java+基于dom4j工具类_xml工具类-dom4j方式
weixin_42202078的博客
02-27 212
jar包下载地址：http://pan.baidu.com/s/1dD0DgTr?errno=0&errmsg=Auth%20Login%20Sucess&stoken=17b2287b172e1e1b350fa068bc320ec708a9b3e894e7296250f1b89e819f421907a081eb3ec99a1ccc44ab7fc81ff120cdd4851c745...
SAX 解析大型XML文件
eyes1842的专栏
08-04 497
最近在项目中需要把一些系统配置表导到XML文件中，一开始觉得数据量不大，使用dom4j就可以了，后来才发现数据量超出预期的大小，程序很快就内存溢出了。SAX在顺序遍历XML所有节点时，还是有很大的优势的。下面是我写的SAX解析XML的代码，解析大型XML文件来说性能比较好。 DefaultElementHandler.java   import org.dom4j.Document; im...
获取指定元素的父节点getParent
wangjingyi
03-31 2121
获取元素的父节点 [code="js"]function getParent(element){ element = document.getElementById(id); //浏览器兼容性：parentElement ---ie parentNode --ff return element.parentElement || ...
ElementPath
07-22 1041
package org.dom4j; public abstract interface ElementPath {  public abstract int size();  public abstract Element getElement(int paramInt);  public abstract String getPath();  public abstract Elem
java中dom4j解析xml文件怎么获取节点属性
热门推荐
幻梦星空的小窝的博客
12-06 1万+
java中dom4j解析xml文件怎么获取节点属性 2010-6-9 10:15 dom4j中，使用Element.attributes方法可以获取到节点的属性，而使用elements则可以获取相应的子节点 比如： Element root = doc.getRootElement(); List attrList = root.attributes(); for (int i =
dom4j的Element
xclsky的博客
12-18 5918
1,Element其中的一个Element为dom4j,创建Element，通过DocumentHelper.createElement（name） 如：Element result=DocumentHelper.createElement("result"); 2,设置Element的text内容，通过result.setText(value)； 如：a.setText("这里"); 3
dom4j详解与使用指南
12. `org.dom4j.NodeFilter`: `NodeFilter`接口定义了一个过滤器，用于在遍历DOM4J节点时进行筛选。 13. `org.dom4j.ProcessingInstruction`: `ProcessingInstruction`接口定义了XML处理指令，用于向处理器传递特定...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值