java使用dom4j解析xml

最新推荐文章于 2023-07-13 17:16:02 发布
最新推荐文章于 2023-07-13 17:16:02 发布
阅读量833 收藏 1
点赞数
分类专栏： java 文章标签： java dom4j

XML解析技术有两种 DOM SAX

  • DOM方式 
    根据XML的层级结构在内存中分配一个树形结构,把XML的标签,属性和文本等元素都封装成树的节点对象 
    • 优点: 便于实现增 删 改 查
    • 缺点: XML文件过大可能造成内存溢出
  • SAX方式 
    采用事件驱动模型边读边解析:从上到下一行行解析,解析到某一元素, 调用相应解析方法 
    • 优点: 不会造成内存溢出,
    • 缺点: 查询不方便,但不能实现 增 删 改

不同的公司和组织提供了针对DOM和SAX两种方式的解析器


一.前言

Dom4j是JDom的一种智能分支,从原先的JDom组织中分离出来,提供了比JDom功能更加强大,性能更加卓越的Dom4j解析器(比如提供对XPath支持).

二.代码详情

  dom4j是一个第三方开发组开发出的插件，所以在我们使用dom4jf的时候我们要去下载一下dom4j对应版本的jar导入在我们项目中。

 1)xml文件:

<?xml version="1.0" encoding="UTF-8"?> 
<books> 
  <book id="001"> 
      <title>Harry Potter</title> 
      <author>J K. Rowling</author> 
  </book> 
  <book id="002"> 
      <title>Learning XML</title> 
      <author>Erik T. Ray</author> 
  </book> 
</books>

示例一：用List列表的方式来解析xml

SAXReader就是一个管道，用一个流的方式，把xml文件读出来

import java.io.File;
import java.util.List;  
import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;  
public class Demo {  
    public static void main(String[] args) throws Exception {
        SAXReader reader = new SAXReader();
        File file = new File("books.xml");
        Document document = reader.read(file);
        Element root = document.getRootElement();
        List<Element> childElements = root.elements();
        for (Element child : childElements) {
            //未知属性名情况下获取属性的内容。attr.getName()获取标签名，attr.getValue()获取属性值
            /*List<Attribute> attributeList = child.attributes();
            for (Attribute attr : attributeList) {
//        	// 字符串转XML
//        	String xmlStr = "......";
//        	Document document = DocumentHelper.parseText(xmlStr);
//        	// XML转字符串 
//        	Document document = ...;
//        	String text = document.asXML();
                System.out.println(attr.getName() + ": " + attr.getValue());
            }*/              
            //已知属性名情况下
            System.out.println("id: " + child.attributeValue("id"));              
            //未知子元素名情况下获取元素的内容
            /*List<Element> elementList = child.elements();
            for (Element ele : elementList) {
                System.out.println(ele.getName() + ": " + ele.getText());
            }
            System.out.println();*/              
            //已知子元素名的情况下，elementText("title")根据标签名获取值
            System.out.println("title" + child.elementText("title"));


示例XML如下,下面我们会使用Dom4j对他进行增 删 改 查操作:

  • config.xml
<?xml version="1.0" encoding="utf-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns="http://www.fq.me/context"
       xsi:schemaLocation="http://www.fq.me/context http://www.fq.me/context/context.xsd">
    <bean id="id1" class="com.fq.benz">
        <property name="name" value="benz"/>
    </bean>
    <bean id="id2" class="com.fq.domain.Bean">
        <property name="isUsed" value="true"/>
        <property name="complexBean" ref="id1"/>
    </bean>
</beans>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • context.xsd
<?xml version="1.0" encoding="utf-8"?>
<schema xmlns="http://www.w3.org/2001/XMLSchema"
        targetNamespace="http://www.fq.me/context"
        elementFormDefault="qualified">
    <element name="beans">
        <complexType>
            <sequence>
                <element name="bean" maxOccurs="unbounded">
                    <complexType>
                        <sequence>
                            <element name="property" maxOccurs="unbounded">
                                <complexType>
                                    <attribute name="name" type="string" use="required"/>
                                    <attribute name="value" type="string" use="optional"/>
                                    <attribute name="ref" type="string" use="optional"/>
                                </complexType>
                            </element>
                        </sequence>
                        <attribute name="id" type="string" use="required"/>
                        <attribute name="class" type="string" use="required"/>
                    </complexType>
                </element>
            </sequence>
        </complexType>
    </element>
</schema>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
/**
 * @author jifang
 * @since 16/1/18下午4:02.
 */
public class Dom4jRead {

    @Test
    public void client() throws DocumentException {
        SAXReader reader = new SAXReader();
        Document document = reader.read(ClassLoader.getSystemResource("config.xml"));
        // ...
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

与JAXP类似Document也是一个接口(org.dom4j包下),其父接口是Node, Node的子接口还有Element Attribute Document Text CDATA Branch等

  • Node
Node常用方法 释义
Element getParent() getParent returns the parent Element if this node supports the parent relationship or null if it is the root element or does not support the parent relationship.
  • Document
Document常用方法 释义
Element getRootElement() Returns the root Elementfor this document.
  • Element
Element常用方法 释义
void add(Attribute/Text param) Adds the given Attribute/Text to this element.
Element addAttribute(String name, String value) Adds the attribute value of the given local name.
Attribute attribute(int index) Returns the attribute at the specified indexGets the
Attribute attribute(String name) Returns the attribute with the given name
Element element(String name) Returns the first element for the given local name and any namespace.
Iterator elementIterator() Returns an iterator over all this elements child elements.
Iterator elementIterator(String name) Returns an iterator over the elements contained in this element which match the given local name and any namespace.
List elements() Returns the elements contained in this element.
List elements(String name) Returns the elements contained in this element with the given local name and any namespace.
  • Branch
Branch常用方法 释义
Element addElement(String name) Adds a new Element node with the given name to this branch and returns a reference to the new node.
boolean remove(Node node) Removes the given Node if the node is an immediate child of this branch.
Dom4j查询
  • 打印所有属性信息:
/**
 * @author jifang
 * @since 16/1/18下午4:02.
 */
public class Dom4jRead {

    private Document document;

    @Before
    public void setUp() throws DocumentException {
        document = new SAXReader()
                .read(ClassLoader.getSystemResource("config.xml"));
    }

    @Test
    @SuppressWarnings("unchecked")
    public void client() {
        Element beans = document.getRootElement();

        for (Iterator iterator = beans.elementIterator(); iterator.hasNext(); ) {
            Element bean = (Element) iterator.next();
            String id = bean.attributeValue("id");
            String clazz = bean.attributeValue("class");
            System.out.println("id: " + id + ", class: " + clazz);

            scanProperties(bean.elements());
        }
    }

    public void scanProperties(List<? extends Element> properties) {
        for (Element property : properties) {
            System.out.print("name: " + property.attributeValue("name"));
            Attribute value = property.attribute("value");
            if (value != null) {
                System.out.println("," + value.getName() + ": " + value.getValue());
            }
            Attribute ref = property.attribute("ref");
            if (ref != null) {
                System.out.println("," + ref.getName() + ": " + ref.getValue());
            }
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
Dom4j添加节点

在第一个<bean/>标签末尾添加<property/>标签

<bean id="id1" class="com.fq.benz"> 
    <property name="name" value="benz"/>  
    <property name="refBean" ref="id2">新添加的标签</property>
</bean>  
 
 
  • 1
  • 2
  • 3
  • 4

 
 
  • 1
  • 2
  • 3
  • 4
/**
 * @author jifang
 * @since 16/1/19上午9:50.
 */
public class Dom4jAppend {

    //...

    @Test
    public void client() {
        Element beans = document.getRootElement();
        Element firstBean = beans.element("bean");
        Element property = firstBean.addElement("property");
        property.addAttribute("name", "refBean");
        property.addAttribute("ref", "id2");
        property.setText("新添加的标签");
    }

    @After
    public void tearDown() throws IOException {
        // 回写XML
        OutputFormat format = OutputFormat.createPrettyPrint();
        XMLWriter writer = new XMLWriter(new FileOutputStream("src/main/resources/config.xml"), format);
        writer.write(document);
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26

我们可以将获取读写XML操作封装成一个工具, 以后调用时会方便些:

/**
 * @author jifang
 * @since 16/1/19下午2:12.
 */
public class XmlUtils {

    public static Document getXmlDocument(String config) {
        try {
            return new SAXReader().read(ClassLoader.getSystemResource(config));
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }

    public static void writeXmlDocument(String path, Document document) {
        try {
            new XMLWriter(new FileOutputStream(path), OutputFormat.createPrettyPrint()).write(document);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 在第一个<bean/>的第一个<property/>后面添加一个<property/>标签
<bean id="id1" class="com.fq.benz"> 
    <property name="name" value="benz"/>  
    <property name="rate" value="3.14"/>
    <property name="refBean" ref="id2">新添加的标签</property> 
</bean>  
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
public class Dom4jAppend {

    private Document document;

    @Before
    public void setUp() {
        document = XmlUtils.getXmlDocument("config.xml");
    }

    @Test
    @SuppressWarnings("unchecked")
    public void client() {
        Element beans = document.getRootElement();
        Element firstBean = beans.element("bean");
        List<Element> properties = firstBean.elements();

        //Element property = DocumentHelper
        // .createElement(QName.get("property", firstBean.getNamespaceURI()));
        Element property = DocumentFactory.getInstance()
                .createElement("property", firstBean.getNamespaceURI());
        property.addAttribute("name", "rate");
        property.addAttribute("value", "3.14");
        properties.add(1, property);
    }

    @After
    public void tearDown() {
        XmlUtils.writeXmlDocument("src/main/resources/config.xml", document);
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
Dom4j修改节点
  • 将id1 bean的第一个<property/>修改如下:
<property name="name" value="翡青"/>  
 
 
  • 1

 
 
  • 1
@Test
@SuppressWarnings("unchecked")
public void client() {
    Element beans = document.getRootElement();
    Element firstBean = beans.element("bean");
    List<Element> properties = firstBean.elements();

    Element property = DocumentFactory.getInstance()
            .createElement("property", firstBean.getNamespaceURI());
    property.addAttribute("name", "rate");
    property.addAttribute("value", "3.14");
    properties.add(1, property);
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
Dom4j 删除节点
  • 删除刚刚修改的节点
@Test
@SuppressWarnings("unchecked")
public void delete() {
    List<Element> beans = document.getRootElement().elements("bean");
    for (Element bean : beans) {
        if (bean.attributeValue("id").equals("id1")) {
            List<Element> properties = bean.elements("property");
            for (Element property : properties) {
                if (property.attributeValue("name").equals("name")) {
                    // 执行删除动作
                    property.getParent().remove(property);
                    break;
                }
            }
            break;
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18

Dom4j实例

在Java 反射一文中我们实现了根据JSON配置文件来加载bean的对象池,现在我们可以为其添加根据XML配置(XML文件同前):

/**
 * @author jifang
 * @since 16/1/18下午9:18.
 */
public class XmlParse {

    private static final ObjectPool POOL = ObjectPoolBuilder.init(null);

    public static Element parseBeans(String config) {
        try {
            return new SAXReader().read(ClassLoader.getSystemResource(config)).getRootElement();
        } catch (DocumentException e) {
            throw new RuntimeException(e);
        }
    }

    public static void processObject(Element bean, List<? extends Element> properties)
            throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchFieldException {
        Class<?> clazz = Class.forName(bean.attributeValue(CommonConstant.CLASS));
        Object targetObject = clazz.newInstance();

        for (Element property : properties) {
            String fieldName = property.attributeValue(CommonConstant.NAME);
            Field field = clazz.getDeclaredField(fieldName);
            field.setAccessible(true);
            // 含有value属性
            if (property.attributeValue(CommonConstant.VALUE) != null) {
                SimpleValueSetUtils.setSimpleValue(field, targetObject, property.attributeValue(CommonConstant.VALUE));
            } else if (property.attributeValue(CommonConstant.REF) != null) {
                String refId = property.attributeValue(CommonConstant.REF);
                Object object = POOL.getObject(refId);
                field.set(targetObject, object);
            } else {
                throw new RuntimeException("neither value nor ref");
            }
        }

        POOL.putObject(bean.attributeValue(CommonConstant.ID), targetObject);
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40

注: 上面代码只是对象池项目的XML解析部分,完整项目可参考git@git.oschina.net:feiqing/commons-frame.git

XPath

XPath是一门在XML文档中查找信息的语言,XPath可用来在XML文档中对元素和属性进行遍历.

表达式 描述
/ 从根节点开始获取(/beans:匹配根下的<beans/>; /beans/bean:匹配<beans/>下面的<bean/>)
// 从当前文档中搜索,而不用考虑它们的位置(//property: 匹配当前文档中所有<property/>)
* 匹配任何元素节点(/*: 匹配所有标签)
@ 匹配属性(例: //@name: 匹配所有name属性)
[position] 位置谓语匹配(例: //property[1]: 匹配第一个<property/>;//property[last()]: 匹配最后一个<property/>)
[@attr] 属性谓语匹配(例: //bean[@id]: 匹配所有带id属性的标签; //bean[@id='id1']: 匹配所有id属性值为’id1’的标签)

谓语: 谓语用来查找某个特定的节点或者包含某个指定的值的节点.

XPath的语法详细内容可以参考W3School XPath 教程.

Dom4j对XPath的支持

默认的情况下Dom4j并不支持XPath, 需要在pom下添加如下依赖:

<dependency>
    <groupId>jaxen</groupId>
    <artifactId>jaxen</artifactId>
    <version>1.1.6</version>
</dependency>
 
 
  • 1
  • 2
  • 3
  • 4
  • 5

 
 
  • 1
  • 2
  • 3
  • 4
  • 5

Dom4jNode接口提供了方法对XPath支持:

方法
List selectNodes(String xpathExpression)
List selectNodes(String xpathExpression, String comparisonXPathExpression)
List selectNodes(String xpathExpression, String comparisonXPathExpression, boolean removeDuplicates)
Object selectObject(String xpathExpression)
Node selectSingleNode(String xpathExpression)

XPath实现查询

  • 查询所有bean标签上的属性值
/**
 * @author jifang
 * @since 16/1/20上午9:28.
 */
public class XPathRead {

    private Document document;

    @Before
    public void setUp() throws DocumentException {
        document = XmlUtils.getXmlDocument("config.xml");
    }

    @Test
    @SuppressWarnings("unchecked")
    public void client() {
        List<Element> beans = document.selectNodes("//bean");
        for (Element bean : beans) {
            System.out.println("id: " + bean.attributeValue("id") +
                    ", class: " + bean.attributeValue("class"));
        }
    }
}
 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

 
 
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23

XPath实现更新

  • 删除id=”id2”的<bean/>
@Test
public void client() {
    Node bean = document.selectSingleNode("//bean[@id=\"id2\"]");
    bean.getParent().remove(bean);
}


DanielMeng9527
关注
专栏目录
在java中使用dom4j解析xml(示例代码)
09-04
鉴于目前的趋势，我们这里来讲讲Dom4j的基本用法，不涉及递归等复杂操作。Dom4j的用法很多，官网上的示例有那么点儿晦涩，这里就不写了
java使用dom4j解析xml配置文件实现抽象工厂反射示例
09-04
在这个例子中，`BeanFactory`使用DOM4J的`SAXReader`来解析XML文档，获取`service-class`和`dao-class`下的所有元素。这些元素代表了工厂需要生产的对象，即接口的实现类。工厂将创建的对象存储在一个Map中，以便...
转载：Java使用dom4j解析XML
Fly~~~的专栏
12-05 1358
原文地址：http://blog.csdn.net/yyywyr/article/details/38359049 解析XML的方式有很多，本文介绍使用dom4j解析xml。 1、环境准备 （1）下载dom4j-1.6.1.jar （2）下载junit-4.10.jar 2、温馨提示 解析XML过程是通过获取Document对象，然后继续获取各个节点以及属性等操作，因此获取Documen
java用dom4j解析xml_Java中使用dom4j解析xml文档
weixin_35840387的博客
02-17 182
前段时间学习了XML(Extensible Markup Language)可扩展标记语言后了解到了XML被设计为具有自我描述性，它的设计宗旨是传输数据，而不是显示数据那如果我们想要获取到XML的数据内容应该怎么办呢？于是我最近学习到了可以使用dom4j来解析XML文档并获取其中的数据那么什么是dom4j呢？简单来说：dom4j是一个Java的XML API，是jdom的升级品，用来读写XML文件...
JAVA 使用Dom4j 解析XML
醉ぃ灬清风。
06-06 1566
解析XML的方式有很多，本文介绍使用dom4j解析xml。 1、环境准备 （1）下载dom4j-1.6.1.jar （2）下载junit-4.10.jar 2、温馨提示 解析XML过程是通过获取Document对象，然后继续获取各个节点以及属性等操作，因此获取Document对象是第一步，大体说来，有三种方式： （1）自己创建Document对象 Docume
在java中使用dom4j解析xml
da297368860的博客
07-02 3423
话不多说，直接上 xml文档： <?xml version="1.0" encoding="UTF-8"?> <books> <book id="001"> <title>Harry Potter</title> <author>J K. Rowling</author> </book> <book id="002"> <
java中使用dom4j解析XML文件的方法教程
08-26
Java中使用Dom4j解析XML文件的方法教程 domest4j是一个Java的XML API，性能优异、功能强大、易于使用。下面我们将学习如何使用Dom4j解析XML文件。 为什么使用Dom4j？ Dom4j是一个基于Java的XML API，具有高性能...
xmlParse:使用 dom4j 将 XML 文档解析为 Java 对象
06-14
使用 dom4j 将 XML 文档解析为我自己的格式 格式： 私人字符串名称； 私有字符串值； 私人列表 childList; private Map<String> propMap = new HashMap(); 意义 将 XML 文档对象转换成这个格式对象（XmlElement...
Java使用sax、dom、dom4j解析xml文档
01-22
Java提供了多种解析XML的API，包括SAX（Simple API for XML）、DOM（Document Object Model）以及DOM4J。下面我们将详细探讨这些解析方式及其在实际开发中的应用。 1. SAX解析器： SAX是一种基于事件驱动的解析器，...
java使用 dom4j解析xml文件
Artistiq的博客
12-04 328
步骤 1 导入dom4j  jar包，用Xpath的话吧jaxen包也导入 2 dom4j具体写法 xml文件里的内容 &lt;?xml version="1.0" encoding="utf-8" ?&gt; &lt;stus&gt; &lt;stu&gt; &lt;name&gt;刘德华&lt;/name&gt; &lt;age&gt;666&
利用dom4j--读取xml文件
07-29
利用dom4j--读取xml文件。 代码简洁易懂。
JAVA 应用 DOM4J 及 JDOM 方式解析 XML
王者之峰
05-17 596
DOM4J方式DOM4J及 JDOM 是非官方提供的，应用起来比较简洁。
Java 操作xml文件--dom4j解析
qq_45437885的博客
04-01 2765
Java xml框架dom4j的使用 增删改查
dom4j 对 xml解析
zhuchunyan_aijia的博客
09-11 282
由于DOM4J在解析XML时只能一层一层解析，所以当XML文件层数过多时使用会很不方便，结合XPATH就可以直接获取到某个元素 使用dom4j支持xpath的操作的几种主要形式 默认的情况下，dom4j不支持xpath，如果想要在dom4j里面是有xpath，第一步需要，引入支持xpath的jar包 &lt;dependency&gt; &lt;groupId&gt;dom4j&lt;/g...
DOM4J解析XML
gy1030472166的博客
06-07 158
1.XML&lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;cinema&gt; &lt;film id="1"&gt; &lt;name&gt;仙剑奇侠传&lt;/name&gt; &lt;author&gt;胡歌&lt;/author&gt;
XML及使用dom4j解析XML
m0_63647215的博客
04-13 794
常见XML解析方法有两种 1.DOM：要求解析器将整个XML文件全部加载到内存中，生成一个Document对象 优点：元素和元素之间的结构，关系，可以针对元素进行增删查改操作 缺点：如果XML文件过大，可能会导致内存溢出 2.SAX：是一种速度更快，更加高效的解析方式，她是逐行扫描，边扫描边解析，并且以事件驱动的方式来进行具体的解析，每解析一行，都会出发一个事件。 优点：不会出现内存溢出，可以处理大文件 确定：只能读，不能写 解析器就是根据不同的解析方式提供具体的实现，为了方便开发人员来解
java使用dom4j实现xml文件的解析
nhx900317的博客
09-26 1505
至此，解析和修改参数的工作就完成了，还需要注意的，由于直接对xml文件进行操作，如果有同时操作同一个航线文件的情况，会有问题，需要加一个线程锁或者文件锁之类的判断。
使用dom4j解析XML文档的方法详解
最新发布
weixin_47847063的博客
07-13 5405
dom4j是一个基于Java的开源XML解析器，它提供了一种简单而灵活的方式来解析和操作XML文档。它使用了DOM（Document Object Model）模型，使开发者能够轻松地读取、写入和修改XML数据。本文将详细介绍dom4j的使用方法，并提供示例代码来说明各种操作。
Java使用Dom4J方式解析XML文件
浩瀚星空，法力无边；其大无外，其小无内。
11-30 1348
一 dom4j介绍 使用方式：在pom.xml中导入dom4j对应的jar <dependency> <groupId>dom4j</groupId> <artifactId>dom4j</artifactId> <version>1.6.1</version> </dependency> 优点：dom4j使Java生成和解析XML灵活性变高，并且代码易于.
Java使用DOM4J解析XML文件教程
要使用 DOM4J 读取并解析这个 XML 文件，你可以创建如下的 Java 代码： ```java package com.hsinghsu.testXML; import org.dom4j.Document; import org.dom4j.DocumentException; import org.dom4j.Element; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值