精华内容
下载资源
问答
  • 鉴于目前的趋势,我们这里来讲讲Dom4j的基本用法,不涉及递归等复杂操作。Dom4j的用法很多,官网上的示例有那么点儿晦涩,这里就不写了
  • dom4j解析xml嵌套格式

    2019-08-06 01:09:05
    NULL 博文链接:https://nbh219.iteye.com/blog/2075553
  • 使用dom4j解析XML

    2020-03-04 11:34:15
    dom4j是一种解析XML文档的开放源代码XML框架。本文介绍如何使用包含在dom4j中的解析器创建并修改XML文档。dom4j API包含一个解析XML文档的工具。本文中将使用这个解析器创建一个示例XML文档,然后使用同一个解析器...
  • dom4j解析xml文件的压缩包,完整版。对jdom进行了封装。包含源码,jar包以及所需的全部内容。
  • dom4j API下载包括用于解析XML文档的工具。 在本文中,将使用解析器创建示例XML文档。 清单1显示了示例XML文档catalog.xml。 清单1.示例XML文档(catalog.xml) <?xml version="1.0" encoding="UTF-8"?> &...

    使用dom4j解析xml

    dom4j API下载包括用于解析XML文档的工具。 在本文中,将使用解析器创建示例XML文档。 清单1显示了示例XML文档catalog.xml。

    清单1.示例XML文档(catalog.xml)
    <?xml version="1.0" encoding="UTF-8"?> 
    <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>

    使用解析器修改catalog.xml。 清单2显示了修改后的XML文档catalog-modified.xml。

    清单2.修改后的XML文档(catalog-modified.xml)
    <?xml version="1.0" encoding="UTF-8"?> 
    <catalog> 
    <!--An XML catalog--> 
    <?target instruction?>
      <journal title="XML Zone"
                       publisher="IBM developerWorks"> 
    
    <article level="Introductory" date="October-2002">
     <title>Create flexible and extensible XML schemas</title> 
     <author> 
         <firstname>Ayesha</firstname> 
         <lastname>Malik</lastname> 
     </author> 
      </article>
      </journal> 
    </catalog>

    与W3C DOM API相比,使用dom4j随附的解析器的优势在于dom4j具有本机XPath支持。 DOM解析器不支持XPath选择节点。

    本文分为以下几节:

    • 初步设置
    • 建立文件
    • 修改文件

    初步设置

    可以从http://dom4j.org获得此解析器。 使dom4j-1.4/dom4j-full.jar在类路径中可用; 它包含dom4j类,XPath引擎以及SAX和DOM的接口。 如果正在使用JAXP解析器中包含的SAX和DOM接口,则将dom4j-1.4/dom4j.jar添加到类路径中。 dom4j.jar包含dom4j类和XPath引擎,但不包含SAX和DOM接口。

    建立文件

    在本节中,我将讨论使用dom4j API创建XML文档的过程。 将创建示例XML文档catalog.xml。

    使用import语句导入dom4j API类:

    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;

    使用DocumentHelper类创建一个文档实例。 DocumentHelper是一个dom4j API工厂,用于生成XML文档节点。

    Document document = DocumentHelper.createDocument();

    使用addElement()方法创建根元素catalogaddElement()用于将元素添加到XML文档。

    Element catalogElement = document.addElement("catalog");

    使用addComment()方法创建注释“ An XML catalog”并将其添加到catalog元素。

    catalogElement.addComment("An XML catalog");

    使用addProcessingInstruction()方法将处理指令添加到catalog元素。

    catalogElement.addProcessingInstruction("target","text");

    使用addElement()方法将journal元素添加到catalog元素。

    Element journalElement =  catalogElement.addElement("journal");

    使用addAttribute()方法将titlepublisher属性添加到journal元素。

    journalElement.addAttribute("title", "XML Zone");
             journalElement.addAttribute("publisher", "IBM developerWorks");

    article元素添加到journal元素。

    Element articleElement=journalElement.addElement("article");

    leveldate属性添加到article元素。

    articleElement.addAttribute("level", "Intermediate");
          articleElement.addAttribute("date", "December-2001");

    title元素添加到article元素。

    Element titleElement=articleElement.addElement("title");

    使用setText()方法设置article元素的文本。

    titleElement.setText("Java configuration with XML Schema");

    author元素添加到article元素。

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

    将一个firstname元素添加到author元素,并设置firstname元素的文本。

    Element  firstNameElement=authorElement.addElement("firstname");
         firstNameElement.setText("Marcello");

    将一个lastname元素添加到author元素,并设置lastname元素的文本。

    Element lastNameElement=authorElement.addElement("lastname");
         lastNameElement.setText("Vitaletti");

    可以使用addDocType()方法将文档类型语句添加到文档中。

    document.addDocType("catalog", null,"file://c:/Dtds/catalog.dtd");

    将文档类型语句添加到XML文档:

    <!DOCTYPE catalog SYSTEM "file://c:/Dtds/catalog.dtd">

    如果要使用文档类型定义(DTD)文档对文档进行验证,则需要Doctype。

    默认情况下,将XML声明<?xml version="1.0" encoding="UTF-8"?>添加到XML文档中。

    清单3显示了示例程序XmlDom4J.java,该程序用于创建XML文档catalog.xml。

    清单3.生成XML文档catalog.xml(XmlDom4J.java)的程序
    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    import org.dom4j.io.XMLWriter;
    import java.io.*;
    
    
    
    public class XmlDom4J{
    
    
    public void generateDocument(){
    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");
        try{
        XMLWriter output = new XMLWriter(
                new FileWriter( new File("c:/catalog/catalog.xml") ));
            output.write( document );
            output.close();
            }
         catch(IOException e){System.out.println(e.getMessage());}
    }
    
    public static void main(String[] argv){
    XmlDom4J dom4j=new XmlDom4J();
    dom4j.generateDocument();
    }}

    本节讨论了创建XML文档的过程。 在下一节中,您将看到如何使用dom4j API修改在本节中创建的XML文档catalog.xml。

    修改文件

    在本节中,我将向您展示如何使用dom4j API修改示例XML文档catalog.xml。

    使用SAXReader解析XML文档catalog.xml:

    SAXReader saxReader = new SAXReader();
     Document document = saxReader.read(inputXml);

    SAXReader包含在org.dom4j.io软件包中。

    inputXml是从c:/catalog/catalog.xml创建的java.io.File。 使用XPath表达式获取article元素中的level节点列表。 如果level属性值为“中级”,则将其修改为“简介”。

    List list = document.selectNodes("//article/@level" );
          Iterator iter=list.iterator();
            while(iter.hasNext()){
                Attribute attribute=(Attribute)iter.next();
                   if(attribute.getValue().equals("Intermediate"))
                   attribute.setValue("Introductory"); 
           }

    获取article元素列表。 获取article元素中title元素的迭代器,并修改title元素的文本。

    list = document.selectNodes("//article" );
         iter=list.iterator();
       while(iter.hasNext()){
           Element element=(Element)iter.next();
          Iterator iterator=element.elementIterator("title");
       while(iterator.hasNext()){
       Element titleElement=(Element)iterator.next();
       if(titleElement.getText().equals("Java configuration with XML Schema"))
         titleElement.setText("Create flexible and extensible XML schema");
    
        }}

    使用类似于title元素的过程来修改author元素。

    清单4显示了示例程序Dom4JParser.java,该程序用于将catalog.xml文档修改为catalog-modified.xml文档。

    清单4.用于修改catalog.xml的程序(Dom4Jparser.java)
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.Attribute;
    import java.util.List;
    import java.util.Iterator;
    import org.dom4j.io.XMLWriter;
    import java.io.*;
    import org.dom4j.DocumentException;
    import org.dom4j.io.SAXReader; 
    
    public class Dom4JParser{
    
     public void modifyDocument(File inputXml){
    
      try{
       SAXReader saxReader = new SAXReader();
       Document document = saxReader.read(inputXml);
    
       List list = document.selectNodes("//article/@level" );
       Iterator iter=list.iterator();
       while(iter.hasNext()){
        Attribute attribute=(Attribute)iter.next();
        if(attribute.getValue().equals("Intermediate"))
          attribute.setValue("Introductory"); 
    
           }
       
       list = document.selectNodes("//article/@date" );
       iter=list.iterator();
       while(iter.hasNext()){
        Attribute attribute=(Attribute)iter.next();
        if(attribute.getValue().equals("December-2001"))
          attribute.setValue("October-2002");
    
           }
    
       list = document.selectNodes("//article" );
       iter=list.iterator();
       while(iter.hasNext()){
        Element element=(Element)iter.next();
        Iterator iterator=element.elementIterator("title");
          while(iterator.hasNext()){
            Element titleElement=(Element)iterator.next();
            if(titleElement.getText().equals("Java configuration with XML
    
          Schema"))
            titleElement.setText("Create flexible and extensible XML schema");
    
                                              }
    
                                    }
    
        list = document.selectNodes("//article/author" );
        iter=list.iterator();
         while(iter.hasNext()){
         Element element=(Element)iter.next();
         Iterator iterator=element.elementIterator("firstname");
         while(iterator.hasNext()){
          Element firstNameElement=(Element)iterator.next();
          if(firstNameElement.getText().equals("Marcello"))
          firstNameElement.setText("Ayesha");
                                         }
    
                                  }
    
        list = document.selectNodes("//article/author" );
        iter=list.iterator();
         while(iter.hasNext()){
          Element element=(Element)iter.next();
          Iterator iterator=element.elementIterator("lastname");
         while(iterator.hasNext()){
          Element lastNameElement=(Element)iterator.next();
          if(lastNameElement.getText().equals("Vitaletti"))
          lastNameElement.setText("Malik");
    
                                      }
    
                                   }
         XMLWriter output = new XMLWriter(
          new FileWriter( new File("c:/catalog/catalog-modified.xml") ));
         output.write( document );
         output.close();
       }
     
      catch(DocumentException e)
                     {
                      System.out.println(e.getMessage());
                                }
    
      catch(IOException e){
                           System.out.println(e.getMessage());
                        }
     }
    
     public static void main(String[] argv){
    
      Dom4JParser dom4jParser=new Dom4JParser();
      dom4jParser.modifyDocument(new File("c:/catalog/catalog.xml"));
    
                                            }
    
       }

    本节向您展示了如何使用dom4j附带的解析器修改示例XML文档。 该解析器不使用DTD或模式来验证XML文档。 如果需要验证XML文档,请将dom4j与JAXP SAX解析器集成。

    结论

    dom4j附带的解析器是一种非验证工具,用于解析XML文档。 它可以与JAXP,Crimson或Xerces解析器集成。 本文向您展示了如何使用此解析器创建和修改XML文档。


    翻译自: https://www.ibm.com/developerworks/xml/library/x-dom4j/index.html

    使用dom4j解析xml

    展开全文
  • 本文主要介绍了java使用dom4j读取配置文件实现抽象工厂和反射的示例,在Java中也可以同Donet一样,将差异配置在配置文件里面。另外,我们采用下面的方式实现,将会更加便捷
  • XPath是一门在XML文档中查找信息的语言,下面介绍一下java使用xpath和dom4j解析xml的示例,大家参考使用
  • 使用DOM4J解析XML的大致步骤 1:创建SAXReader 2:使用SAXReader读取XML文档并生成Document对象 Document对象内部就保存了XML文档描述的整棵树结构 3:通过Document获取根元素 4:从根元素开始逐级获取子元素已达到遍历...

    使用DOM4J解析XML的大致步骤
    1:创建SAXReader
    2:使用SAXReader读取XML文档并生成Document对象
    Document对象内部就保存了XML文档描述的整棵树结构
    3:通过Document对象获取根元素
    4:从根元素开始逐级获取子元素已达到遍历XML文档的目的

    Element的每一个实例用于表示XML文档中的一个元素(一对标签)
    常用的方法:
    String getName() 获取标签名
    String getText() 获取标签中间的文本数据
    Element element(String name) 获取指定名字的子标签
    List elements() 获取所有子标签,集合中为若干Element实例
    List elements(String name) 获取所有同名子标签(指定的名字)

    标签上的属性:attributeValue(String str)<===>attribute(String str).getValue(String value);

    String elementText(String name) 获取指定名字的子标签的中间的文本
    例如:
    e.elementText(“abc”);
    等同于
    e.element(“abc”).getText();

    package xml;
    
            import org.dom4j.Attribute;
            import org.dom4j.Document;
            import org.dom4j.Element;
            import org.dom4j.io.SAXReader;
    
            import java.util.List;
    
    /**
     * 解析xml文档
     *
     * 解析XML有两种常见的方式
     * 1:SAX解析:Simple API for Xml
     *   逐行扫描解析,速度块,内存消耗小,但是不能对XML文档进行修改。
     *
     * 2:DOM解析:Document Object Model
     *   DOM是w3c推荐的解析方式,称为文档对象模型
     *   DOM解析其内部会将XML文档先读取完毕后内建整个树状模型,然后让我们解析
     *   时通过遍历树状结构来达到解析目的。
     *
     *
     *   dom4j(dom for java)是java中常见的以DOM形式解析XML文档的API。
     */
    public class ParseXmlDemo {
        public static void main(String[] args) {
            /*
                使用DOM4J解析XML的大致步骤
                1:创建SAXReader
                2:使用SAXReader读取XML文档并生成Document对象
                  Document对象内部就保存了XML文档描述的整棵树结构
                3:通过Document获取根元素
                4:从根元素开始逐级获取子元素已达到遍历XML文档的目的
             */
            try{
                //1:创建SAXReader
                SAXReader reader = new SAXReader();
                //2:读取XML文档并生成Document
                Document doc = reader.read("./emplist.xml");
                /*
                    3:通过Document获取根元素(XML的根标签)
                    Element的每一个实例用于表示XML文档中的一个元素(一对标签)
                    常用的方法:
                    String getName()    获取标签名
                    String getText()    获取标签中间的文本数据
                    Element element(String name)    获取指定名字的子标签
                    List elements()     获取所有子标签,集合中为若干Element实例
                    List elements(String name)      获取所有同名子标签(指定的名字)
    
                    String elementText(String name) 获取指定名字的子标签的中间的文本
                    例如:
                    e.elementText("abc");
                    等同于
                    e.element("abc").getText();
                 */
                Element root = doc.getRootElement();
                System.out.println(root.getName());//list
                //获取每个员工信息(通过根标签获取所有<emp>子标签)
                List<Element> list = root.elements("emp");//获取根标签"emp"下的所有子标签
                System.out.println(list.size());
                //遍历子标签
                for(Element empEle:list){
                    //获取员工名字
    //                Element nameEle = empEle.element("name");//获取emp中的子标签<name>
    //                String name = nameEle.getText();//获取name标签中的文本信息
                    String name = empEle.elementText("name");
    
                    //获取员工年龄
    //                Element ageEle = empEle.element("age");
    //                int age = Integer.parseInt(ageEle.getText());
                    int age = Integer.parseInt(empEle.elementText("age"));
    
                    //获取员工性别
    //                Element genderEle = empEle.element("gender");
    //                String gender = genderEle.getText();
                    String gender = empEle.elementText("gender");
    
                    //获取员工工资
    //                Element salaryEle = empEle.element("salary");
    //                int salary = Integer.parseInt(salaryEle.getText());
                    int salary = Integer.parseInt(empEle.elementText("salary"));
    
    //                获取员工工号
    //                Attribute attr = empEle.attribute("id");
    //                int id = Integer.parseInt(attr.getValue());
    
    //                int id = Integer.parseInt(empEle.attribute("id").getValue());
    
                    int id = Integer.parseInt(empEle.attributeValue("id"));
    
                    System.out.println("name:"+name+","+"工号:"+id+","+"年龄:"+age+","+"sex:"+gender+","+"薪资:"+salary);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }
    

    输出结果:

    在这里插入图片描述

    展开全文
  • 在最近的开发中用到了dom4j来解析xml文件,所以便有了这篇文章,本文主要给大家介绍了关于java中使用dom4j解析XML文件的方法教程,文中通过示例代码介绍的非常详细,需要的朋友可以参考下
  • 本篇文章主要是对通过dom4j解析xml字符串的示例代码进行了介绍,需要的朋友可以过来参考下,希望对大家有所帮助
  • 一、解析xml文件的方法   xml文件说白了就是一个有规则的记事本文件(万物皆可文本),它里面有成对的标签,通常我们解析一个记事本时,就是直接读取,其实针对xml也可以直接读取,但是太麻烦了,为啥不针对它自身的...

    一、解析xml文件的方法

      xml文件说白了就是一个有规则的记事本文件(万物皆可文本),它里面有成对的标签,通常我们解析一个记事本时,就是直接读取,其实针对xml也可以直接读取,但是太麻烦了,为啥不针对它自身的一些性质,再集成一些处理方法呢,所以我们前人就创造了好多技术。
      大概有两种思路,一是基于树结构处理的Dom解析,另外一种是基于事件模型的SAX解析。树结构Dom解析我理解就是,“不管你解不解析,我都要把整篇按层次加载好”;事件模型就是“你提出问题,我根据你的问题从头去找答案,找到就停止”。显然,这两个思路的优缺点一目了然。下面就这两个思路讲几种方法:

    1. DOM(Document Object Model)
      DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构,然后才能做任何工作。

    • 优点
      ①允许应用程序对数据和结构做出更改。
      ②访问是双向的,可以在任何时候在树中上下导航,获取和操作任意部分的数据。
    • 缺点
      ①通常需要加载整个XML文档来构造层次结构,消耗资源大。

    2. SAX(Simple API for XML)
       SAX处理的优点非常类似于流媒体的优点。分析能够立即开始,而不是等待所有的数据被处理。而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。一般来说,SAX还比它的替代者DOM快许多。

       DOM解析器把XML文档转化为一个包含其内容的树,并可以对树进行遍历。用DOM解析模型的优点是编程容易,开发人员只需要调用建树的指令,然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档,所以对性能和内存的要求比较高,尤其是遇到很大的XML文件的时候。由于它的遍历能力,DOM解析器常用于XML文档需要频繁的改变的服务中。
       SAX解析器采用了基于事件的模型,它在解析XML文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低,因为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时,SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难,而且很难同时访问同一个文档中的多处不同数据。

    • 优势
      ①不需要等待所有数据都被处理,分析就能立即开始。
      ②只在读取数据时检查数据,不需要保存在内存中。
      ③可以在某个条件得到满足时停止解析,不必解析整个文档。
      ④效率和性能较高,能解析大于系统内存的文档。

    • 缺点
      ①需要应用程序自己负责TAG的处理逻辑(例如维护父/子关系等),文档越复杂程序就越复杂。
      ②单向导航,无法定位文档层次,很难同时访问同一文档的不同部分数据,不支持XPath。

    3. JDOM(Java-based Document Object Model)
        JDOM的目的是成为Java特定文档模型,它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型,JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。
        JDOM与DOM主要有两方面不同。首先,JDOM仅使用具体类而不使用接口。这在某些方面简化了API,但是也限制了灵活性。第二,API大量使用了Collections类,简化了那些已经熟悉这些类的Java开发者的使用。
        JDOM文档声明其目的是“使用20%(或更少)的精力解决80%(或更多)Java/XML问题”(根据学习曲线假定为20%)。JDOM对于大多数Java/XML应用程序来说当然是有用的,并且大多数开发者发现API比DOM容易理解得多。JDOM还包括对程序行为的相当广泛检查以防止用户做任何在XML中无意义的事。然而,它仍需要您充分理解XML以便做一些超出基本的工作(或者甚至理解某些情况下的错误)。这也许是比学习DOM或JDOM接口都更有意义的工作。
        JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档(尽管它还可以将以前构造的DOM表示作为输入)。它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。

    • 优点
      ①使用具体类而不是接口,简化了DOM的API。
      ②大量使用了Java集合类,方便了Java开发人员。

    • 缺点
      ①没有较好的灵活性。
      ②性能较差。

    4. DOM4J(Document Object Model for Java)
      虽然DOM4J代表了完全独立的开发结果,但最初,它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能,包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项,它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始,它就一直处于开发之中。
      为支持所有这些功能,DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类,但是在许多情况下,它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是,虽然DOM4J付出了更复杂的API的代价,但是它提供了比JDOM大得多的灵活性。
      在添加灵活性、XPath集成和对大文档处理的目标时,DOM4J的目标与JDOM是一样的:针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案,实现在本质上处理所有Java/XML问题的目标。在完成该目标时,它比JDOM更少强调防止不正确的应用程序行为。
      DOM4J是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML,特别值得一提的是连Sun的JAXM也在用DOM4J.

    【优点】
    ①大量使用了Java集合类,方便Java开发人员,同时提供一些提高性能的替代方法。
    ②支持XPath。
    ③有很好的性能。

    【缺点】
    ①大量使用了接口,API较为复杂。

    **总结:**以上四种方法,从程序员的角度来说,其实就是从繁到简。解决一个问题,一般最一开始方法很粗暴,只要解决问题就行了,后来又发现这个方法有些复杂,就进行优化;或者从另一个角度,有更加简单的方法,这就出来分支了。随着技术不断的发展、人们的探索,解决问题的方法肯定越来越简单,但是,往往距离它的底层也越来越远,那是因为前人不断的对方法进行封装,使它越来越接近人们的大脑思考方式。程序员就是物与人交流的桥梁。其实对于一般的技术人员来说,没必要也不可能对每种技术的底层了解,有时候,往往只要知道如何使用它解决你的问题即可,好了,又说了一堆大道理。
      所以,日常中使用的就是dom4j技术了,下面写个demo。

    二、使用Dom4j解析xml

    需要下载dom4j.jar包
    基本步骤:

    1. 创建SAXReader,用来读取XML文件2文件
    2. 指定xml文件使得SAXReader读取,并解析成文档对象Document
    3. 获取根元素对象(Element)
    4. 通过Element的一些方法,获取标签名、标签属性、标签内容。
      “一般使用迭代器或者for循环进行层层遍历”

    要解析的xml文件:demo.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <companys name="com">
        <company1 id="1001">
            <name>万科A</name>
            <address>广东深圳</address>
        </company1>
        <company2 id="1002">
            <name>恒大B</name>
            <address>广东广州</address>
        </company2>
        <company3 id="1003">
            <name>金地C</name>
            <address>北京</address>
        </company3>
        <company4 id="1006">
            <name>绿地D</name>
            <address>上海</address>
        </company4>
    </companys>
    

    解析demo.xml的java代码:

    import java.io.File;
    import java.util.Iterator;
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.SAXReader;
    
    public class AnalysisDemo {
    	public static void main(String args[]) {
    		try {
    //			创建SAXReader对象来读取xml
    			 SAXReader reader = new SAXReader();
    			 File xmlFile = new File("E:\\demo.xml");
    			 Document doc = reader.read(xmlFile);
    //			 得到根标签
    			 Element root = doc.getRootElement();
    //			 使用迭代方法遍历当前元素的子元素,创建子元素迭代器。当
    			 Iterator<Element> it = root.elementIterator(/*里面也可以设置字符串,迭代特定名称的元素*/);
    			 while(it.hasNext()) {
    				 Element em = it.next();
    				 System.out.println("标签名:"+em.getName()+";标签的内容:"+em.getText());
    			 }
    //			 迭代遍历当前标签对象的属性
    			 for(Iterator<Attribute> itt = root.attributeIterator(); itt.hasNext();) {
    				 Attribute ab = itt.next();
    				 System.out.println("属性名:"+ab.getName()+";属性值:"+ab.getStringValue());
    			 }
    			 
    //			 上面是使用迭代器遍历,其实也可以使用for循环遍历,
    //			 Element对象调用elements()方法可以返回子元素集合
    			 
    	} catch(Exception e) {
    		e.printStackTrace();
    	}
    }	
    }
    

      使用基本的dom4j可以实现xml的解析,但是比较麻烦,它一开始是从根节点开始一层一层的递进深入。下面介绍基于dom4j的Xpath,他可以直接定位到你想到的位置。
    需要导入javen.jar,还有它所依赖的jar包。

    import java.io.File;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.Node;
    import org.dom4j.io.SAXReader;
    
    public class AnalysisDemo {
    	public static void main(String args[]) {
    		try {
    //			创建SAXReader对象来读取xml
    			 SAXReader reader = new SAXReader();
    			 File xmlFile = new File("E:\\demo.xml");
    			 Document doc = reader.read(xmlFile);
    //			 得到根标签
    			 Element root = doc.getRootElement();
    			 Node node1 = root.selectSingleNode("./company1");
    			 System.out.println("id属性的属性值:"+node1.valueOf("@id"));
    			 Node node2 = root.selectSingleNode("./company1/name");
    			 System.out.println("标签名:"+node2.getName()+";标签内容:"+node2.getText());
    			 
    	} catch(Exception e) {
    		e.printStackTrace();
    	}
    }	
    }
    
    

      Xpath的优点是可以迅速定位到一个位置,不像之前那个,得一层一层遍历。还有一个就是,这里有个Node类,我刚开始用的时候有点迷糊,如何使用Element和Node呢?可以看下面此文章:https://blog.csdn.net/qq_36923376/article/details/97265090
      差不多吧,处理xml无非就是取标签名、标签属性、标签属性值、标签内容这些。模式方法其实很固定,使用时还是Xpath简单些。下面稍微看下如何写一个xml文件。

    三、写入xml文件

    基本步骤:

    1. 首先建立一个Document对象
    2. 使用Document创建一个根节点对象(Element)
    3. 调用addElement(String em)添加子元素并返回这个Element,谁调用就在谁的下面创建标签;调用addText(String content)添加标签内容;调用addAttribute(String name,String value)添加属性和属性值,一层一层逐个添加。
      “如果标签里面没有内容,自动闭合,就是单独的标签”

    代码示例:

    import java.io.FileWriter;
    import java.io.IOException;
    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.XMLWriter;
    
    public class AnalysisDemo {
    	public static void main(String args[]) {
    //		创建Document对象
    		Document document = DocumentHelper.createDocument();
    //		建立一个根节点
    		Element root = document.addElement("html");
    		root.addAttribute("country", "China");
    		Element head = root.addElement("head");
    		Element body = root.addElement("body");
    		body.addText("Hello!");
    		try {
    //			1.定义一种美化的格式,自动缩进换行等
    			OutputFormat format = OutputFormat.createPrettyPrint();
    //			2.使用XMLWriter创建xml文件
    			XMLWriter writer = new XMLWriter(new FileWriter("E:\\2.xml"),format);
    //			3.将document写入
    			writer.write(document);
    			writer.flush();
    			writer.close();
    		}catch(IOException e) {
    			
    		}
    	}	
    }
    

    生成xml:
    在这里插入图片描述

    展开全文
  • java dom4j解析xml

    2017-08-18 15:40:13
    java dom4j解析xml (详细注释)
  • 使用dom4jxml文件中的数据导入到数据库中,包含xml文件和连接数据库文件,能够运行。 (1)用eclipse创建一个简单的java project (2)导入所需要的包 (3)编写DBUtil.java 连接数据库 (4)编写xml文件 ...
  • dom4j解析xml和soap报文

    2017-09-14 17:48:27
    通过dom4j解析xml文件或xml字符串,同时利用dom4j解析soap报文,解析出所需要的字段,使用的相对比较基础,有需要的可以参考一下。
  • 使用dom4j高效率xml解析,内涵demo程序,idea导入即可运行,适用于各种复杂xml解析,给自己留作备份,有需要可下载。
  • DOM4J具有性能优异、功能强大和极端易用使用的特点,只要懂得DOM基本概念,就可以通过dom4j的api文档来解析xml,dom4j是一套开源的api。实际项目中,往往选择dom4j来作为解析xml的利器
  • NULL 博文链接:https://yangyongbyjava.iteye.com/blog/2068636
  • 使用Dom4j解析XML

    万次阅读 多人点赞 2013-10-23 12:06:26
    dom4j是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件,可以在SourceForge上找到它.  对主流的Java XML API进行的性能、功能和易用性的评测,dom4...

           dom4j是一个Java的XML API,类似于jdom,用来读写XML文件的。dom4j是一个非常非常优秀的Java XML API,具有性能优异、功能强大和极端易用使用的特点,同时它也是一个开放源代码的软件,可以在SourceForge上找到它.

           对主流的Java XML API进行的性能、功能和易用性的评测,dom4j无论在那个方面都是非常出色的。如今你可以看到越来越多的Java软件都在使用dom4j来读写XML,例如Hibernate,包括sun公司自己的JAXM也用了Dom4j。

           使用Dom4j开发,需下载dom4j相应的jar文件

            1.官网下载: http://www.dom4j.org/dom4j-1.6.1/

             2.dom4j是sourceforge.net上的一个开源项目,因此可以到http://sourceforge.net/projects/dom4j下载其最新版.

             对于下载的zip文件进行解压后的效果如下:

            

     打开dom4j-1.6.1的解压文件


    在这里可以看到有docs帮助的文件夹,也有需要使用dom4j解析xml文件的dom4j-1.6.1.jar文件.我们只需要把dom4j-1.6.1.jar文件构建到我们开发的项目中就可以使用dom4j开发了.

    下面我以Myeclipse创建Java项目的构建方法为例说明.

    首先创建一个demo项目,在demo项目中创建一个lib文件,把dom4j-1.6.1.jar文件拷贝到lib中,然后右键dom4j-1.6.1jar文件

       

    点击Add to Build Path即可构建到项目中去了.

    备注:如果进行的是web项目开发,我们只需要把它拷贝到web-inf/lib中去即可,会自动构建到web项目中.


    在项目开发的过程中可以参考docs文件夹的(帮助文档),找到index.html打开,点击Quick start可以通过帮助文档进行学习 dom4j进行xml的解析.


        下面我对我认为api中重要的方法进行翻译说明如下:

    一、DOM4j中,获得Document对象的方式有三种:

    	1.读取XML文件,获得document对象            
                       SAXReader reader = new SAXReader();              
    		   Document   document = reader.read(new File("csdn.xml"));
    	2.解析XML形式的文本,得到document对象.
                       String text = "<csdn></csdn>";            
                       Document document = DocumentHelper.parseText(text);
    	3.主动创建document对象.
                      Document document = DocumentHelper.createDocument();             //创建根节点
                      Element root = document.addElement("csdn");

    二、节点对象操作的方法

    1.获取文档的根节点.
          Element root = document.getRootElement();
        2.取得某个节点的子节点.
          Element element=node.element(“四大名著");
        3.取得节点的文字
            String text=node.getText();
        4.取得某节点下所有名为“csdn”的子节点,并进行遍历.
           List nodes = rootElm.elements("csdn"); 
             for (Iterator it = nodes.iterator(); it.hasNext();) {   
    	  Element elm = (Element) it.next();  
      	// do something
     }
         5.对某节点下的所有子节点进行遍历.    
          for(Iterator it=root.elementIterator();it.hasNext();){      
            Element element = (Element) it.next();      
           // do something 
     }
        6.在某节点下添加子节点
          Element elm = newElm.addElement("朝代");
        7.设置节点文字.  elm.setText("明朝");
        8.删除某节点.//childElement是待删除的节点,parentElement是其父节点  parentElement.remove(childElment);
        9.添加一个CDATA节点.Element contentElm = infoElm.addElement("content");contentElm.addCDATA(“cdata区域”);

    三、节点对象的属性方法操作

    1.取得某节点下的某属性    Element root=document.getRootElement();        //属性名name
             Attribute attribute=root.attribute("id");
        2.取得属性的文字
    	String text=attribute.getText();
        3.删除某属性 Attribute attribute=root.attribute("size"); root.remove(attribute);
        4.遍历某节点的所有属性   
          Element root=document.getRootElement();      
           for(Iterator it=root.attributeIterator();it.hasNext();){        
               Attribute attribute = (Attribute) it.next();         
               String text=attribute.getText();        
               System.out.println(text);  
      }
        5.设置某节点的属性和文字.   newMemberElm.addAttribute("name", "sitinspring");
        6.设置属性的文字   Attribute attribute=root.attribute("name");   attribute.setText("csdn");

    四、将文档写入XML文件

    1.文档中全为英文,不设置编码,直接写入的形式.  
           XMLWriter writer = new XMLWriter(new  FileWriter("ot.xml")); 
           writer.write(document);  
           writer.close();
        2.文档中含有中文,设置编码格式写入的形式.
           OutputFormat format = OutputFormat.createPrettyPrint();// 创建文件输出的时候,自动缩进的格式                  
           format.setEncoding("UTF-8");//设置编码
           XMLWriter writer = new XMLWriter(newFileWriter("output.xml"),format);
           writer.write(document);
           writer.close();

    五、字符串与XML的转换

    1.将字符串转化为XML
          String text = "<csdn> <java>Java班</java></csdn>";
          Document document = DocumentHelper.parseText(text);
        2.将文档或节点的XML转化为字符串.
           SAXReader reader = new SAXReader();
           Document   document = reader.read(new File("csdn.xml"));            
           Element root=document.getRootElement();    
           String docXmlText=document.asXML();
           String rootXmlText=root.asXML();
           Element memberElm=root.element("csdn");
           String memberXmlText=memberElm.asXML();
    六、案例(解析sida.xml文件并对其进行curd的操作)

    1.sida.xml描述四大名著的操作,文件内容如下

    <?xml version="1.0" encoding="UTF-8"?>
    <四大名著>
    	<西游记 id="x001">
    		<作者>吴承恩1</作者>
    		<作者>吴承恩2</作者>
    		<朝代>明朝</朝代>
    	</西游记>
    	<红楼梦 id="x002">
    		<作者>曹雪芹</作者>
    	</红楼梦>
    </四大名著>
    2.解析类测试操作

    package dom4j;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.FileWriter;
    import java.io.OutputStreamWriter;
    import java.nio.charset.Charset;
    import java.nio.charset.CharsetEncoder;
    import java.util.Iterator;
    import java.util.List;
    
    import org.dom4j.Attribute;
    import org.dom4j.Document;
    import org.dom4j.Element;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.SAXReader;
    import org.dom4j.io.XMLWriter;
    import org.junit.Test;
    
    public class Demo01 {
    
    	@Test
    	public void test() throws Exception {
    
    		// 创建saxReader对象
    		SAXReader reader = new SAXReader();
    		// 通过read方法读取一个文件 转换成Document对象
    		Document document = reader.read(new File("src/dom4j/sida.xml"));
    		//获取根节点元素对象
    		Element node = document.getRootElement();
    		//遍历所有的元素节点
    		listNodes(node);
    
    		// 获取四大名著元素节点中,子节点名称为红楼梦元素节点。
    		Element element = node.element("红楼梦");
    		//获取element的id属性节点对象
    		Attribute attr = element.attribute("id");
    		//删除属性
    		element.remove(attr);
    		//添加新的属性
    		element.addAttribute("name", "作者");
    		// 在红楼梦元素节点中添加朝代元素的节点
    		Element newElement = element.addElement("朝代");
    		newElement.setText("清朝");
    		//获取element中的作者元素节点对象
    		Element author = element.element("作者");
    		//删除元素节点
    		boolean flag = element.remove(author);
    		//返回true代码删除成功,否则失败
    		System.out.println(flag);
    		//添加CDATA区域
    		element.addCDATA("红楼梦,是一部爱情小说.");
    		// 写入到一个新的文件中
    		writer(document);
    
    	}
    
    	/**
    	 * 把document对象写入新的文件
    	 * 
    	 * @param document
    	 * @throws Exception
    	 */
    	public void writer(Document document) throws Exception {
    		// 紧凑的格式
    		// OutputFormat format = OutputFormat.createCompactFormat();
    		// 排版缩进的格式
    		OutputFormat format = OutputFormat.createPrettyPrint();
    		// 设置编码
    		format.setEncoding("UTF-8");
    		// 创建XMLWriter对象,指定了写出文件及编码格式
    		// XMLWriter writer = new XMLWriter(new FileWriter(new
    		// File("src//a.xml")),format);
    		XMLWriter writer = new XMLWriter(new OutputStreamWriter(
    				new FileOutputStream(new File("src//a.xml")), "UTF-8"), format);
    		// 写入
    		writer.write(document);
    		// 立即写入
    		writer.flush();
    		// 关闭操作
    		writer.close();
    	}
    
    	/**
    	 * 遍历当前节点元素下面的所有(元素的)子节点
    	 * 
    	 * @param node
    	 */
    	public void listNodes(Element node) {
    		System.out.println("当前节点的名称::" + node.getName());
    		// 获取当前节点的所有属性节点
    		List<Attribute> list = node.attributes();
    		// 遍历属性节点
    		for (Attribute attr : list) {
    			System.out.println(attr.getText() + "-----" + attr.getName()
    					+ "---" + attr.getValue());
    		}
    
    		if (!(node.getTextTrim().equals(""))) {
    			System.out.println("文本内容::::" + node.getText());
    		}
    
    		// 当前节点下面子节点迭代器
    		Iterator<Element> it = node.elementIterator();
    		// 遍历
    		while (it.hasNext()) {
    			// 获取某个子节点对象
    			Element e = it.next();
    			// 对子节点进行遍历
    			listNodes(e);
    		}
    	}
    
    	/**
    	 * 介绍Element中的element方法和elements方法的使用
    	 * 
    	 * @param node
    	 */
    	public void elementMethod(Element node) {
    		// 获取node节点中,子节点的元素名称为西游记的元素节点。
    		Element e = node.element("西游记");
    		// 获取西游记元素节点中,子节点为作者的元素节点(可以看到只能获取第一个作者元素节点)
    		Element author = e.element("作者");
    
    		System.out.println(e.getName() + "----" + author.getText());
    
    		// 获取西游记这个元素节点 中,所有子节点名称为作者元素的节点 。
    
    		List<Element> authors = e.elements("作者");
    		for (Element aut : authors) {
    			System.out.println(aut.getText());
    		}
    
    		// 获取西游记这个元素节点 所有元素的子节点。
    		List<Element> elements = e.elements();
    
    		for (Element el : elements) {
    			System.out.println(el.getText());
    		}
    
    	}
    
    }
    自己适当注释部分代码观察运行效果,反复练习,希望你对dom4j有进一步的了解.


    七、字符串与XML互转换案例

    package dom4j;
    
    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.OutputStreamWriter;
    
    import org.dom4j.Document;
    import org.dom4j.DocumentHelper;
    import org.dom4j.Element;
    import org.dom4j.io.OutputFormat;
    import org.dom4j.io.SAXReader;
    import org.dom4j.io.XMLWriter;
    import org.junit.Test;
    
    public class Demo02 {
    
    	@Test
    	public void test() throws Exception {
    
    		// 创建saxreader对象
    		SAXReader reader = new SAXReader();
    		// 读取一个文件,把这个文件转换成Document对象
    		Document document = reader.read(new File("src//c.xml"));
    		// 获取根元素
    		Element root = document.getRootElement();
    		// 把文档转换字符串
    		String docXmlText = document.asXML();
    		System.out.println(docXmlText);
    		System.out.println("---------------------------");
    		// csdn元素标签根转换的内容
    		String rootXmlText = root.asXML();
    		System.out.println(rootXmlText);
    		System.out.println("---------------------------");
    		// 获取java元素标签 内的内容
    		Element e = root.element("java");
    		System.out.println(e.asXML());
    
    	}
    
    	/**
    	 * 创建一个document对象 往document对象中添加节点元素 转存为xml文件
    	 * 
    	 * @throws Exception
    	 */
    	public void test2() throws Exception {
    
    		Document document = DocumentHelper.createDocument();// 创建根节点
    		Element root = document.addElement("csdn");
    		Element java = root.addElement("java");
    		java.setText("java班");
    		Element ios = root.addElement("ios");
    		ios.setText("ios班");
    
    		writer(document);
    	}
    
    	/**
    	 * 把一个文本字符串转换Document对象
    	 * 
    	 * @throws Exception
    	 */
    	public void test1() throws Exception {
    		String text = "<csdn><java>Java班</java><net>Net班</net></csdn>";
    		Document document = DocumentHelper.parseText(text);
    		Element e = document.getRootElement();
    		System.out.println(e.getName());
    		writer(document);
    	}
    
    	/**
    	 * 把document对象写入新的文件
    	 * 
    	 * @param document
    	 * @throws Exception
    	 */
    	public void writer(Document document) throws Exception {
    		// 紧凑的格式
    		// OutputFormat format = OutputFormat.createCompactFormat();
    		// 排版缩进的格式
    		OutputFormat format = OutputFormat.createPrettyPrint();
    		// 设置编码
    		format.setEncoding("UTF-8");
    		// 创建XMLWriter对象,指定了写出文件及编码格式
    		// XMLWriter writer = new XMLWriter(new FileWriter(new
    		// File("src//a.xml")),format);
    		XMLWriter writer = new XMLWriter(new OutputStreamWriter(
    				new FileOutputStream(new File("src//c.xml")), "UTF-8"), format);
    		// 写入
    		writer.write(document);
    		// 立即写入
    		writer.flush();
    		// 关闭操作
    		writer.close();
    	}
    }

    展开全文
  • 使用dom4j解析xml文件,并转出json格式 我这边的需要就是讲xml格式的soap的响应报文解析出来并返回给前端 首先要准备的依赖 <!--dom4j--> <dependency> <groupId>dom4j</groupId> <...
  • 怎么使用new SAXReader().setEntityResolver()方法去除xml检验? 求具体的代码块?
  • JAVA 使用Dom4j 解析XML

    万次阅读 多人点赞 2014-08-03 18:01:48
    解析XML的方式有很多,本文介绍使用dom4j解析xml文件
  • 本篇文章主要介绍了java中利用Dom4j解析和生成XML文档,dom4j是一套非常优秀的Java开源api,主要用于读写xml文档,具有性能优异、功能强大、和非常方便使用的特点。有兴趣的可以了解一下。
  • dom4j解析XML所需jar包

    2017-10-13 16:33:03
    dom4j解析XML必备jardom4j解析XML必备jardom4j解析XML必备jardom4j解析XML必备jar
  • 使用DOM4J解析XML文件

    2018-04-27 15:31:30
    简介XML可扩展标记语言,是一种数据交换格式,与操作系统和编程语言的开发平台无关,实现不同系统之间的数据交换。...XML种解析方式:DOM解析,SAX解析,JDOM解析,DOM4J解析。今天我们简单的来了解一下DOM...
  • idea中使用dom4j解析XML

    千次阅读 2019-02-25 09:16:34
    java中使用dom4j解析XML 其实在java中解析XML文件的方式有很多,我这里示例就用第三方插件dom4j解析 我使用的IDE是idea 使用dom4j解析XML 1.先去这个地址去下载jar包  https://dom4j.github.io/ 2.在idea中...
  • -- org.dom4j --> <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> </dependency> 二、SAXReader类说明 实现对xml文件的...
  • 使用 dom4j 解析 XML

    2013-05-29 20:33:09
    使用 dom4j 解析 XML;很不错的中文文档
  • java基础-使用dom4j解析XML文件

    千次阅读 2018-01-03 20:37:30
    解析XML 解析过程  /* * 解析XML文件的基本流程 * 1:创建SAXReader,用来读取XML * 文件 * 2:指定xml文件使得SAXReader读取, * 并解析问文档对象Document * 3:获取根元素 * 4:获取每一个元素,从而达到...
  • 前言  本章讲解Dom4J解析XML的基本流程 方法 1.概念 之前我们所学习的STAX的解析方式是使用原生JDK进行的解析,那么你发现还是可以...2.使用Dom4J解析XML 1)引入第三方的jar包 2) 编写代码解析XML pac...
  • 转载:Java使用dom4j解析XML

    千次阅读 2015-12-05 16:05:48
    解析XML的方式有很多,本文介绍使用dom4j解析xml。 1、环境准备 (1)下载dom4j-1.6.1.jar (2)下载junit-4.10.jar 2、温馨提示 解析XML过程是通过获取Document对象,然后继续获取各个节点以及属性等操作,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 49,594
精华内容 19,837
关键字:

使用dom4j解析xml