java_Dom4j解析XML详解

合集下载

dom4j element方法总结

dom4j element方法总结

dom4j element方法总结DOM4J是一个Java库,用于处理XML文档。

它提供了一种方便的方式来解析、修改和创建XML文档。

以下是DOM4J Element的一些常用方法:1. 获取子元素:`List<Element> elements()`: 获取当前元素的所有子元素。

`List<Element> elements(String name)`: 根据指定的元素名称获取所有子元素。

`Element element(String name)`: 根据指定的元素名称获取子元素对象,如果元素名称重复,则获取第一个元素。

2. 获取和设置文本内容:`String getText()`: 获取当前元素对象的文本内容。

`void setText(String text)`: 设置当前元素对象的文本内容。

3. 获取属性值:`String attributeValue(String name)`: 根据指定的属性名称获取其对应的值。

4. 添加属性:`public Element addAttribute(String name, String value)`: 根据指定的属性名称和值进行添加或修改。

5. 获取根元素:`Element getRootElement()`: 获取根元素对象(根标签)。

6. 遍历所有元素节点:可以通过递归的方式遍历所有元素节点并打印它们的名称。

首先获取根元素,然后对每个子元素递归调用此方法。

7. 其他常用操作:获取元素的命名空间URI、命名空间Prefix等。

判断元素是否有某个属性。

删除或替换子元素等。

使用DOM4J时,建议查阅官方文档或相关教程,以了解更多关于Element 和其它相关功能的详细信息。

java如何解析http请求返回的xml报文

java如何解析http请求返回的xml报文

java如何解析http请求返回的xml报⽂xml报⽂解析⽅法有很多种,此处采⽤dom4j的⽅法。

dom4j的jar包下载地址:https://dom4j.github.io/#1、request.getInputStream()和new SAXReader().read(输⼊流):返回的报⽂如下:<?xml version="1.0" encoding="UTF-8"?><CreateAccessKeyResponse> <CreateAccessKeyResult> <AccessKey> <UserName>aaa</UserName> <AccessKeyId>2019dfc6ab5fe433f10c</AccessKeyId> <Status>Active</Status> <IsPrimary>false</IsPrimary> <SecretAccessKey>a14aeb3ac35b835d5ec4507d5667a353c77ceedc</SecretAccessKey></AccessKey></CreateAccessKeyResult></CreateAccessKeyResponse>获取参数AccessKeyId的值:import org.dom4j.Document;import org.dom4j.Element;import org.dom4j.io.SAXReader;HttpURLConnection conn = create_AccessKey(); //create_AccessKey为⾃⼰写的http请求⽅法// 从request中取得输⼊流InputStream inputStream = conn.getInputStream();// 读取输⼊流SAXReader reader = new SAXReader();Document document = reader.read(inputStream);// 得到xml根元素Element root = document.getRootElement();String AK = root.element("CreateAccessKeyResult").element("AccessKey").element("AccessKeyId").getTextTrim();System.out.println("AccessKeyId="+AK+"\n");2、⽤dom4j读取xml⽂件中的参数:public void readXml() throws DocumentException, FileNotFoundException, IOException {String xml =System.getProperty("user.dir")+File.separator+"src"+File.separator+"test"+File.separator+"java"+File.separator+"http"+File.separator+"config.xml"; File xmlFile = new File(xml);SAXReader reader = new SAXReader();try {Document document = reader.read(xmlFile);Element root = document.getRootElement();AK = root.element("ak").getTextTrim();SK = root.element("sk").getTextTrim();} catch (Exception e) {e.printStackTrace();}}config.xml的内容如下:<?xml version="1.0" encoding="UTF-8"?><configuration> <ak>0d34d3db4bab560d343c</ak> <sk>a52628cb22b5a12642dd907075df6996b4c8a7b1</sk></configuration>。

JavaXML解析的四种方法(连载)

JavaXML解析的四种方法(连载)

JavaXML解析的四种⽅法(连载)1. xml简介 XML:指可扩展标记语⾔, Extensible Markup Language;类似HTML。

XML的设计宗旨是传输数据,⽽⾮显⽰数据。

⼀个xml⽂档实例:1 <?xml version="1.0" encoding="UTF-8"?>2 <company name="Tencent" address="深圳市南⼭区">3 <department deptNo="001" name="development">4 <employee id="devHead" position="minister">许刚</employee>5 <employee position="developer">⼯程师A</employee>6 </department>7 <department deptNo="002" name="education">8 <employee position="minister" telephone="1234567">申林</employee>9 <employee position="trainee">实习⽣A</employee>10 </department>11 </company> 第⼀⾏是 XML 声明。

它定义 XML 的版本 (1.0) 和所使⽤的编码. 下⼀⾏描述⽂档的根元素:<company>开始,该根元素具有2个属性“name”,"address"。

java解析xml的4种方式的优缺点对比及实现详解

java解析xml的4种方式的优缺点对比及实现详解

java解析xml的4种⽅式的优缺点对⽐及实现详解⼀、介绍及优缺点分析DOM(Document Object Model)DOM是⽤与平台和语⾔⽆关的⽅式表⽰XML⽂档的官⽅W3C标准。

DOM是以层次结构组织的节点或信息⽚断的集合。

这个层次结构允许开发⼈员在树中寻找特定信息。

分析该结构通常需要加载整个⽂档和构造层次结构,然后才能做任何⼯作。

由于它是基于信息层次的,因⽽DOM被认为是基于树或基于对象的。

【优点】①允许应⽤程序对数据和结构做出更改。

②访问是双向的,可以在任何时候在树中上下导航,获取和操作任意部分的数据。

整个⽂档树在内存中,便于操作;⽀持删除、修改、重新排列等多种功能【缺点】①通常需要加载整个XML⽂档来构造层次结构,消耗资源⼤。

将整个⽂档调⼊内存(包括⽆⽤的节点),浪费时间和空间;使⽤场合:⼀旦解析了⽂档还需多次访问这些数据;硬件资源充⾜(内存、CPU)SAX(Simple API for XML)SAX处理的优点⾮常类似于流媒体的优点。

分析能够⽴即开始,⽽不是等待所有的数据被处理。

⽽且,由于应⽤程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。

这对于⼤型⽂档来说是个巨⼤的优点。

事实上,应⽤程序甚⾄不必解析整个⽂档;它可以在某个条件得到满⾜时停⽌解析。

⼀般来说,SAX还⽐它的替代者DOM快许多。

选择DOM还是选择SAX?对于需要⾃⼰编写代码来处理XML⽂档的开发⼈员来说,选择DOM还是SAX解析模型是⼀个⾮常重要的设计决策。

DOM采⽤建⽴树形结构的⽅式访问XML⽂档,⽽SAX采⽤的是事件模型。

DOM解析器把XML⽂档转化为⼀个包含其内容的树,并可以对树进⾏遍历。

⽤DOM解析模型的优点是编程容易,开发⼈员只需要调⽤建树的指令,然后利⽤navigation APIs访问所需的树节点来完成任务。

可以很容易的添加和修改树中的元素。

然⽽由于使⽤DOM解析器的时候需要处理整个XML⽂档,所以对性能和内存的要求⽐较⾼,尤其是遇到很⼤的XML⽂件的时候。

dom4j xpath语法

dom4j xpath语法

dom4j xpath语法在Java开发中,dom4j是一个非常常用的XML解析工具,而XPath 是dom4j中用于定位XML元素的一种查询语言。

本文将详细介绍dom4j中XPath的语法及用法。

一、XPath简介XPath是一种在XML文档中进行导航和查询的语言,它可以通过元素的层级关系、属性、文本内容等信息来定位XML元素。

在dom4j 中,我们可以通过XPath来快速定位XML元素,从而方便地进行数据提取和处理。

二、XPath语法1. 标签定位XPath可以通过标签名称来定位元素。

例如,要定位一个名为"book"的元素,可以使用以下语法://book2. 属性定位XPath还可以通过元素的属性来定位。

例如,要定位一个属性名为"id"且值为"001"的元素,可以使用以下语法://*[@id='001']3. 属性匹配XPath可以通过属性的匹配来定位元素。

例如,要定位属性名为"class"且值包含"active"的元素,可以使用以下语法://*[contains(@class, 'active')]4. 层级定位XPath可以通过元素的层级关系来定位。

例如,要定位某个元素下的子元素,可以使用以下语法://parent/child5. 文本内容定位XPath可以通过元素的文本内容来定位。

例如,要定位某个元素的文本内容为"hello world"的元素,可以使用以下语法://*[text()='hello world']6. 逻辑运算XPath支持逻辑运算符来组合多个条件。

例如,要定位属性名为"class"且值为"active"的元素,并且其父元素的属性名为"type"且值为"container",可以使用以下语法://*[contains(@class,'active') and parent::*[@type='container']]7. 通配符XPath支持通配符"*"来代表任意元素。

dom4j用法

dom4j用法

dom4j用法dom4j是一个开源的JavaXML解析库,用于解析XML文档并提供API来操作XML元素和属性。

它可以轻松地读取、分析和生成XML文件。

dom4j支持使用XPath表达式来访问XML文档中的节点和属性。

XPath是一种用于在XML文档中定位节点的语言。

dom4j还提供了一些高级功能,如XML命名空间的支持和DTD验证。

使用dom4j可以轻松地解析XML文档,例如:```SAXReader reader = new SAXReader();Document document = reader.read(newFile('path/to/xml/file.xml'));Element root = document.getRootElement();List<Element> elements = root.elements();for (Element element : elements) {//访问元素}```在上面的代码中,我们使用SAXReader类读取XML文档,并获取根元素。

然后,我们可以使用getRootElement()方法获取XML文档的根元素,并使用elements()方法获取根元素的所有子元素。

除了解析XML文档外,dom4j还提供了API来创建新的XML文档。

例如:```Document document = DocumentHelper.createDocument();Element root = document.addElement('root');Element child = root.addElement('child');child.addAttribute('attribute', 'value');child.setText('text');```在上面的代码中,我们使用DocumentHelper类创建一个新的XML 文档,并添加根元素和一个子元素。

DOM4J详细教程

DOM4J详细教程

DOM4J详细教程
答:
DOM4J是一个Java XML API,它可以用来快速、高效地读取、生成和
修改XML数据。

它支持XPath的完整实现,支持Java5的新功能,并有一
个强大的可扩展的SAX集成,还支持JAXP 1.3、通过支持性能良好的DOM、SAX以及JAXP的结合,它可以提供XML文档的可用性。

1.使用DOM4J
使用DOM4J解析XML文档的主要步骤如下:
(1)创建一个Document对象,该文档对象将描述整个XML文档。

(2)创建一个XMLReader对象,该对象使用DOM4J的API来解析
XML文档。

(3)创建一个DocumentHandler对象,该对象用来处理XML文档内容,如处理XML文档的根元素和子元素等。

(4)使用XMLReader的parse方法来将Document对象与DocumentHandler对象相关联,以便允许访问Document对象的内容。

(5)执行任何必要的处理来解析XML文档中的元素。

2.DOM4J技术
(1)XML读取
DOM4J提供了一组API,可以在处理XML文档时使用。

DOM4J的
org.dom4j.io.XMLReader类可以解析XML文档,将其转换为DOM4J的
Document对象。

它可以使用InputSource或java.io.Reader对象的任何对象,以确保可以将XML文档从字符串、文件或URL读取。

(2)XML写入
(3)XPath查询。

dom4j下载与使用文档

dom4j下载与使用文档

Dom4j下载及使用Dom4j读写XML简介要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在/目前最新dom4j包下载地址:/sourceforge/dom4j/dom4j-1.6.1.zip解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要加入包jaxen-1.1-beta-7.jar.以下是相关操作:一.Document对象相关1.读取XML文件,获得document对象.SAXReader reader = new SAXReader();Document document = reader.read(new File("input.xml"));2.解析XML形式的文本,得到document对象.String text = "<members></members>";Document document = DocumentHelper.parseText(text);3.主动创建document对象.Document document = DocumentHelper.createDocument();Element root = document.addElement("members");// 创建根节点二.节点相关1.获取文档的根节点.Element rootElm = document.getRootElement();2.取得某节点的单个子节点.Element memberElm=root.element("member");// "member"是节点名3.取得节点的文字String text=memberElm.getText();也可以用:String text=root.elementT ext("name");这个是取得根节点下的name字节点的文字.4.取得某节点下名为"member"的所有字节点并进行遍历.List nodes = rootElm.elements("member");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 ageElm = newMemberElm.addElement("age");7.设置节点文字.ageElm.setText("29");8.删除某节点.parentElm.remove(childElm);// childElm是待删除的节点,parentElm是其父节点三.属性相关.1.取得某节点下的某属性Element root=document.getRootElement();Attribute attribute=root.attribute("size");// 属性名name2.取得属性的文字String text=attribute.getText();也可以用:String text2=root.element("name").attributeValue("firstname");这个是取得根节点下name字节点的属性firstname的值.3.遍历某节点的所有属性Element root=document.getRootElement();for(Iterator it=root.attributeIterator();it.hasNext();){Attribute attribute = (Attribute) it.next();String text=attribute.getText();System.out.println(text);}4.设置某节点的属性和文字.newMemberElm.addAttribute("name", "sitinspring");5.设置属性的文字Attribute attribute=root.attribute("name");attribute.setText("sitinspring");6.删除某属性Attribute attribute=root.attribute("size");// 属性名nameroot.remove(attribute);四.将文档写入XML文件.1.文档中全为英文,不设置编码,直接写入的形式.XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));writer.write(document);writer.close();2.文档中含有中文,设置编码格式写入的形式.OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("GBK"); // 指定XML编码XMLWriter writer = new XMLWriter(new FileWriter("output.xml"),format);writer.write(document);writer.close();五.字符串与XML的转换1.将字符串转化为XMLString text = "<members> <member>sitinspring</member> </members>";Document document = DocumentHelper.parseText(text);2.将文档或节点的XML转化为字符串.SAXReader reader = new SAXReader();Document document = reader.read(new File("input.xml"));Element root=document.getRootElement();String docXmlText=document.asXML();String rootXmlText=root.asXML();Element memberElm=root.element("member");String memberXmlText=memberElm.asXML();六.使用XPath快速找到节点.读取的XML文档示例<?xml version="1.0" encoding="UTF-8"?><projectDescription><name>MemberManagement</name><comment></comment><projects><project>PRJ1</project><project>PRJ2</project><project>PRJ3</project><project>PRJ4</project></projects><buildSpec><buildCommand><name>org.eclipse.jdt.core.javabuilder</name><arguments></arguments></buildCommand></buildSpec><natures><nature>org.eclipse.jdt.core.javanature</nature></natures></projectDescription>使用XPath快速找到节点project.public static void main(String[] args){SAXReader reader = new SAXReader();try{Document doc = reader.read(new File("sample.xml"));List projects=doc.selectNodes("/projectDescription/projects/project"); Iterator it=projects.iterator();while(it.hasNext()){Element elm=(Element)it.next();System.out.println(elm.getText()); }}catch(Exception ex){ex.printStackTrace();}}。

dom4j xpath语法

dom4j xpath语法

dom4j xpath语法一、什么是dom4j xpath语法dom4j是一个用于操作XML文档的Java开源库,它提供了一种简单而强大的方式来使用xpath语法对XML文档进行解析和查询。

xpath 是一种用于在XML文档中定位节点的语言,它可以通过路径表达式来选择节点或节点集合。

二、dom4j xpath语法的基本用法1. 选择节点使用xpath语法可以选择XML文档中的节点,例如:- 选择根节点:/- 选择当前节点:.- 选择子节点:/- 选择父节点:..- 选择属性节点:/@属性名2. 谓语谓语可以用于过滤节点,例如:- 选择所有属性为id的节点://节点名[@属性名='属性值']- 选择第一个子节点:/节点名[1]3. 选择节点集合使用xpath语法可以选择多个节点,例如:- 选择所有子节点:/节点名/*- 选择所有后代节点://节点名- 选择所有具有相同父节点的节点:/节点名1 | /节点名24. 选择文本内容使用xpath语法可以选择节点中的文本内容,例如:- 选择节点中的文本内容:/节点名/text()- 选择节点及其后代节点中的文本内容://节点名/text()5. 使用通配符通配符可以用于匹配节点名,例如:- 选择所有节点://*- 选择所有具有相同父节点的节点:/节点名/*三、dom4j xpath语法的高级用法1. 使用函数xpath语法支持多种内置函数,例如:- 选择所有包含指定文本的节点://节点名[contains(text(),'文本内容')]- 选择所有具有指定属性的节点://节点名[@属性名]2. 使用轴轴可以用于选择相对于当前节点的节点,例如:- 选择当前节点的所有子节点:child::- 选择当前节点的所有父节点:parent::- 选择当前节点的所有祖先节点:ancestor::- 选择当前节点的所有后代节点:descendant::四、dom4j xpath语法的实例应用假设有以下XML文档:```<bookstore><book category="web"><title lang="en">Learning XML</title><author>Erik T. Ray</author><year>2003</year><price>39.95</price></book><book category="web"><title lang="en">XQuery Kick Start</title> <author>James McGovern</author><year>2003</year><price>49.99</price></book><book category="programming"><title lang="en">Java Programming</title> <author>John Doe</author><year>2005</year><price>59.99</price></book></bookstore>```我们可以使用dom4j xpath语法来查询和操作这个XML文档,例如:- 选择所有book节点://book- 选择所有category属性为web的book节点://book[@category='web']- 选择所有title节点的文本内容://title/text()- 选择第一个book节点的author节点的文本内容://book[1]/author/text()五、dom4j xpath语法的注意事项1. xpath语法区分大小写,要注意节点名和属性名的大小写。

xml文件解析方法

xml文件解析方法

xml文件解析方法XML文件解析方法引言:XML(可扩展标记语言)是一种用于存储和传输数据的标记语言,它具有良好的可读性和灵活性,被广泛应用于数据交换和配置文件等领域。

在处理XML文件时,解析是必不可少的环节。

本文将介绍几种常用的XML文件解析方法,包括DOM、SAX和StAX。

一、DOM解析方法DOM(文档对象模型)是一种将整个XML文件以树形结构加载到内存中的解析方法。

DOM解析器将XML文件解析为一个树状结构,通过遍历节点来获取和操作XML文件中的数据。

DOM解析方法的优点是易于理解和使用,可以随机访问XML文件中的任意节点,但缺点是占用内存较大,不适用于大型XML文件的解析。

1. 创建DOM解析器对象:使用标准的Java API,可以通过DocumentBuilderFactory类来创建DOM解析器对象。

2. 加载XML文件:通过DOM解析器对象的parse()方法加载XML文件,将其转化为一个树形结构。

3. 遍历节点:使用DOM解析器对象提供的方法,如getElementsByTagName()、getChildNodes()等,可以遍历XML文件中的各个节点,获取节点的名称、属性和文本内容等信息。

4. 获取节点数据:通过节点对象提供的方法,如getNodeName()、getTextContent()等,可以获取节点的名称和文本内容。

二、SAX解析方法SAX(简单API for XML)是一种基于事件驱动的XML解析方法。

在SAX解析过程中,解析器顺序读取XML文件,当遇到节点开始、节点结束或节点文本等事件时,会触发相应的回调方法。

相比于DOM 解析方法,SAX解析方法具有内存占用小、解析速度快的优点,但缺点是无法随机访问XML文件中的节点。

1. 创建SAX解析器对象:使用标准的Java API,可以通过SAXParserFactory类来创建SAX解析器对象。

2. 实现事件处理器:自定义一个事件处理器,实现SAX解析器提供的DefaultHandler类,并重写相应的回调方法,如startElement()、endElement()和characters()等。

xml的四种解析方法及源代码

xml的四种解析方法及源代码

xml的四种解析方法及源代码(SAX、DOM、JDOM、DOM4J)第二种:DOM解析DOM中的核心概念就是节点。

DOM在分析XML文档时,将将组成XML文档的各个部分(元素、属性、文本、注释、处理指令等)映射为一个对象(节点)。

在内存中,这些节点形成一课文档树。

整棵树是一个节点,树中的每一个节点也是一棵树(子树),可以说,DOM就是对这棵树的一个对象描述,我们通过访问树中的节点来存取XML文档的内容。

PS:属性节点是附属于元素的,不能被看做是元素的子节点,更不能作为一个单独的节点DOMPrinter.javaJava代码import org.w3c.dom.Document;import dNodeMap;import org.w3c.dom.Node;import .apache.xerces.internal.parsers.DOMParser;public class DOMPrinter{public static void main(String[] args){try{/** *//** 获取Document对象 */DOMParser parser = new DOMParser();parser.parse("db.xml");Document document = parser.getDocument();printNode(document);} catch (Exception e){e.printStackTrace();}}public static void printNode(Node node){short nodeType=node.getNodeType();switch(nodeType){case Node.PROCESSING_INSTRUCTION_NODE://预处理指令类型 printNodeInfo(node);break;case Node.ELEMENT_NODE://元素节点类型printNodeInfo(node);printAttribute(node);break;case Node.TEXT_NODE://文本节点类型printNodeInfo(node);break;default:break;}Node child=node.getFirstChild();while(child!=null){printNode(child);child=child.getNextSibling();}}/** *//*** 根据节点类型打印节点* @param node*/public static void printNodeInfo(Node node){if (node.getNodeType() == Node.ELEMENT_NODE){System.out.println("NodeName: " + node.getNodeName()); }else if (node.getNodeType() == Node.TEXT_NODE){String value = node.getNodeValue().trim();if (!value.equals(""))System.out.println("NodeValue: " + value);elseSystem.out.println();}else{System.out.println(node.getNodeName()+" : "+node.getNodeValu e());}}/** *//*** 打印节点属性* @param aNode 节点*/public static void printAttribute(Node aNode){NamedNodeMap attrs = aNode.getAttributes();if(attrs!=null){for (int i = 0; i < attrs.getLength(); i++){Node attNode = attrs.item(i);System.out.println("Attribute: " + attNode.getNodeName() + "=\"" + attNode.getNodeValue()+"\"");}}}DOM生成XML文档:DOMCreateExample.javaJava代码import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.ParserConfigurationException;import org.w3c.dom.Document;import org.w3c.dom.Element;import .apache.xml.internal.serialize.XMLSerializer;public class DOMCreateExample{public static void main(String[] args) throws ParserConfiguratio nException{//DOMImplementation domImp = DOMImplementationImpl.getDOMImple mentation();DocumentBuilderFactory builderFact = DocumentBuilderFactory.ne wInstance();DocumentBuilder builder = builderFact.newDocumentBuilder();Document doc = builder.newDocument();//Document doc = domImp.createDocument(null, null, null);Element root = doc.createElement("games");Element child1 = doc.createElement("game");child1.appendChild(doc.createTextNode("Final Fantasy VII")); child1.setAttribute("genre", "rpg");root.appendChild(child1);doc.appendChild(root);XMLSerializer serial;try{serial = new XMLSerializer(new FileOutputStream("domcreate.x ml"), null);serial.serialize(doc);} catch (FileNotFoundException e1){e1.printStackTrace();} catch (IOException e){e.printStackTrace();}}}第三种JDOM解析JDOM利用了java语言的优秀特性,极大地简化了对XML文档的处理,相比DOM 简单易用。

java xml格式返回报文解析

java xml格式返回报文解析

java xml格式返回报文解析Java中可以使用多种方式解析XML格式的返回报文,常见的方式有DOM解析、SAX解析以及基于XML绑定技术的解析。

每种方式都有不同的特点和适用场景,下面将详细介绍这三种解析方式。

1. DOM解析:DOM(Document Object Model)解析是将整个XML文档加载到内存中,构建成一个树形结构,并提供API来操作这个树。

DOM解析提供了许多API,可以通过节点遍历和搜索、属性读取和设置、节点创建和删除等方式来处理XML文档。

DOM解析适用于对XML文档进行多次读写操作,如增删改查等复杂的操作。

使用Java的DOM解析,可以通过以下几个步骤实现:1)使用DocumentBuilderFactory创建一个DocumentBuilder对象。

2)调用DocumentBuilder的parse方法,传入XML文件的输入流,将XML文档解析为一个Document对象。

3)通过Document对象可以获取XML文档的根元素,从而开始对XML文档进行遍历和操作。

DOM解析的优点是能够将整个XML文档加载到内存中,便于操作和修改。

但是对于较大的XML文件,DOM解析会消耗大量的内存空间。

2. SAX解析:SAX(Simple API for XML)解析是一种基于事件驱动的解析方式,它逐行读取XML文档并触发相应的事件,应用程序根据事件的发生来处理XML文档。

SAX解析的特点是速度快、内存消耗小,适用于对XML文档进行单次顺序读取的操作。

使用Java的SAX解析,可以通过以下几个步骤实现:1)定义一个继承自DefaultHandler的处理器类,重写相应的事件回调方法。

2)使用SAXParserFactory创建一个SAXParser对象。

3)调用SAXParser的parse方法,传入XML文件的输入流和处理器对象,开始解析XML文档。

SAX解析的优点是速度快,内存消耗小,适用于大型XML文件的解析。

JAVA 解析XML 文件的三种解析方法

JAVA 解析XML 文件的三种解析方法

创建解析XML文件的三种解析方法1、第一种用w3c解析package w3c;import java.io.File;import java.io.FileOutputStream;import java.util.Random;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.transform.OutputKeys;import javax.xml.transform.Transformer;import javax.xml.transform.TransformerFactory;import javax.xml.transform.dom.DOMSource;import javax.xml.transform.stream.StreamResult;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.NodeList;public class w3c {public static void main(String[] args) throws Exception{ createXml();}//创建XML文档并创建节点public static void createXml() throws Exception{//获取XML解析器工厂类DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();//获取XML解析器DocumentBuilder db = dbf.newDocumentBuilder();//获取操作的document对象Document document = db.newDocument();//设置XML文件的版本document.setXmlVersion("1.0");//创建根节点Element root = document.createElement("students");//将根节点添加到document对象中document.appendChild(root);//声明一个姓名的数组String nameList[] = {"吕布","赵云","马超","张飞","关羽","许褚","孙策","周瑜","夏侯渊","张颌","于禁","黄忠","典韦","曹仁","程普"};String sexList[] = {"男","女"};//循环添加数据for(int i = 0 ;i < 20 ; i++){//创建根元素节点Element rootelement = document.createElement("student");//声明参数IDString id ="";//循环生成一个9为的随机ID数for(int j = 0; j< 9 ; j ++ ){id += new Random().nextInt(8)+1;}//设置根元素节点的属性rootelement.setAttribute("id",id);//将根元素节点添加到根节点中root.appendChild(rootelement);//设置元素节点Element name = document.createElement("name");Element sex = document.createElement("sex");Element age = document.createElement("age");Element phone = document.createElement("phone");//给元素节点赋值name.setTextContent(nameList[newRandom().nextInt(nameList.length)]);sex.setTextContent(sexList[newRandom().nextInt(sexList.length)]);age.setTextContent(new Random().nextInt(20)+20+"");String tel ="";for(int k = 0; k< 7 ; k++ ){tel += new Random().nextInt(9);}phone.setTextContent("0756-"+tel);//将元素节点添加到根元素节点中rootelement.appendChild(name);rootelement.appendChild(sex);rootelement.appendChild(age);rootelement.appendChild(phone);}//开始把Document映射到文件TransformerFactory transFactory =TransformerFactory.newInstance();Transformer transFormer = transFactory.newTransformer();//生成的XML文件File file = new File("w3c.xml");//判断XML文件存不存在,如果不存在则创建if(file.exists()){file.createNewFile();}//设置是否添加空格transFormer.setOutputProperty(OutputKeys.INDENT, "yes");//设置输出文件的格式transFormer.setOutputProperty(OutputKeys.ENCODING, "utf-8");//输出XML文件transFormer.transform(new DOMSource(document), newStreamResult(new FileOutputStream(file)));//输出XML文件的路径System.out.println(file.getAbsolutePath());}//解析XML文档public static void resolving() throws Exception{//获取XML解析器工厂类DocumentBuilderFactory dbf=DocumentBuilderFactory.newInstance();//获取XML解析器DocumentBuilder db = dbf.newDocumentBuilder();//获取操作的document对象Document document = db.parse(new File("w3c.xml"));//获取XML文件的根元素节点NodeList root = document.getElementsByTagName("student");//循环根元素节点信息for(int i = 0 ; i < root.getLength() ;i++){Element student = (Element)root.item(i);System.err.println("id = "+student.getAttribute("id")+" name = "+student.getElementsByTagName("name").item(0).getTextContent()+" sex = "+student.getElementsByTagName("sex").item(0).getTextContent()+" age = "+student.getElementsByTagName("age").item(0).getTextContent()+" phone = "+student.getElementsByTagName("phone").item(0).getTextContent());}}}2、第二种用jdom解析package jdom;import java.io.FileOutputStream;import java.util.Iterator;import java.util.List;import java.util.Random;import org.jdom.Document;import org.jdom.Element;import org.jdom.input.SAXBuilder;import org.jdom.output.Format;import org.jdom.output.XMLOutputter;public class jdom {private static String xmlpath = "jdom.xml";public static void main(String[] args) throws Exception{ //resolving();createXml();}//创建XML文件并添加节点public static void createXml() throws Exception{ //创建document对象Document document = new Document();//创建根节点Element root = new Element("students");//将根节点添加到document对象中document.addContent(root);for(int i = 0 ;i < 20 ; i++){//创建根元素节点Element student = new Element("student");//声明参数IDString id ="";//循环生成一个9为的随机ID数for(int j = 0; j< 9 ; j ++ ){id += new Random().nextInt(8)+1;}//设置跟元素节点的属性student.setAttribute("id",id);//将根元素节点添加到根节点中root.addContent(student);//声明一个姓名的数组String nameList[] = {"吕布","赵云","马超","张飞","关羽","许褚","孙策","周瑜","夏侯渊","张颌","于禁","黄忠","典韦","曹仁","程普"};String sexList[] = {"男","女"};//创建元素节点Element name = new Element("name");Element sex = new Element("sex");Element age =new Element("age");Element phone = new Element("phone");//设置根元素节点的文本值name.setText(nameList[newRandom().nextInt(nameList.length)]);sex.setText(sexList[new Random().nextInt(sexList.length)]);age.setText(new Random().nextInt(20)+20+"");String tel ="";for(int k = 0; k< 7 ; k++ ){tel += new Random().nextInt(9);}phone.setText("0756-"+tel);//将元素节点添加到根元素节点中student.addContent(name);student.addContent(sex);student.addContent(age);student.addContent(phone);}//设置XML输出排版Format format = Format.getPrettyFormat();XMLOutputter out = new XMLOutputter(format);//输出XML文件out.output(document, new FileOutputStream(xmlpath));}//解析XML文档@SuppressWarnings("rawtypes")public static void resolving() throws Exception{//获取XML解析器SAXBuilder builder = new SAXBuilder();//获取document对象Document doucment = builder.build(xmlpath);//获取根节点Element students = doucment.getRootElement();//获取根元素节点List studentList = students.getChildren("student");//循环获取元素文本值,第一种方法for(int i = 0 ; i< studentList.size() ; i++ ){Element student = (Element)studentList.get(i);System.out.println("id ="+student.getAttributeValue("id")+" name = "+student.getChildText("name")+" sex = "+student.getChildText("sex")+" age = "+student.getChildText("age")+" phone = "+student.getChildText("phone"));}System.err.println("\n---------------------------------------------------------------------");//循环获取元素文本值,第二种方法for(Iterator iter=studentList.iterator();iter.hasNext();){ Element student = (Element)iter.next();System.out.println("id ="+student.getAttributeValue("id")+" name = "+student.getChildText("name")+" sex = "+student.getChildText("sex")+" age = "+student.getChildText("age")+" phone = "+student.getChildText("phone"));}}}3、第三种用dom4j解析package dom4j;import java.io.File;import java.io.FileWriter;import java.util.Iterator;import java.util.List;import java.util.Random;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;public class dom4j {private static String xmlpath = "dom4j.xml";public static void main(String[] args)throws Exception{//createXml();resolving();}public static void createXml() throws Exception{//创建document对象Document document = DocumentHelper.createDocument();//创建根节点Element root = DocumentHelper.createElement("studnets");//将根节点添加到document对象中document.setRootElement(root);for(int i = 0 ;i < 20 ; i++){//创建根元素节点并将根元素节点添加到根节点中Element student = root.addElement("student");//设置根元素节点的值//声明参数IDString id ="";//循环生成一个9为的随机ID数for(int j = 0; j< 9 ; j ++ ){id += new Random().nextInt(8)+1;}student.addAttribute("id",id);//创建元素节点并将元素节点添加到根元素节点中Element name = student.addElement("name");Element sex = student.addElement("sex");Element age = student.addElement("age");Element phone = student.addElement("phone");//声明一个姓名的数组String nameList[] = {"吕布","赵云","马超","张飞","关羽","许褚","孙策","周瑜","夏侯渊","张颌","于禁","黄忠","典韦","曹仁","程普"};String sexList[] = {"男","女"};//设置元素节点的文本值name.setText(nameList[newRandom().nextInt(nameList.length)]);sex.setText(sexList[new Random().nextInt(sexList.length)]);age.setText(new Random().nextInt(20)+20+"");String tel ="";for(int k = 0; k< 7 ; k++ ){tel += new Random().nextInt(9);}phone.setText("0756-"+tel);}//设置XML文件输出的格式OutputFormat format = new OutputFormat("\t", true);format.setEncoding("utf-8");XMLWriter xmlWriter = new XMLWriter(new FileWriter(xmlpath), format);//输出XML文件xmlWriter.write(document);xmlWriter.close();}//解析XML文件@SuppressWarnings("rawtypes")public static void resolving() throws Exception{//获取XML解析器SAXReader saxReader = new SAXReader();//获取document对象Document document = saxReader.read(new File(xmlpath));//获取根节点Element root = document.getRootElement();//获取根元素节点List chindList = root.elements();//循环获取元素文本值,第一种方法for(Iterator iter = chindList.iterator(); iter.hasNext();){ Element student =(Element)iter.next();System.out.println("id = "+student.attributeValue("id")+" name = "+student.elementText("name")+" sex = "+student.elementText("sex")+" age = "+student.elementText("age")+" phone = "+student.elementText("phone"));}System.err.println("\n---------------------------------------------------------------------");//循环获取元素文本值,第二种方法for(int i = 0 ; i< chindList.size() ; i++ ){Element student = (Element)chindList.get(i);System.out.println("id = "+student.attributeValue("id")+" name = "+student.elementText("name")+" sex = "+student.elementText("sex")+" age = "+student.elementText("age")+" phone = "+student.elementText("phone"));}}}。

XML的四种解析器原理及性能比较

XML的四种解析器原理及性能比较

XML的四种解析器原理及性能比较XML(可扩展标记语言)是一种非常常见的数据交换格式,用于在应用程序之间传递和存储数据。

在处理XML数据时,需要使用解析器来读取和解析XML文档。

下面将介绍XML的四种解析器的原理和性能比较。

1. DOM解析器(Document Object Model Parser):DOM解析器将整个XML文档加载到内存中,并将其表示为一个树形结构,每个节点都对应XML文档中的一个元素或属性。

解析器可以通过遍历这个树形结构来访问和操作XML数据。

由于将整个文档加载到内存中,DOM解析器所需的内存较大,适合处理比较小的XML文档。

虽然性能较差,但它提供了灵活的访问和操作XML数据的方法。

2. SAX解析器(Simple API for XML Parser):3. StAX解析器(Streaming API for XML Parser):StAX解析器是一种混合了DOM和SAX解析器的解析器,它允许开发人员以推拉模型访问XML数据。

开发人员可以使用迭代器的形式遍历XML文档,并根据需要拉取或推送事件。

StAX解析器的内存需求较低,同时也具备灵活的操作XML数据的能力。

4. JAXB解析器(Java Architecture for XML Binding):JAXB解析器是一种用于将XML数据绑定到Java对象的解析器。

它可以将XML文档中的元素和属性映射到具体的Java类和对象上,并提供了将Java对象序列化为XML的能力。

相比于前三种解析器,JAXB解析器需要定义Java类和XML的映射关系,稍微复杂一些。

但它提供了方便的对象操作方式,可以更加简洁地处理XML数据。

对于解析性能的比较,DOM解析器的性能最差,因为它需要将整个XML文档加载到内存中。

对于大型XML文档,DOM解析器可能会导致内存不足的问题。

SAX解析器和StAX解析器的性能较好,因为它们是基于事件驱动的解析器,可以逐行读取XML文档,无需将整个文档加载到内存中。

dom4j解析XML文档

dom4j解析XML文档

将dom4j-1.6.1.jar添加到系统CLASSPATH环境变量中
Dom4j常用的API 【重点掌握】
Element Branch Document
Cloneable
Node
Attribute
DocumentType
CharacterData
ProcessingInstruction
CDATA
<list> <book>疯狂XML讲义</book> <game>扫雷</game> <sport>乒乓球</sport> </list>
在获取<list…/>节点之后,如果希望获取它包含的3个子节点的数 节点之后,如果希望获取它包含的 个子节点的数 在获取 节点之后 据,需要使用如下代码
//获取list元素下的所有子元素 NodeList itemList=list.getChildNodes(); //遍历每个子元素 for(int I=0;I<itemList.getLength();I++){ System.out.println(itemList.item(j).getTextContent().trim()); }
Vistor接口的方法
visit(Attribute node) visit(CDATA node)
简单说明
当Visitor对象访问属性节点时将回调该方法 当Visitor对象访问CDATA片段时将回调该方法 当Visitor对象访问注释节点时将回调该方法 当Visitor对象访问文档根节点时将回调该方法 当Visitor对象访问DTD内容将回调该方法 当Visitor对象访问元素节点将回调该方法 当Visitor对象访问Entity节点将回调该方法 当Visitor对象访问命名空间时回调该方法 当Visitor对象访问处理指令时回调该方法 当Visitor对象访问文档内容时将回调该方法

java 解析xml字符串 简书

java 解析xml字符串 简书

在Java中解析XML字符串可以使用多种方法,其中最常见的是使用Java内置的DOM、SAX和StAX API。

1.DOM解析器DOM解析器将XML文档转换为树形结构,并允许您通过编程方式遍历和操作该树形结构。

以下是一个简单的示例,演示如何使用DOM解析器解析XML字符串:java复制代码import javax.xml.parsers.DocumentBuilderFactory;import javax.xml.parsers.DocumentBuilder;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.NodeList;public class DOMExample {public static void main(String[] args)throws Exception {String xmlString = "<root><element>text</element></root>";DocumentBuilderFactory factory =DocumentBuilderFactory.newInstance();DocumentBuilder builder = factory.newDocumentBuilder();Document document = builder.parse(new InputSource(newStringReader(xmlString)));document.getDocumentElement().normalize();System.out.println("Root element: " +document.getDocumentElement().getNodeName());NodeList nodeList = document.getElementsByTagName("element");for (int i = 0; i < nodeList.getLength(); i++) {Element element = (Element) nodeList.item(i);System.out.println("Element: " + element.getTextContent());}}}2.SAX解析器SAX解析器是一种基于事件的解析器,它按顺序读取XML文档,并在读取每个元素时触发事件。

java解析xml详解及示例

java解析xml详解及示例

java解析xml详解及示例java 解析xml的几种方法第一种:DOMDOM的全称是Document Object Model,也即文档对象模型。

在应用程序中,基于DOM 的XML分析器将一个XML文档转换成一个对象模型的集合(通常称DOM树),应用程序正是通过对这个对象模型的操作,来实现对XML文档数据的操作。

通过DOM接口,应用程序可以在任何时候访问XML文档中的任何一部分数据,因此,这种利用DOM接口的机制也被称作随机访问机制。

DOM接口提供了一种通过分层对象模型来访问XML文档信息的方式,这些分层对象模型依据XML的文档结构形成了一棵节点树。

无论XML文档中所描述的是什么类型的信息,即便是制表数据、项目列表或一个文档,利用DOM所生成的模型都是节点树的形式。

也就是说,DOM强制使用树模型来访问XML文档中的信息。

由于XML本质上就是一种分层结构,所以这种描述方法是相当有效的。

DOM树所提供的随机访问方式给应用程序的开发带来了很大的灵活性,它可以任意地控制整个XML文档中的内容。

然而,由于DOM 分析器把整个XML文档转化成DOM树放在了内存中,因此,当文档比较大或者结构比较复杂时,对内存的需求就比较高。

而且,对于结构复杂的树的遍历也是一项耗时的操作。

所以,DOM分析器对机器性能的要求比较高,实现效率不十分理想。

不过,由于DOM分析器所采用的树结构的思想与XML 文档的结构相吻合,同时鉴于随机访问所带来的方便,因此,DOM分析器还是有很广泛的使用价值的。

Java代码import java.io.File;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Document;import org.w3c.dom.Element;import org.w3c.dom.NodeList;public class DomT est1{public static void main(String[] args) throws Exception{// step 1: 获得dom解析器工厂(工作的作用是用于创建具体的解析器)DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();// System.out.println("class name: " + dbf.getClass().getName());// step 2:获得具体的dom解析器DocumentBuilder db = dbf.newDocumentBuilder();// System.out.println("class name: " + db.getClass().getName());// step3: 解析一个xml文档,获得Document对象(根结点)Document document = db.parse(new File("candidate.xml"));NodeList list = document.getElementsByTagName("PERSON");for(int i = 0; i < list.getLength(); i++){Element element = (Element)list.item(i);String content =element.getElementsByTagName("NAME").item(0).getFirstC hild().getNodeValue();System.out.println("name:" + content);content =element.getElementsByTagName("ADDRESS").item(0).getFir stChild().getNodeValue(); System.out.println("address:" + content);content =element.getElementsByTagName("TEL").item(0).getFirstChil d().getNodeValue();System.out.println("tel:" + content);content =element.getElementsByTagName("FAX").item(0).getFirstChil d().getNodeValue();System.out.println("fax:" + content);content =element.getElementsByTagName("EMAIL").item(0).getFirstC hild().getNodeValue();System.out.println("email:" + content);System.out.println("--------------------------------------");}}}Java代码import java.io.File;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;import org.w3c.dom.Attr;import /doc/723478280.html,ment;import org.w3c.dom.Document;import org.w3c.dom.Element;import/doc/723478280.html,dNodeMap;import org.w3c.dom.Node;import org.w3c.dom.NodeList;/*** 使用递归解析给定的任意一个xml文档并且将其内容输出到命令行上* @author*/public class DomT est3{public static void main(String[] args) throws Exception{DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();DocumentBuilder db = dbf.newDocumentBuilder();Document doc = db.parse(new File("student.xml"));//获得根元素结点Element root = doc.getDocumentElement();parseElement(root);}private static void parseElement(Element element){String tagName = element.getNodeName();NodeList children = element.getChildNodes();System.out.print("<" + tagName);//element元素的所有属性所构成的NamedNodeMap对象,需要对其进行判断 NamedNodeMap map = element.getAttributes();//如果该元素存在属性if(null != map){{//获得该元素的每一个属性Attr attr = (Attr)map.item(i);String attrName = attr.getName();String attrValue = attr.getValue();System.out.print(" " + attrName + "=\"" + attrValue + "\""); } }System.out.print(">");for(int i = 0; i < children.getLength(); i++){Node node = children.item(i);//获得结点的类型short nodeType = node.getNodeType();if(nodeType == Node.ELEMENT_NODE){//是元素,继续递归parseElement((Element)node);}else if(nodeType == Node.TEXT_NODE){//递归出口System.out.print(node.getNodeValue());}else if(nodeType == /doc/723478280.html,MENT_NODE) {System.out.print("System.out.print(data);System.out.print("-->");}}System.out.print("");}}第二种 sax:SAX的全称是Simple APIs for XML,也即XML简单应用程序接口。

Dom4J、JDOM、DOM、SAX和Pull技术解析XML文件

Dom4J、JDOM、DOM、SAX和Pull技术解析XML文件

解析XML文件的五种技术1.1SAX技术SAX处理的优点非常类似于流媒体的优点。

分析能够立即开始,而不是等待所有的数据被处理。

而且,由于应用程序只是在读取数据时检查数据,因此不需要将数据存储在内存中。

这对于大型文档来说是个巨大的优点。

事实上,应用程序甚至不必解析整个文档;它可以在某个条件得到满足时停止解析。

一般来说,SAX还比它的替代者DOM快许多。

选择DOM还是选择SAX?对于需要自己编写代码来处理XML文档的开发人员来说,选择DOM 还是SAX解析模型是一个非常重要的设计决策。

DOM采用建立树形结构的方式访问XML文档,而SAX采用的事件模型。

DOM解析器把XML文档转化为一个包含其内容的树,并可以对树进行遍历。

用DOM解析模型的优点是编程容易,开发人员只需要调用建树的指令,然后利用navigation APIs访问所需的树节点来完成任务。

可以很容易的添加和修改树中的元素。

然而由于使用DOM解析器的时候需要处理整个XML文档,所以对性能和内存的要求比较高,尤其是遇到很大的XML文件的时候。

由于它的遍历能力,DOM解析器常用于XML文档需要频繁的改变的服务中。

SAX解析器采用了基于事件的模型,它在解析XML文档的时候可以触发一系列的事件,当发现给定的tag的时候,它可以激活一个回调方法,告诉该方法制定的标签已经找到。

SAX对内存的要求通常会比较低,因为它让开发人员自己来决定所要处理的tag.特别是当开发人员只需要处理文档中所包含的部分数据时,SAX这种扩展能力得到了更好的体现。

但用SAX解析器的时候编码工作会比较困难,而且很难同时访问同一个文档中的多处不同数据。

1.1.1 SAX语法简介SAX是一个解析速度快并且占用内存少的xml解析器,非常适合用于Android等移动设备。

SAX 解析XML文件采用的是事件驱动,也就是说,它并不需要解析完整个文档,在按内容顺序解析文档的过程中,SAX会判断当前读到的字符是否合法XML语法中的某部分,如果符合就会触发事件。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

学习:Dom4j1、DOM4J简介DOM4J是 出品的一个开源XML 解析包。

DOM4J应用于Java 平台,采用了Java 集合框架并完全支持DOM,SAX 和JAXP。

DOM4J 使用起来非常简单。

只要你了解基本的XML-DOM 模型,就能使用。

Dom:把整个文档作为一个对象。

DOM4J 最大的特色是使用大量的接口。

它的主要接口都在org.dom4j里面定义:接口之间的继承关系如下:interface ng.Cloneableinterface org.dom4j.Nodeinterface org.dom4j.Attributeinterface org.dom4j.Branchinterface org.dom4j.Documentinterface org.dom4j.Elementinterface org.dom4j.CharacterDatainterface org.dom4j.CDATAinterface mentinterface org.dom4j.Textinterface org.dom4j.DocumentTypeinterface org.dom4j.Entityinterface org.dom4j.ProcessingInstruction2、XML文档操作12.1、读取XML文档:读写XML文档主要依赖于org.dom4j.io包,有DOMReader和SAXReader两种方式。

因为利用了相同的接口,它们的调用方式是一样的。

public static Docum ent load(String filenam e) {Document docum ent =null;try {SAXReader saxReader = new SAXReader();docum ent =saxReader.read(new File(filename)); //读取XML文件,获得docum ent 对象} catch (Exception ex) {ex.printStackTrace();}return docum ent;}或public static Docum ent load(URL url) {Document docum ent =null;try {SAXReader saxReader = new SAXReader();docum ent =saxReader.read(url); //读取XML文件,获得docum ent对象} catch (Exception ex) {ex.printStackTrace();}return docum ent;}//读取指定的xml文件之后返回一个Document对象,这个对象代表了整个XML文档,用于各种Do m运算。

执照XML文件头所定义的编码来转换。

2.2、获取根节点根节点是xml分析的开始,任何xml分析工作都需要从根开始Xml xml =new Xml();Document dom= xml.load(path +"/" +file);Element root =dom.getRootElement();2.3、. 新增一个节点以及其下的子节点与数据Element m enuElement =root.addElement("m enu");Element engNameElement =menuElement.addElement("engName"); engNameElement.setText(catNam eEn);Element chiNameElement =m enuElement.addElement("chiName"); chiNameElement.setText(catNam e);2.4、写入XML文件注意文件操作的包装类是乱码的根源public static boolean doc2XmlFile(Document document, String filename) {boolean flag = true;try {XMLWriter writer = new XMLWriter( new OutputStreamWriter(new FileOutp utStream(filename),"UTF-8"));writer.write(document);writer.close();} catch (Exception ex) {flag = false;ex.printStackTrace();}System.out.println(flag);return flag;}Dom4j通过XMLWriter将Document对象表示的XML树写入指定的文件,并使用OutputFormat格式对象指定写入的风格和编码方法。

调用OutputFormat.c reatePrettyPrint()方法可以获得一个默认的pretty print风格的格式对象。

对OutputFormat对象调用setEncoding()方法可以指定XML文件的编码方法。

public void writeTo(OutputStream out, String encoding) throws Unsuppo rtedEncodingException, IOException {OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("gb2312");XMLWriter writer = new XMLWriter(System.out,format);writer.write(doc);writer.flush();return;}2. 5、遍历xml节点对Docum ent对象调用get RootElement()方法可以返回代表根节点的Element对象。

拥有了一个Element对象后,可以对该对象调用elem entIterator()方法获得它的子节点的E lement对象们的一个迭代器。

使用(Element)iterator.next()方法遍历一个iterator并把每个取出的元素转化为Element类型。

public boolean isOnly(String catNameEn,HttpServletRequest request,Str ing xml) {boolean flag = true;String path = request.getRealPath("");Document doc = load(path+"/"+xml);Element root = doc.getRootElement();for (Iterator i = root.elementIterator(); i.hasNext();) {Element el = (Element) i.next();if(catNameEn.equals(el.elementTextTrim("engName"))){flag = false;break;}}return flag;}2.6、创建xml文件public static void m ain(String args[]){String fileName="c:/text.xml";Document docum ent=Docum entHelper.createDocument();//建立document对象,用来操作xml文件Element booksElement=docum ent.addElement("books");//建立根节点booksElement.addComment("This is a test for dom4j ");//加入一行注释Element bookElement=booksElement.addElement("book");//添加一个book节点bookElement.addAttribute("show","yes");//添加属性内容Element titleElement=bookElement.addElement("title");//添加文本节点titleElement.setText("ajax in action");//添加文本内容try{XMLWriter writer=new XMLWriter(new FileWriter(new File(fileName)));writer.write(docum ent);writer.close();}catch(Exception e){e.printStackTrace();}}2.7、修改节点属性public static void m odifyXMLFile() {String oldStr = "c:/text.xm l";String newStr ="c:/text1.xml";Document docum ent =null;//修改节点的属性try{SAXReader saxReader = new SAXReader(); // 用来读取xml文档docum ent =saxReader.read(new File(oldStr)); // 读取xml文档List list =docum ent.selectNodes("/books/book/@show");// 用xpath查找节点boo k的属性Iterator iter =list.iterator();while(iter.hasNext()) {Attribute attribute =(Attribute) iter.next();if(attribute.getValue().equals("yes"))attribute.setValue("no");}} catch(Exception e) {e.printStackTrace();}//修改节点的内容try{SAXReader saxReader = new SAXReader(); // 用来读取xml文档docum ent =saxReader.read(new File(oldStr)); // 读取xml文档List list =docum ent.selectNodes("/books/book/title");// 用xpath查找节点book的内容Iterator iter =list.iterator();while(iter.hasNext()) {Element element =(Element) iter.next();elem ent.setText("xxx");// 设置相应的内容}} catch(Exception e) {e.printStackTrace();}try{XMLWriter writer =new XMLWriter(new FileWriter(new File(newStr))); writer.write(docum ent);writer.close();} catch(Exception ex) {ex.printStackTrace();}}2.8、删除节点public static void removeNode() {String oldStr = "c:/text.xm l";String newStr ="c:/text1.xml";Document docum ent =null;try{SAXReader saxReader = new SAXReader();// 用来读取xml文档docum ent =saxReader.read(new File(oldStr));// 读取xml文档List list =docum ent.selectNodes("/books/book");// 用xpath查找对象Iterator iter =list.iterator();while(iter.hasNext()) {Element bookElement =(Element) iter.next();// 创建迭代器,用来查找要删除的节点,迭代器相当于指针,指向book下所有的title节点Iterator iterator =bookElem ent.elem entIterator("title");while(iterator.hasNext()) {Element titleElement =(Element) iterator.next();if(titleElement.getText().equals("ajax in action")) {bookElement.remove(titleElement);}}}} catch(Exception e) {e.printStackTrace();}try{XMLWriter writer =new XMLWriter(new FileWriter(new File(newStr))); writer.write(docum ent);writer.close();} catch(Exception ex) {ex.printStackTrace();}}2、XML文档操作22.1、Document对象相关1、读取XML文件,获得document对象.SAXReader reader = new SAXReader();Document document = reader.read(new File("input.xml"));2、解析XML形式的文本,得到document对象.String text = "<members></members>";Document document = DocumentHelper.parseText(text);3、主动创建document对象.Document document = DocumentHelper.createDocument ();Element root = document.addElement("members");// 创建根节点2.2、节点相关1、获取文档的根节点.Element rootElm = document.getRootElement();2、取得某节点的单个子节点.Element memberElm=root.element("member");// "member"是节点名3.取得节点的文字String text=memberElm.getText();String text=root.elementText("name");这个是取得根节点下的name字节点的文字.4.取得某节点下指定名称的所有节点并进行遍历.List nodes = rootElm.elements("member");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 ageElm = newMemberElm.addElement("age");7.设置节点文字.ageElm.setText("29");8.删除某节点.parentElm.remove(childElm); // childElm是待删除的节点,parentElm是其父节点9.添加一个CDATA节点.Element contentElm = infoElm.addElement("content"); contentElm.addCDATA(diary.getContent());2.3、属性相关.1.取得节点的指定的属性Element root=document.getRootElement();Attribute attribute=root.attribute("size"); // 属性名name2.取得属性的文字String text=attribute.getText();String text2=root.element("name").attributeValue("firstname");//这个是取得根节点下name字节点的firstname属性的值.3.遍历某节点的所有属性Element root=document.getRootElement();for(Iterator it=root.attributeIterator();it.hasNext();){Attribute attribute = (Attribute) it.next();String text=attribute.getText();System.out.println(text);}4.设置某节点的属性和文字.newMemberElm.addAttribute("name", "sitinspring");5.设置属性的文字Attribute attribute=root.attribute("name");attribute.setText("sitinspring");6.删除某属性Attribute attribute=root.attribute("size");// 属性名nam eroot.remove(attribute);2.4、将文档写入XML文件.1.文档中全为英文,不设置编码,直接写入.XMLWriter writer = new XMLWriter(new FileWriter("output.xml")); writer.write(document);writer.close();2.文档中含有中文,设置编码格式再写入.OutputFormat format = OutputFormat.createPrettyPrint();format.setEncoding("GBK"); // 指定XML编码XMLWriter writer = new XMLWriter(new FileWriter("output.xml"),forma t);writer.write(document);writer.close();2.5、字符串与XML的转换1.将字符串转化为XMLString text = "<members> <member>sitinspring</member> </members>";Document document = DocumentHelper.parseText(text);2.将文档或节点的XML转化为字符串.SAXReader reader = new SAXReader();Document document = reader.read(new File("input.xml"));Element root=document.getRootElement();String docXmlText=document.asXML();String rootXmlText=root.asXML();Element memberElm=root.element("member");String memberXmlText=memberElm.asXML();3、dom4j的事件处理模型涉及的类和接口:3.1、类:SAXReaderpublic void addHandler(String path,Elem entHandler handler)当解析到path指定的路径时,将调用参数handler指定的处理器。

相关文档
最新文档