Java解析XML汇总

合集下载

java_Dom4j解析XML详解

学习：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运算。

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 xmlparser用法

文章标题：深入探讨Java XML解析器的使用方法与技巧一、引言：解析XML在Java中的重要性XML作为一种可扩展的标记语言，被广泛应用于数据交换和存储的场景中。

在Java开发中，对XML的解析是一项非常常见的任务，它涉及到从XML文档中提取数据、修改数据以及创建新的XML文档等方面。

对于Java开发者来说，掌握XML解析器的使用方法与技巧是非常重要的。

二、Java中常见的XML解析器介绍在Java中，常见的XML解析器主要包括DOM解析器、SAX解析器和StAX解析器。

下面将针对这三种解析器进行详细介绍，并分别分析它们的优缺点和适用场景。

1. DOM解析器DOM（Document Object Model）解析器将整个XML文档解析成内存中的一个树形结构，因此适合于对XML文档进行随机访问和修改。

但是，由于DOM解析器需要将整个文档加载到内存中，对于大型XML文档来说，可能会占用过多的内存，因此不适合对大型XML文档进行解析。

2. SAX解析器SAX（Simple API for XML）解析器是一种基于事件驱动的解析器，它逐行解析XML文档，只在遇到标签开始、标签结束和文本内容时触发相应的事件，从而大大减小了内存开销。

SAX解析器适合用于对大型XML文档进行顺序读取和简单处理。

3. StAX解析器StAX（Streaming API for XML）解析器是一种基于迭代器的解析器，它允许开发者以类似流的方式读写XML文档，同时也支持部分随机访问功能。

由于StAX解析器结合了DOM和SAX解析器的优点，因此在某些场景下可以取得很好的效果。

三、Java中使用XML解析器的常见场景和技巧1. 选择合适的解析器在实际开发中，选择合适的解析器非常重要。

如果需要对XML文档进行较为复杂的处理，并且内存资源充足，那么可以选择DOM解析器；如果需要对大型XML文档进行顺序读取和简单处理，那么可以选择SAX解析器；如果需要兼顾随机访问和内存占用的平衡，那么可以选择StAX解析器。

Java动态生成和解析xml文件步骤详解

Java动态⽣成和解析xml⽂件步骤详解⾸先声明，这个地⽅是利⽤dom4j进⾏解析和⽣成，需要⽤到dom4j的jar包，所以⾸先需要我们获取jar包：<dependency><groupId>dom4j</groupId><artifactId>dom4j</artifactId><version>1.6.1</version></dependency>⽣成xml⽂件代码案列：package day12;import java.io.FileOutputStream;import java.util.ArrayList;import java.util.List;import org.dom4j.Document;import org.dom4j.DocumentHelper;import org.dom4j.Element;import org.dom4j.io.OutputFormat;import org.dom4j.io.XMLWriter;/*** 写出XML⽂档*/public class WriteXmlDemo {public static void main(String[] args) {List<Emp> empList = new ArrayList<Emp>();empList.add(new Emp(1,"张三",22,"男",3000));empList.add(new Emp(2,"李四",23,"⼥",4000));empList.add(new Emp(3,"王五",24,"男",5000));empList.add(new Emp(4,"赵六",25,"⼥",6000));empList.add(new Emp(5,"钱七",26,"男",7000));empList.add(new Emp(6,"传奇",21,"男",8000));/** 写出XML⽂档的⼤致步骤* 1.创建空⽩⽂档对象Document* 2.向该⽂档中添加根元素* 3.按照规定的XML⽂档结构从根元素开始，逐级添加⼦元素，已完成该结构* 4.创建XMLWriter* 5.将Document对象写出成XML⽂档* 6.将XMLWriter关闭*///1Document doc = DocumentHelper.createDocument();/** 2.Element addElement(String name)* Document提供的该⽅法是⽤来向当前⽂档中添加给定名字的根元素。

java xml标签详解

java xml标签详解在Java中处理XML通常涉及XML文档和它们之间的结构、元素、属性和文本。

在XML文档中，元素是内容的边界，而属性是附加到元素上的键值对。

以下是一些基本的XML标签概念：1.元素（Element）: XML元素是由开始标签、结束标签（有些元素可能没有结束标签）和元素之间的内容组成的。

例如，<name>John Doe</name>。

2.开始标签（Start Tag）: 开始标签用于标记元素的开始，例如<name>。

3.结束标签（End Tag）: 结束标签用于标记元素的结束，并使用/符号来表示。

例如</name>。

4.空元素（Empty Element）: 空元素只有一个开始标签，没有结束标签。

例如<br/>。

5.属性（Attribute）: 属性是附加到元素上的键值对。

它们在开始标签中定义，由键值对的形式出现（key="value"）。

例如<element attribute="value">。

6.文本（Text）: 文本是元素之间的内容，例如<name>John Doe</name>中的 "John Doe"。

7.命名空间（Namespace）: 命名空间用于区分具有相同名称的元素或属性。

它们通常在开始标签中定义，例如<element xmlns="namespaceURI">。

8.CDATA（Character Data）: CDATA用于包含可能被解析为XML标记的文本。

例如，如果您有一个包含大量HTML的XML元素，您可以使用CDATA来避免HTML被解析为XML。

示例：<![CDATA[Some text <em>more text</em>]]>。

java使用document解析xml文件

java使⽤document解析xml⽂件准备⼯作：1创建java⼯程2创建xml⽂档。

完成后看下⾯代码：import org.w3c.dom.*;import javax.xml.parsers.DocumentBuilder;import javax.xml.parsers.DocumentBuilderFactory;public class Main {public static void main(String[] args) throws Exception {//创建⼀个⽂档解析器⼯⼚DocumentBuilderFactory fac= DocumentBuilderFactory.newInstance();//⽤上⾯的⼯⼚创建⼀个⽂档解析器DocumentBuilder builder=fac.newDocumentBuilder();//⽤上⾯的⽂档解析器解析⼀个⽂件放到document对象⾥Document doc=builder.parse("src/server.xml");//获取⽂档中节点名称为Listener的所有节点，并返回⼀个节点集合NodeList listenerList=doc.getElementsByTagName("Listener");System.out.println("⼀共有"+listenerList.getLength()+"个节点");//遍历整个集合(把所有标签名为Listener的节点⼀个⼀个拿出来for (int i=0;i<listenerList.getLength();i++){System.out.println("===========这是第"+(i+1)+"个listener节点的开始:===========");//把集合⾥的每⼀个listener节点分别拿出来Node node=listenerList.item(i);//再把上⼀个节点中的所有属性拿出来NamedNodeMap nodeMap= node.getAttributes();System.out.println("第"+(i+1)+"个节点⼀共有"+nodeMap.getLength()+"个属性");//遍历所有属性for(int j=0;j<nodeMap.getLength();j++){Node node1=nodeMap.item(j);System.out.println("第"+(j+1)+"个属性的名称是"+node1.getNodeName());System.out.println("第"+(j+1)+"个属性的值是"+node1.getNodeValue());}//获取节点的所有⼦节点，注意会把所有换⾏符也解析为⼦节点NodeList childNode=node.getChildNodes();//遍历所有⼦节点for(int k=0;k<childNode.getLength();k++){if(childNode.item(k).getNodeType()==Node.ELEMENT_NODE){//这个过滤条件是只将标签节点保留（换⾏符的节点就删去）}System.out.println("===========这是第"+(i+1)+"个节点的结束:===========");}}}为了⽅便记忆，在这⾥拆解⼀下。

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⽂件的时候。

在Java中使用xpath对xml解析

在Java中使⽤xpath对xml解析个⼈博客地址：xpath是⼀门在xml⽂档中查找信息的语⾔。

xpath⽤于在XML⽂档中通过元素和属性进⾏导航。

它的返回值可能是节点，节点集合，⽂本，以及节点和⽂本的混合等。

在学习本⽂档之前应该对XML的节点，元素，属性，⽂本，处理指令，注释，根节点，命名空间以及节点关系有⼀定的了解以及对xpath也有了解。

XML学习地址：xpath基本语法学习地址：xpath官⽅⽂档：https:///cvc4tEIGy5EvS访问密码 9d16本⽂主要介绍：Java中使⽤xpath操作对xml操作。

1）⾸先在dom4j中如何使⽤xpath技术导⼊xPath⽀持的jar包。

jaxen-1.1-beta-6.jar(⾸先要先导⼊dom4j包，dom4j下载地址：/dom4j-1.6.1/)。

导包之后如图所⽰：如果不知道怎样导包请参考我以前的⼀篇博客：2）在Java中使⽤xpath⽅法，主要有两点：List<Node> selectNodes("xpath表达式"); 查询多个节点对象Node selectSingleNode("xpath表达式"); 查询⼀个节点对象下⾯就⽤实例说明使⽤⽅法。

⼀、selectNodes使⽤⽅法：1package com.vastsum.demo;23import java.io.File;4import java.io.FileOutputStream;5import java.util.List;67import org.dom4j.Document;8import org.dom4j.Element;9import org.dom4j.Node;10import org.dom4j.io.OutputFormat;11import org.dom4j.io.SAXReader;12import org.dom4j.io.XMLWriter;1314/**15 *16 * @author shutu00817 *selectNode的使⽤⽅法18*/19public class xpathDemo {2021public static void main(String[] args) throws Exception {2223 Document doc = new SAXReader().read(new File("./src/contact.xml"));2425/**26 * @param xpath 表⽰xpath语法变量27*/28 String xpath="";2930/**31 * 1. / 绝对路径表⽰从xml的根位置开始或⼦元素（⼀个层次结构）32*/33 xpath = "/contactList";34 xpath = "/contactList/contact";3536/**37 * 2. // 相对路径表⽰不分任何层次结构的选择元素。

java注解生成xml和包含CDATA问题

java注解⽣成xml和包含CDATA问题百度java⽣成xml，有⼀⼤推的⽂章，主要的⽣成⽅式⼀种使⽤Dom4J ,还有⼀种使⽤Jdk⾃带注解类！下⾯主要整理我注解类的使⽤，（可以参考这篇⽂章）和xml中CDATA 问题的解决⽅法！1:要⽣成的xml原始⽂件！<?xml version="1.0" encoding="utf-8"?><item><id>35399645973</id><title><![CDATA[补⽔⾸选⽔密码⽔保湿美⽩护洗护组合三件]]> </title><category><![CDATA[美妆>保湿>洗护]]></category><url><![CDATA[/detail-35399645973]]> </url><url_wap><![CDATA[/de99645973]]> </url_wap><price>310</price><promotion_price>93.8</promotion_price><wap_price>85</wap_price><sub_item_ids><sub_item_id>35399645973_1</sub_item_id><sub_item_id>35399645973_2</sub_item_id><sub_item_id>35399645973_3</sub_item_id>……</sub_item_ids><detail><![CDATA[商品详情，⽀持html图⽂混排]]> </detail><status>1<status><pic_main><img><url><![CDATA[/10777829/T_400x400.jpg]]> </url><size>400x400</size></img></pic_main><pic_extra><img><url><![CDATA[/10777821_400x400.jpg]]> </url><size>400x400</size></img><img><url><![CDATA[/10777822_400x400.jpg]]> </url><size>400x400</size></img></pic_extra ></item>2：xml对应的model类！(1):FanLiProductInofMsg.javaimport java.util.List;import javax.xml.bind.annotation.XmlAttribute;import javax.xml.bind.annotation.XmlElement;import javax.xml.bind.annotation.XmlElementWrapper;import javax.xml.bind.annotation.XmlRootElement;/**** @author aflyun* @date 2016.06.12**/@XmlRootElement(name="item")public class FanLiProductInofMsg {@XmlAttributeprivate String version;@XmlElementprivate String id;@XmlElementprivate String title;@XmlElementprivate String category;@XmlElementprivate String url;//Pc商品的url@XmlElement(name="url_wap")private String urlWap;//Wap商品的url url_wap@XmlElementprivate String price;@XmlElement(name="promotion_price")private String promotionPrice;//promotion_price@XmlElement(name="wap_price")private String wapPrice;//wap_price@XmlElementWrapper(name="sub_item_ids")@XmlElement(name="sub_item_id")private List<String> subItemIds;//sub_item_ids@XmlElementprivate String detail;//detail@XmlElementprivate String status;//status@XmlElementWrapper(name="pic_main")@XmlElement(name="img")private List<Img> mainImg;//pic_main@XmlElementWrapper(name="pic_extra")@XmlElement(name="img")private List<Img> extraImg;//pic_extrapublic void setVersion(String version) {this.version = version;}public void setId(String id) {this.id = id;}public void setTitle(String title) {this.title = title;}public void setCategory(String category) {this.category = category;}public void setUrl(String url) {this.url = url;}public void setUrlWap(String urlWap) {this.urlWap = urlWap;}public void setPrice(String price) {this.price = price;}public void setPromotionPrice(String promotionPrice) { this.promotionPrice = promotionPrice;}public void setWapPrice(String wapPrice) {this.wapPrice = wapPrice;}public void setSubItemIds(List<String> subItemIds) { this.subItemIds = subItemIds;}public void setDetail(String detail) {this.detail = detail;}public void setStatus(String status) {this.status = status;}public void setMainImg(List<Img> mainImg) {this.mainImg = mainImg;}public void setExtraImg(List<Img> extraImg) {this.extraImg = extraImg;}}(2):Img .javaimport javax.xml.bind.annotation.XmlElement;import javax.xml.bind.annotation.XmlRootElement;/**** @author aflyun* @date 2016.06.12**/@XmlRootElementpublic class Img {@XmlElement(name="url")private String url;@XmlElement(name="size")private String size;public void setUrl(String url) {this.url = url;}public void setSize(String size) {this.size = size;}}3：⽣成过程，已经CDATA问题处理！package com.dufy.test.xml;import java.io.ByteArrayOutputStream;import java.io.File;import java.io.FileWriter;import java.io.PrintWriter;import java.util.ArrayList;import java.util.List;import javax.xml.bind.JAXBContext;import javax.xml.bind.Marshaller;import javax.xml.transform.sax.SAXResult;import org.apache.xml.serialize.OutputFormat;import org.apache.xml.serialize.XMLSerializer;import org.junit.Test;import com.kuyu.b2b2c.product.fanli.vo.FanLiProductInofMsg; import com.kuyu.b2b2c.product.fanli.vo.Img;public class JuintXmlTest {private static Marshaller marshal;@Testpublic void testXml() throws Exception {List<String> list = new ArrayList<String>();list.add("11_11_11");list.add("22_22_22");list.add("33_33_33");List<Img> imgList = new ArrayList<Img>();Img img = null;for (int i = 0; i < 2; i++) {img = new Img();img.setUrl("-" + i + "-");img.setSize("40×40");imgList.add(img);}FanLiProductInofMsg fps = new FanLiProductInofMsg();fps.setVersion("1.0");fps.setId("110");fps.setTitle("4K ⾼清");fps.setCategory("电视>4K>⾼清");fps.setUrl("");fps.setUrlWap("");fps.setPrice("100");fps.setPromotionPrice("111");fps.setWapPrice("113");fps.setSubItemIds(list);fps.setDetail("wwwwwwwwwwwwwwwwwwwwwww");fps.setStatus("1");fps.setMainImg(imgList);fps.setExtraImg(imgList);PrintWriter pw = new PrintWriter(new File("D:/test.xml"));String ojbectToXmlWithCDATA = ojbectToXmlWithCDATA(FanLiProductInofMsg.class, fps);System.out.println(ojbectToXmlWithCDATA);pw.println(ojbectToXmlWithCDATA);pw.close();}public static String ojbectToXmlWithCDATA(Class clazz, Object obj) throws Exception {JAXBContext context = JAXBContext.newInstance(clazz);// configure an OutputFormat to handle CDATAOutputFormat of = new OutputFormat();of.setCDataElements(new String[] { "^title", //"^category","^url","^url_wap","^detail"}); //// set any other options you'd likeof.setPreserveSpace(true);of.setIndenting(true);// create the serializerByteArrayOutputStream op = new ByteArrayOutputStream();XMLSerializer serializer = new XMLSerializer(op, of);SAXResult result = new SAXResult(serializer.asContentHandler());Marshaller mar = context.createMarshaller();mar.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);mar.marshal(obj, result);return op.toString("utf-8");}}setCDataElements 这⾥⾯你标注需CDATA 的字段！上⾯的这个例⼦可以直接拷贝运⾏，⽹上还⼀些其他的⽅法⽣成xml和CDATA，如果你有好的⽅法，欢迎分享给我，谢谢！4:参考⽂章（1）：（2）：（3）：欢迎访问我的csdn博客，我们⼀同成长！。

Java中XML解析工具范例

Java中XML解析⼯具范例1.直接代码部分：1import java.io.File;2import java.io.FileInputStream;3import java.util.List;4import org.jdom.Document;5import org.jdom.Element;6import org.jdom.input.SAXBuilder;7import org.xml.sax.InputSource;89/**10 * 作⽤: XML解析⼯具类,其中的属性根据⾃⼰需要另⾏添加或者更改11 *12*/13public class ReadFileContent14 {15static FileInputStream ins;1617public static String trxId; //⽂件id18public static String trxBank; //银⾏编码19public static String trxOper; //20public static String trxDate; //数据⽇期21public static String PkgNo; //包号22public static String fileCode; //⽂件编码23public static String fileName; //⽂件类型24public static String fileContent; //⽂件内容252627public static void PullConfigXml(String path)28 {29 ("开始读取配置⽂件...");30try {31 File file=null;32//本地测试路径 /home/ngpcom/dfgz/config33//String path=System.getProperty("user.home")+file.separator+"dfgz"+file.separator+"config"+file.separator+"config1.xml"; 34//String path =System.getProperty("user.home")+file.separator+"config"+file.separator+"config1.xml";35 ("配置⽂件的路径["+path+"]");36 ins = new FileInputStream(new File( path));37 } catch (Exception e) {38 Log4jBean.logger.error("读取配置⽂件异常，异常信息为：【" + e.getMessage() + "】");39 }40 ("读取配置⽂件成功，开始解析xml⽂档");4142// 创建新的输⼊源SAX 解析器将使⽤ InputSource 对象来确定如何读取 XML输⼊,此处为⽂件流43 InputSource source = new InputSource(ins);44// 创建⼀个新的SAXBuilder45 SAXBuilder saxbBuilder = new SAXBuilder();46try {47// 通过输⼊源构造⼀个Document48 Document doc = saxbBuilder.build(source);49// 取得xml根元素50 Element root = doc.getRootElement();51// 取得根元素的⼦元素52 List<?> node = root.getChildren();53for (int i = 0; i < node.size(); i++) {54 Element element = (Element) node.get(i);55if (element.getName().equals("trxId")) {56 trxId = element.getValue();57 } else if (element.getName().equals("trxBank")) {58 trxBank = element.getValue();59 } else if (element.getName().equals("trxOper")) {60 trxOper = element.getValue();61 } else if (element.getName().equals("trxDate")) {62 trxDate = element.getValue();63 } else if(element.getName().equals("PkgNo")){64 PkgNo=element.getValue();65 } else if(element.getName().equals("fileCode")){66 fileCode=element.getValue();67 } else if(element.getName().equals("fileName")){68 fileName=element.getValue();69 }else if(element.getName().equals("fileContent")){70 fileContent=element.getValue();71 }72 }73 (" 解析xml配置⽂件成功");74 ("*****************************************************************************");75 (" trxId:[" + trxId + "]");76 (" trxBank:[" + trxBank + "]");77 (" trxOper:[" + trxOper + "]");78 (" trxDate:[" + trxDate + "]");79 (" PkgNo:[" + PkgNo + "]");80 (" fileCode:[" + fileCode + "]");81 (" fileName:[" + fileName + "]");82 (" fileContent:[" + fileContent + "]");83 ("*****************************************************************************");84 } catch (Exception e) {85 Log4jBean.logger.error("解析xml配置⽂件异常，异常信息为：【" + e.getMessage() + "】");86 }8788 }89public static void main(String[] args)90 {91//PullConfigXml();92 }。

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格式的返回报文，常见的方式有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 文件的三种解析方法

创建解析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的四种解析器的原理和性能比较。

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文档，无需将整个文档加载到内存中。

Java解析XML的四种方法

Java解析XML的四种方法概序XML现在已经成为一种通用的数据交换格式,它的平台无关性,语言无关性,系统无关性,给数据集成与交互带来了极大的方便。

XML文件解析方法XML在不同的语言里解析方式都是一样的,只不过实现的语法不同而已。

基本的解析方式有两种,一种叫SAX，另一种叫DOM。

SAX是基于事件流的解析,DOM是基于XML文档树结构的解析。

假设我们XML的内容和结构如下:<?xml version="1.0" encoding="UTF-8"?><employees><employee><name>ddviplinux</name><sex>m</sex><age>30</age></employee></employees>本文实现DOM与SAX的XML文档生成与解析。

首先定义一个操作XML文档的接口XmlDocument 它定义了XML文档的建立与解析的接口。

package com.alisoft.facepay.framework.bean;/**** @author hongliang.dinghl* 定义XML文档建立与解析的接口*/public interface XmlDocument {/*** 建立XML文档* @param fileName 文件全路径名称*/public void createXml(String fileName);/*** 解析XML文档* @param fileName 文件全路径名称*/public void parserXml(String fileName);}1.DOM生成和解析XML文档为 XML 文档的已解析版本定义了一组接口。

解析器读入整个文档，然后构建一个驻留内存的树结构，然后代码就可以使用 DOM 接口来操作这个树结构。

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相关操作的详细介绍：
1. 解析XML文件：使用Java中的DOM、SAX或JDOM等API可以解析XML文件并获取其中的数据。

2. 创建XML文件：可以使用Java中的DOM或JDOM等API创建XML文件，并将数据写入其中。

3. 使用XML Schema验证XML文档：可以使用Java中的SAX或DOM API以及一些第三方库，如JAXB或XSDValidator等，来验证XML 文档是否符合XML Schema的规范。

4. 转换XML格式：可以使用Java中的XSLT API将XML文档转换为其他格式，如HTML、PDF等。

5. 使用XPath查询XML文档：可以使用Java中的XPath API来查询XML文档中的数据。

6. 使用JAXB绑定XML和Java对象：可以使用JAXB API将XML 文档中的数据绑定到Java对象上，并进行操作和修改。

7. 使用XML与Web服务交互：可以使用Java中的WebService API 来使用XML和Web服务交互，并获取和发送数据。

总之，Java与XML的结合可以实现许多功能，如数据存储、数据传输、Web服务交互等，是Java开发中的重要部分。

- 1 -。

Java中xml解析

Java中xml解析1.String 字符串保持到txt⽂件String xml ="abcdefghijk";FileWriter fw = null;File f = new File("d:\\a.txt");try {if(!f.exists()){f.createNewFile();}fw = new FileWriter(f);BufferedWriter out = new BufferedWriter(fw);out.write(xml, 0, xml.length()-1);out.close();} catch (IOException e) {e.printStackTrace();}2.读取xml节点，获取节点值，节点属性等导⼊的包import org.dom4j.Document;import org.dom4j.io.SAXReader;SAXReader reader = new SAXReader();Document doc = reader.read(new File("d:/dahua.xml"));doc = DocumentHelper.parseText("字符串");//String 直接转为 Document ⽅法doc.read();//可以读取file，inputstream等//节点：Iterator Element.nodeIterator(); //获取当前标签节点下的所有⼦节点//标签：Element Document.getRootElement(); //获取xml⽂档的根标签Element ELement.element("标签名") //指定名称的第⼀个⼦标签Iterator<Element> Element.elementIterator("标签名");// 指定名称的所有⼦标签List<Element> Element.elements(); //获取所有⼦标签//属性：String Element.attributeValue("属性名") //获取指定名称的属性值Attribute Element.attribute("属性名")；//获取指定名称的属性对象Attribute.getName() //获取属性名称Attibute.getValue() //获取属性值List<Attribute> Element.attributes(); //获取所有属性对象Iterator<Attribute> Element.attibuteIterator(); //获取所有属性对象//⽂本：Element.getText(); //获取当前标签的⽂本Element.elementText("标签名") //获取当前标签的指定名称的⼦标签的⽂本内容// 使⽤xpath⽅法List<Node> selectNodes("xpath表达式"); 查询多个节点对象Node selectSingleNode("xpath表达式"); 查询⼀个节点对象。

Java相关课程系列笔记之五XML学习笔记(建议用WPS打开)

>XML学习笔记Java相关课程系列笔记之五笔记内容说明XML（范传奇老师主讲，占笔记内容100%）；目录一、 XML基本语法 0XML介绍 0XML元素 0XML属性 0实体引用 0CDATA段 (1)DTD声明元素 (1)DTD声明元素：声明空元素 (2)DTD声明元素：含有PCDATA (2)DTD声明元素：带有子元素（子元素列表）的元素 (2)DTD声明元素：声明只出现一次的元素 (3)DTD声明元素：声明可多次出现的元素 (3)DTD声明元素：子元素只能是其中之一的情况 (3)DTD声明元素：子元素可以是元素也可以是文本 (3)DTD声明元素：总结 (4)DTD中声明元素的属性 (4)属性类型 (4)属性值的约束 (4)DTD命名空间介绍 (4)二、 Schema简介 (5)Schema的作用 (5)Schema文件的扩展名xsd (5)三、 Java解析XML (6)Java与XML共同点 (6)Java解析XML有两种方式 (6)JDOM/DOM4J (6)DOM解析 (6)SAX解析 (6)案例：使用DOM4J包的核心API解析xml文件 (6)案例：使用DOM4J包的核心API写入xml文件 (6)四、 XPath语言 (8)XPath基本介绍 (8)使用XPath的好处 (8)XPath基本语法 (8)DOM4J对XPath的支持 (8)五、附文件 (9)一、XML基本语法XML介绍1）XML是可扩展标记语言（EXtensible Markup Language）。

2）XML是独立于软件和硬件的信息传输工具。

3）XML是以文本的形式存在于一个文本文件中的，一般该文件的后缀名就是“.xml”，例如：。

4）XML的设计宗旨是传输信息（尤其是结构比较复杂的数据），而不是显示数据。

5）XML可以描绘树状结构的数据。

因为这个特点，除了传输数据外，更多时候我们使用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简单应用程序接口。