`
helloyesyes
  • 浏览: 1310183 次
  • 性别: Icon_minigender_2
  • 来自: 武汉
文章分类
社区版块
存档分类
最新评论

JDOM 操作XML

 
阅读更多

可扩展标记语言——eX tensible M arkup L anguage

用户可以自己定义语言标记，只要有开始和闭合标签即可。

xsl装饰、修饰xml的显示结果。

dtd约束xml文件中的标记。

Ø XML的优点：

    1、xml可以让数据和标记分离。

    2、异质信息互通

    3、机器语言

    4、用交流语言替代html装饰语言

    5、简单易用

    6、可以自定义、可扩展  

Ø XML和HTML比较

比较内容

HTML

XML

可扩展性

不具有扩展性、标记固定

是元标记语言，可以定义新标记，用户可以自定义标记

侧重点

侧重于信息的表现形式为什么格式被关注

侧重于结构化的描述信息，数据是什么为XML所关注

语法

不严格（嵌套、配对）

严格嵌套、配对，并按照DTD要求输出

可读性、可维护性

难于阅读和维护

结构清晰，便于阅读维护

数据本身、显示

数据和显示合为一处

数据与显示分离

重用性

低

可重用性高
  

Ø JDOM 操作 XML

JDOM可以很方便的操作XML文档，完成XML内容的创建、修改，已经遍历Document文档中的XML元素，完成查询等。下面我们就用JDOM完成这些功能。

# 准备

首先我们要准备jdom相关的jar包

jdom-jar下载地址：http://www.jdom.org/dist/binary/

jaxen在jdom的zip压缩包中可以找到。

Junit是测试用的，可以不添加。但需要用main方法测试。

Junit-jarhttp://ebr.springsource.com/repository/app/bundle/version/download?name=com.springsource.org.junit&version=4.8.1&type=binary   

 

其次，是准备测试工作。部分测试代码： 

package
 com.hoo.test;
 
import
 java.io.File;
import
 java.io.IOException;
import
 java.util.List;
import
 javax.xml.parsers.DocumentBuilder;
import
 javax.xml.parsers.DocumentBuilderFactory;
import
 javax.xml.parsers.ParserConfigurationException;
import
 org.jdom.Attribute;
import
 org.jdom.Comment;
import
 org.jdom.Document;
import
 org.jdom.Element;
import
 org.jdom.JDOMException;
import
 org.jdom.Namespace;
import
 org.jdom.Text;
import
 org.jdom.input.SAXBuilder;
import
 org.jdom.output.XMLOutputter;
import
 org.jdom.xpath.XPath;
import
 org.junit.After;
import
 org.junit.Before;
import
 org.junit.Test;
 
/**

 * <b>function:</b> JDOM操作XML

 * @author hoojo

 * @createDate 2011-8-4 下午12:34:09

 * @file DocumentTest.java

 * @package com.hoo.test

 * @project JDOMTest

 * @blog http://blog.csdn.net/IBM_hoojo

 * @email hoojo_@126.com

 * @version 1.0

 */

public
 class
 DocumentTest {
    
    private
 XMLOutputter out = null;
    
    @Before
    public
 void
 init() {
        //输出文件信息

        out = new
 XMLOutputter();
    }
    
    @After
    public
 void
 destory() {
        if
 (out != null) {
            out = null;
        }
        System.gc();
    }
    
    /**

     * <b>function:</b>输出Document文档信息

     * @author hoojo

     * @createDate 2011-8-5 下午12:10:27

     * @param doc

     */

    private
 void
 print(Document doc) {
        //设置XML文件编码格式

        //out.setFormat(Format.getCompactFormat().setEncoding("gb2132"));

        System.out.println(out.outputString(doc));
    }
    
    private
 void
 fail(Object o) {
        if
 (o != null) {
            System.out.println(o);
        }
    }
}
 

# 创建Document 

/**

 * 创建xml元素

 */

@Test
public
 void
 createDoc() {
    Document doc = null;
    //method 1、创建一个Doc文档，添加一个元素root

    doc = new
 Document(new
 Element("root"
));
    print(doc);
    
    //method 2、创建一个Doc文档，添加一个元素root，设置root元素的节点文本

    doc = new
 Document(new
 Element("root"
).setText("this is a root el"
));
    print(doc);
    
    //method 3、创建一个Doc文档，添加一个元素root，设置root元素的节点文本且添加一个属性id，值为110

    Element root = new
 Element("root"
);
    root.setText("this is a root el"
);
    root.setAttribute("id"
, "110"
);
    doc.setRootElement(root);
    fail("method 3: \n"
 + out.outputString(doc));
    
    //method 4、创建一个Doc文档，添加一个元素root，设置root元素的节点文本

    doc = new
 Document();
    doc.addContent(new
 Element("root"
).setText("this is a root el"
));
    fail("method 4: \n"
 + out.outputString(doc));
    
    fail(doc.toString());
}

* new Document可以创建一个doc文档

当给Document传递一个Element参数时，这个Element就是根元素；

当调用Document的setRootElement方法时，可以设置当前Doc的根元素；

当调用doc的addContent的时候，添加的元素将会是根元素； 

doc = new
 Document(new
 Element("root"
).setText("this is a root el"
));

上面就创建了一个doc，根元素是root，root节点的内容是this is a root el；

注意setText方法返回的对象是当前Element，类似是StringBuffer的append方法； 

 

* new Element()可以创建一个元素

如果传递参数那么这个参数将会是元素节点的名称；

Element的setText方法可以设置元素的文本值； 

Element root = new
 Element("root"
);
root.setText("this is a root el"
);

创建一个节点名称为root的元素，文本是this is a root el

 

* setAttribute()可以设置某个具体节点的属性值 

root.setAttribute("id"
, "110"
);

给root节点添加一个id，值为110

 

* addContent添加注释 

root .addContent(new
 Comment("注释"
));

在root元素下添加一个注释；

addContent是向元素中添加内容，而setContent是设置内容；

 

* setText设置元素文本内容 

root.setText("this is a root el"
);
同样
root. setContent(new
 Text("this is text"
))
同样
root.addContent("this is text"
);

下面用上面的这些方法，创建一篇XML文档。文档内容如下： 

/**

    创建一遍xml文档

    <?xml version="1.0" encoding="UTF-8"?>

    <car vin="123fhg5869705iop90">

      <!--Description of a car-->

      <make>Toyota</make>

      <model>Celica</model>

      <year>1997</year>

      <color>green</color>

      <license state="CA">1ABC234</license>

    </car>

 */

@Test
public
 void
 createXMLDoc() {
    //创建一个car的元素

    Element carEl = new
 Element("car"
);
    //创建vin属性，并设置值

    carEl.setAttribute("vin"
, "123fhg5869705iop90"
);
    
    //创建注释

    carEl.addContent(new
 Comment("Description of a car"
));
    
    //创建一个make元素，设置文本内容

    carEl.addContent(new
 Element("make"
).setText("Toyota"
));
    
    //创建一个model元素，添加一个文本元素

    carEl.addContent(new
 Element("model"
).setContent(new
 Text("Celica"
)));
    
    //创建一个year元素，添加文本内容

    carEl.addContent(new
 Element("year"
).addContent("1997"
));
    
    //创建一个color元素，文本内容是green

    carEl.addContent(new
 Element("color"
).setText("green"
));
    
    //创建一个license的元素

    Element licenseEl = new
 Element("license"
);
    //为license元素添加文本内容

    licenseEl.addContent("1ABC234"
);
    //创建一个state的属性，值为CA

    licenseEl.setAttribute("state"
, "CA"
);
    //将licenseEl添加到根元素中

    carEl.addContent(licenseEl);
    
    //将car元素设置为根元素

    Document doc = new
 Document(carEl);
    print(doc);
    /*out = new XMLOutputter();

    try {

        out.output(doc, System.out);

    } catch (IOException e) {

        e.printStackTrace();

    }*/

}

方法运行后，所创建的文档和上面注释文档内容相同

 

# 读取XML文件的内容

disk.xml文件内容如下： 

<?
xml
 version
="1.0"
 encoding
="UTF-8"
?>

<
HD
>

    <
disk
 name
="C"
>

        <
capacity
>
8G</
capacity
>

        <
directories
>
200</
directories
>

        <
files
>
1580</
files
>

    </
disk
>

    <
disk
 name
="D"
>

        <
capacity
>
10G</
capacity
>

        <
directories
>
500</
directories
>

        <
files
>
3000</
files
>

    </
disk
>

    <
disk2
 name
="E"
>

        <
capacity
>
11G</
capacity
>

        <
directories
>
50</
directories
>

        <
files
 size
="200"
 modifyDate
="2011-08-3"
>

            <
file
>
Java book</
file
>

            <
file
>
Spring.txt</
file
>

            <
file
>
strtus.doc</
file
>

        </
files
>

    </
disk2
>

    <
files
 size
="220"
>
500</
files
>

</
HD
>

读取disk文件的内容，代码如下： 

/**

 * <b>function:</b>读取xml文件中的元素

 * @author hoojo

 * @createDate 2011-8-4 下午04:54:17

 */

@Test
@SuppressWarnings("unchecked"
)
public
 void
 readXMLContent() {
    SAXBuilder builder = new
 SAXBuilder();
    try
 {
        Document doc = builder.build(new
 File("file/disk.xml"
));
        Element rootEl = doc.getRootElement();
        //获得所有子元素

        List<Element> list = rootEl.getChildren();
        //List<Element> list = rootEl.getChildren("disk");

        for
 (Element el : list) {
            //获取name属性值

            String name = el.getAttributeValue("name"
);
            //获取子元素capacity文本值

            String capacity = el.getChildText("capacity"
);
            //获取子元素directories文本值

            String directories = el.getChildText("directories"
);
            String files = el.getChildText("files"
);
            System.out.println("磁盘信息:"
);
            System.out.println("分区盘符:"
 + name);
            System.out.println("分区容量:"
 + capacity);
            System.out.println("目录数:"
 + directories);
            System.out.println("文件数:"
 + files);
            System.out.println("-----------------------------------"
);
        }
    } catch
 (JDOMException e) {
        e.printStackTrace();
    } catch
 (IOException e) {
        e.printStackTrace();
    }
}

* getChildren方法可以获取所有子元素

* getChildren(elName)可以获取所有名称为elName的子节点

* getAttributeValue可以获取指定属性的值

* getChildText可以获取子节点的文本值

 

# 递归显示文档信息 

/**

 * 递归返回指定格式的“--”

 */

private
 String format(int
 i) {
    String temp = ""
;
    if
 (i > 0) {
        temp += "--"
;
        i--;
        temp += format(i);
    }
    return
 temp;
}
 
/**

 * <b>function:</b>显示当前节点所有Element的属性信息

 * @author hoojo

 * @createDate 2011-8-4 下午06:10:53

 * @param el

 * @return

 */

@SuppressWarnings("unchecked"
)
private
 String getAttrInfo(Element el) {
    List<Attribute> attrs = el.getAttributes();
    return
 getAttrInfo(attrs);
}
 
/**

 * <b>function:</b>显示属性信息

 * @author hoojo

 * @createDate 2011-8-9 下午03:52:59

 * @param attrs

 * @return

 */

private
 String getAttrInfo(List<Attribute> attrs) {
    StringBuilder info = new
 StringBuilder();
    for
 (Attribute attr : attrs) {
        info.append(attr.getName()).append("="
).append(attr.getValue()).append(", "
);
    }
    if
 (info.length() > 0) {
        return
 "["
 + info.substring(0, info.length() - 2)+ "]"
;
    }
    return
 ""
;
}
 
/**

 * <b>function:</b>递归显示文档节点元素信息

 * @author hoojo

 * @createDate 2011-8-4 下午05:56:34

 * @param i

 * @param list

 */

@SuppressWarnings("unchecked"
)
private
 void
 print(int
 i, List<Element> list) {
    i++;
    for
 (Element el : list) {
        List<Element> childs = el.getChildren();
        if
 (childs.size() > 0) {
            fail(format(i) + el.getName() + "  "
 + getAttrInfo(el));
            print(i, childs);
        } else
 {
            fail(format(i) + el.getName() + ":"
 + el.getText() + "  "
 + getAttrInfo(el));
        }
    }
}

调用print(0, root.getChildren());方法就可以看到一篇格式化后输出的文档内容 

#############显示文档信息###############
--HD  
----disk  [name=C]
------capacity:8G  
------directories:200  
------files:1580  
----disk  [name=D]
------capacity:10G  
------directories:500  
------files:3000  
----disk2  [name=E]
------capacity:11G  
------directories:50  
------files  [size=200, modifyDate=2011-08-3]
--------file:Java book  
--------file:Spring.txt  
--------file:strtus.doc  
----files:500  [size=220]

 

# XPath查询遍历XML文档 

/**

 * <b>function:</b>用xpath遍历xml信息

 * @author hoojo

 * @createDate 2011-8-4 下午04:56:52

* xpath参考：http://www.w3school.com.cn/xpath/xpath_functions.asp

 * 

 *     nodeName 选取此节点的所有子节点 

    /    从根节点选取 

    //   从匹配选择的当前节点选择文档中的节点，而不考虑它们的 

    .    选取当前节点 

    ..   选取当前节点的父节点 

    @  选取属性 

    

    * 匹配任何元素节点 

    @* 匹配任何属性节点 

    node() 配任何类型的节点 

    

    ancestor 选取当前节点的所有先辈（父、祖父等） 

    ancestor-or-self 选取当前节点的所有先辈（父、祖父等）以及当前节点本身 

    attribute 选取当前节点的所有属性 

    child 选取当前节点的所有子元素。 

    descendant 选取当前节点的所有后代元素（子、孙等）。 

    descendant-or-self 选取当前节点的所有后代元素（子、孙等）以及当前节点本身。 

    following 选取文档中当前节点的结束标签之后的所有节点。 

    namespace 选取当前节点的所有命名空间节点 

    parent 选取当前节点的父节点。 

    preceding 选取文档中当前节点的开始标签之前的所有节点。 

    preceding-sibling 选取当前节点之前的所有同级节点。 

    self 选取当前节点。

    

    child::book 选取所有属于当前节点的子元素的 book 节点 

    attribute::languane 选取当前节点的 languange 属性 

    child::* 选取当前节点的所有子元素 

    attribute::* 选取当前节点的所有属性 

    child::text() 选取当前节点的所有文本子节点 

    child::node() 选取当前节点的所有子节点 

    descendant::book 选取当前节点的所有 book 后代 

    ancestor::book 选择当前节点的所有 book 先辈

 */

@SuppressWarnings("unchecked"
)
@Test
public
 void
 queryElementByXPath() {
    SAXBuilder builder = new
 SAXBuilder();
    try
 {
        Document doc = builder.build(new
 File("file/disk.xml"
));
        List<Element> list = XPath.selectNodes(doc, "/HD/disk"
);
        for
 (Element el : list) {
            String name = el.getAttributeValue("name"
);
            String capacity = el.getChildText("capacity"
);
            String directories = el.getChildText("directories"
);
            String files = el.getChildText("files"
);
            System.out.println("磁盘信息:"
);
            System.out.println("分区盘符:"
 + name);
            System.out.println("分区容量:"
 + capacity);
            System.out.println("目录数:"
 + directories);
            System.out.print("文件数:"
 + files);
            
            String capacityText = ((Text) XPath.selectSingleNode(el, "//disk[@name='"
 + name + "']/capacity/text()"
)).getTextNormalize();
            System.out.println("#"
 + capacityText);
            
            System.out.println("-----------------------------------"
);
        }
        //显示文档信息

        System.out.println("#############显示文档信息###############"
);
        print(0, doc.getContent());
        
        //获得hd元素

        System.out.println("#############显示HD子元素信息###############"
);
        Element root = (Element) XPath.selectSingleNode(doc, "/HD"
);
        //fail(root.getChildren().size());

        print(0, root.getChildren());
        
        //获取hd下所有元素

        System.out.println("#############显示HD子元素信息###############"
);
        List roots = (List) XPath.selectNodes(doc, "/HD/*"
);
        //fail(roots.size());

        print(0, roots);
        
        //获得hd下的所有disk元素

        System.out.println("#############显示disk信息###############"
);
        roots = (List) XPath.selectNodes(doc, "/HD/disk"
);
        //fail(roots.size());

        print(0, roots);
        
        System.out.println("#############显示disk2信息###############"
);
        roots = (List) XPath.selectNodes(doc, "/HD/disk2"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的files信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的files指定下标的file信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files/file[1]"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的files最后的file信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files/file[last()]"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的files倒数第二的file信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files/file[last() - 1]"
);
        print(0, roots);
 
        System.out.println("#############显示任意路径下的files的子元素file位置position在第二的file信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files/file[position() = 2]"
);
        //roots = (List) XPath.selectNodes(doc, "//files/file[position() > 2]");

        print(0, roots);
        
        System.out.println("#############显示任意路径下的files第三个file的当前节点的前面所有同级节点信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files/file[3]/preceding-sibling::*"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的disk2之前的所有节点信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//disk2/preceding::*"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的disk2之后的所有节点信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//disk2/following::*"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的files的所有属性信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files/attribute::*"
);
        fail(getAttrInfo(roots));
        
        System.out.println("#############显示任意路径下的节点是disk属性name=C的信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//disk[@name='C']"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的节点是disk的子元素的文本中含义5和8节点的信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//disk/child::*[contains(text(), '8') and contains(text(), '5')]"
);
        //roots = (List) XPath.selectNodes(doc, "//disk/child::*[contains(text(), '8') or contains(text(), '5')]");

        print(0, roots);
 
        System.out.println("#############显示任意路径下的节点是files且有属性size的信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files[@size]"
);
        print(0, roots);
 
        System.out.println("#############显示HD节点下capacity的值为11G的信息###############"
);
        //roots = (List) XPath.selectNodes(doc, "/HD/disk/capacity[text()='11G']");

        roots = (List) XPath.selectNodes(doc, "/HD/*/capacity[text()='11G']"
);
        //roots = (List) XPath.selectNodes(doc, "/*/*/capacity[text()='11G']");

        print(0, roots);
        
        //parent::*表示父节点集合

        System.out.println("#############显示任意路径下的节点是files且属性size有值的父节点的信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//files[@size='200']/parent::*"
);
        print(0, roots);
        
        System.out.println("#############显示任意路径下的节点disk的子节点的capacity信息###############"
);
        roots = (List) XPath.selectNodes(doc, "//disk/child::capacity"
);
        print(0, roots);
        
        //获取c盘的大小

        System.out.println("获取c盘的大小"
);
        Text filesText = (Text) XPath.selectSingleNode(doc, "/HD/disk[@name='C']/files/text()"
);
        System.out.println(filesText.getTextNormalize());
        
        //XPath function

        /**

        string concat (string, string, string*)  联接两个字符串 

        boolean starts-with (string, string)  判断某字符串是否以另一字符串开头 

        boolean contains (string, string)  判断某字符串是否包含另一字符串 

        string substring (string, number, number)  取子字符串 

        number string-length (string)  测字符串长度 

        number sum (node-set)  求和 

        number floor (number)  求小于此数的最大整数值 

        number ceiling (number)  求大于此数最小整数值

        **/
 
 
        System.out.println("获取@size的和大于200的"
);
        roots = (List) XPath.selectNodes(doc, "//files[sum(@size) > 200]"
);
        print(0, roots);
 
        System.out.println("查找directories的内容长度小于3的"
);
        roots = (List) XPath.selectNodes(doc, "//directories[string-length(text()) < 3]"
);
        print(0, roots);
        
        System.out.println("查找files的内容包含5的"
);
        roots = (List) XPath.selectNodes(doc, "//files[contains(text(), '5')]"
);
        print(0, roots);
    } catch
 (JDOMException e) {
        e.printStackTrace();
    } catch
 (IOException e) {
        e.printStackTrace();
    } 
}

 

# 删除元素及其他操作 

/**

 * <b>function:</b>打印doc相关信息

 * @author hoojo

 * @createDate 2011-8-10 下午06:29:01

 */

@SuppressWarnings("unchecked"
)
@Test
public
 void
 printInfo() {
    SAXBuilder builder = new
 SAXBuilder();
    try
 {
        //builder.setFeature("user", true);

        //builder.setIgnoringBoundaryWhitespace(true);

        //忽略元素内容的空格

        //builder.setIgnoringElementContentWhitespace(true);

        
        Document doc = builder.build(new
 File("file/web.xml"
));
        fail("baseURI: "
 + doc.getBaseURI());
        fail("ContentSize: "
 + doc.getContentSize());
        //System.out.println("getContent: ");

        //print(0, doc.getContent());

        
        fail("getContent index: "
 + doc.getRootElement().getContent(1));
        fail("getDocType: "
 + doc.getDocType());
        fail("getParent: "
 + doc.getRootElement().getContent(1).getParent());
        fail("getProperty: "
 + doc.getProperty("filter"
));
        print(0, XPath.selectNodes(doc, "//*[contains(text(), '#')]"
));
        fail("getText: "
 + ((Element)XPath.selectNodes(doc, "//*[contains(text(), '#')]"
).get(0)).getText());
        fail("getTextTrim: "
 + ((Element)XPath.selectNodes(doc, "//*[contains(text(), '#')]"
).get(0)).getTextTrim());
        fail("getTextNormalize: "
 + ((Element)XPath.selectNodes(doc, "//*[contains(text(), '#')]"
).get(0)).getTextNormalize());
        fail("hasRootElement: "
 + doc.hasRootElement());
        
        //如果文档带有Namespace一定要设置Namespace，不然无法读取内容

        Namespace ns = Namespace.getNamespace("http://java.sun.com/xml/ns/javaee"
);
        Element servletEl = doc.getRootElement().getChild("servlet"
, ns);
        fail("servletEl: "
 + servletEl);
        print(0, servletEl.getChildren());
        
        fail("getChildText: "
 + servletEl.getChildText("servlet-class"
, ns));
        fail("getChildTextNormalize: "
 + servletEl.getChildTextNormalize("servlet-name"
, ns));
        fail("getChildTextTrim: "
 + servletEl.getChildTextTrim("servlet-class"
, ns));
        fail("getName: "
 + servletEl.getName());
        fail("getNamespacePrefix: "
 + servletEl.getNamespacePrefix());
        fail("getNamespace: "
 + servletEl.getNamespace());
        fail("getQualifiedName: "
 + servletEl.getQualifiedName());
        Element classEl = servletEl.getChild("servlet-class"
, ns);
        fail("getText: "
 + classEl.getText());
        fail("getTextNormalize: "
 + classEl.getTextNormalize());
        fail("getTextTrim: "
 + classEl.getTextTrim());
        fail("getValue: "
 + classEl.getValue());
        
        //删除节点

        fail(doc.getRootElement().removeContent(3));
        //print(0, doc.removeContent());

        //print(0, doc.getRootElement().getChildren());

        fail(servletEl.removeChild("servlet-class"
, ns));
        fail(servletEl.removeChildren("init-param"
, ns));
        
        print(0, servletEl.getChildren());
    } catch
 (JDOMException e) {
        e.printStackTrace();
    } catch
 (IOException e) {
        e.printStackTrace();
    }
}

 

0
顶
1
踩
分享到：
| 我的那些女人们
评论
发表评论

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

相关推荐

    jdom 读取XML 文件

    本篇文章将深入探讨如何使用JDOM来读取XML文件。 首先，我们需要了解JDOM的基本概念。JDOM通过构建一棵DOM（Document Object Model）树来表示XML文档，这棵树是由节点构成的，包括元素（Element）、属性（Attribute...

    java利用jdom读取xml文件

    下面将详细介绍如何使用JDOM来读取XML文件。 首先，我们需要了解XML的基本概念。XML（eXtensible Markup Language）是一种标记语言，用于存储和传输结构化数据。它的结构清晰，易于人和机器理解，广泛应用于网络...

    JDOM读取XML，并且创建XML

    在JDOM中，读取XML文件通常涉及以下步骤： 1. 创建一个`SAXBuilder`实例，这是解析XML文档的入口点。 2. 使用`SAXBuilder`的`build`方法读取XML文件，返回一个`Document`对象。 3. 通过`Document`对象访问XML文档的...

    JDOM操作xml文件的xmlBean

    ### JDOM操作XML文件的关键知识点 #### 一、JDOM简介 JDOM（Java Document Object Model）是一种基于Java的XML解析API，它提供了一种简便的方式来解析和操作XML文档。与传统的DOM相比，JDOM更加注重性能和易用性，...

    用JDOM读取XML文件

    用JDOM读取XML文件 用JDOM读取XML文件用JDOM读取XML文件

    jdom读取xml全属性文件

    总结一下，JDOM在Java EE环境中用于读取XML文件，提供了便捷的API来操作XML文档。在处理包含属性的XML元素时，可以利用`Element`类的`getAttributeValue()`方法轻松获取属性值。对于大型或复杂的XML文档，JDOM提供了...

    利用jdom操作xml文档

    ### 利用 JDOM 操作 XML 文档 #### 一、引言 JDOM（Java Document Object Model）是一种用于处理 XML 数据的 Java 库。它提供了面向对象的 API，允许开发人员以简单直观的方式创建、读取、更新和保存 XML 文档。与 ...

    jdom 操作xml文档

    在实际开发中，使用JDOM操作XML文档可以极大地简化代码，提高效率。然而，需要注意的是，JDOM虽然简单易用，但在处理大型XML文件时可能会消耗大量内存。对于性能要求较高的场景，可以考虑使用SAX（Simple API for ...

    使用JDOM解析XML文件

    在Java编程中，JDOM（Java Document Object Model）是处理XML的一种库，它提供了方便的方式来创建、修改和读取XML文档。本篇文章将深入探讨如何使用JDOM解析XML文件。 首先，我们需要理解JDOM的基本结构。JDOM通过...

    jdom学习读取xml文件.files

    本教程将深入探讨如何使用JDOM读取XML文件，并阐述其在Spring框架中的应用。 首先，我们了解JDOM的基本概念。JDOM提供了一种树型结构来表示XML文档，其中XML元素、属性、文本和注释等都对应于特定的Java对象。通过...

    jdom-1.1.zip jdom-1.1.jar jdom.jar jdom库 jdom操作xml

    例如，你可以创建一个`SAXBuilder`实例，然后调用其`build()`方法读取XML文件并将其转换为`Document`对象。 `jdom-b3-docs.zip`可能包含JDOM的API文档，这对于理解和使用库中的各种类和方法至关重要。开发者可以...

    JAVA操作XML\XML\用JDOM操作XML文件--JSP中文网.mht

    JAVA操作XML\XML\用JDOM操作XML文件--JSP中文网.mht

    jdom操作xml的文档

    **JDOM 操作 XML 文档详解** XML (eXtensible Markup Language) 是一种用于标记数据的语言，广泛应用于数据交换、配置文件等场景。而 JDOM（Java Document Object Model）是一个专门为 Java 设计的 XML 处理库，它...

    java读取XML（JDOM）

    Java读取XML文件是开发过程中常见的任务，JDOM是一个用于处理XML文档的Java库，它提供了方便、高效的方式来创建和操作XML数据。本篇将详细讲解如何使用JDOM来读取XML文件，以及相关的源码解析。 首先，我们需要了解...

    java jdom解析xml

    - **优化策略**：如果确实需要处理大型XML文件，可以使用JDOM的SAXBuilder，它允许以SAX方式读取XML，但仍然使用JDOM API进行操作。 6. **示例代码** ```java import org.jdom2.Document; import org.jdom2....

    jdom 读取修改xml文件

    JDOM 的设计非常直观且易于使用，尤其适合那些希望在 Java 程序中轻松操作 XML 的开发人员。 #### 使用 JDOM 读取 XML 文件 在本文提供的示例代码中，我们首先导入了必要的类库： ```java import java.io....

    JDom 读写XML

    使用JDom读取XML文件通常涉及以下步骤： - 创建SAXBuilder实例。 - 调用`build()`方法，传入XML文件的输入流或文件路径，返回一个Document对象，表示整个XML文档。 - 通过Document对象获取根元素，然后可以遍历...

    jdom读取xml详细例子

    本篇文章将详细介绍如何使用 JDOM 来读取 XML 文件，并通过一个详细的示例代码来帮助理解其基本操作。 首先，我们需要了解 JDOM 的基本组件。`Element` 类是 XML 中节点的表示，它可以有属性和子节点。`Document` ...

    jdom 操作XML实现增删改查

    这里我们主要讨论基于DOM的JDOM操作。 1. 创建XML文档 使用JDOM的`DocumentBuilderFactory`和`DocumentBuilder`类创建一个新的XML文档实例，然后通过`Element`类添加根元素及其子元素。 ```java ...

    用jdom解析xml

    JDOM是一个专门为Java设计的API，它提供了一种高效、方便的方式来构建和读取XML文档。在这个教程中，我们将深入探讨如何在JSP（JavaServer Pages）环境中使用JDOM解析XML。 **1. JDOM基本概念** JDOM的核心在于两...

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