四种XML解析器比较
单片机xml解析
单片机xml解析“单片机XML解析”是指使用单片机（通常指微控制器或微处理器）来解析XML格式的数据。
XML（可扩展标记语言）是一种用于存储和传输数据的格式，它使用标记来描述数据的内容和结构。
在嵌入式系统和物联网设备中，解析XML数据可以用于读取配置、通讯协议或者应用程序状态等信息。
单片机XML解析的方法有多种，常见的有：1.库函数解析：许多单片机厂商或第三方库提供了用于解析XML的函数或工具。
这些库通常封装了底层硬件操作，使得开发者可以更方便地读取XML 数据并将其转换为可以在单片机上处理的形式。
2.字符串处理：对于一些资源有限的单片机，可以使用字符串处理函数逐字符读取XML数据，并手动解析其结构和内容。
这种方法比较基础，但灵活度较高。
3.自定义解析器：根据XML的结构和需求，可以编写自定义的解析函数或程序。
这种方法可以提供更好的性能和定制性，但需要投入更多的开发时间和资源。
4.网络协议库：许多单片机支持网络通讯，而许多网络协议（如HTTP）使用XML作为数据交换格式。
因此，通过使用网络协议库，单片机可以直接从网络上获取XML数据并进行解析。
5.中间件/代理：对于更复杂的应用，可以使用一个中间件或代理来接收和处理XML数据，然后再将处理后的数据发送给单片机。
这种方法可以减轻单片机的处理负担，但会增加系统的复杂性和延迟。
总结来说，“单片机XML解析”是指使用单片机来读取、解析和处理XML格式的数据。
这通常涉及到硬件操作、字符串处理、网络通讯等方面的技术。
通过解析XML数据，单片机可以实现更高级的功能，如远程配置、动态数据交换等。
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"。
如何优化代码的XML数据处理
如何优化代码的XML数据处理XML（可扩展标记语言）是一种使用标签来描述和结构化数据的通用格式。
在软件开发中，处理XML数据是非常常见的任务之一。
优化XML数据处理代码可以帮助提高代码的性能、可读性和可维护性。
下面我们将讨论一些常见的优化技巧。
1.使用适当的解析器：在处理XML数据时，我们可以使用不同的解析器。
常见的解析器有DOM（文档对象模型）、SAX（简单API for XML）和StAX（流式XML API）。
DOM解析器加载整个XML文档到内存中，适用于小型文档，但对于大型文档可能导致内存问题。
SAX解析器基于事件驱动模型，逐行读取文档，适用于大型文档，但代码可能会比较复杂。
StAX解析器提供了一种流式处理XML文档的方式，同时兼具DOM和SAX解析器的优点，适合于大型文档且较易于使用。
选择适当的解析器可以根据实际需求和性能要求进行优化。
2.使用缓存：在多次处理相同的XML数据时，我们可以考虑使用缓存来提高性能。
将已解析的XML数据缓存在内存中，可以避免每次读取和解析XML文件，从而减少IO操作和CPU开销。
在对XML数据进行更新操作时，我们需要注意及时更新缓存以避免数据一致性问题。
3.使用XPath查询：XPath是一种用于在XML文档中定位节点的语言。
使用XPath查询可以帮助简化代码，提高查询性能。
相比于遍历整个XML文档来查找节点，使用XPath可以直接定位到目标节点，减少遍历次数，提高效率。
4.避免频繁的字符串拼接：在处理XML数据时，我们经常需要拼接字符串来构建XML结构。
频繁的字符串拼接会导致内存分配和拷贝的开销增加。
为了避免这个问题，我们可以使用StringBuilder类来进行高效的字符串操作。
5.使用线程池：在处理大量XML数据时，可以考虑使用线程池来并行处理任务，以提高处理效率。
将XML数据分成多个任务，每个任务由一个线程来处理，可以充分利用多核处理器，并行处理不同部分的数据。
XML的四种解析器性能比较
情 ．在诸如 Ｓ Ｘ这样基 于事件 的 Ａ Ｉ Ａ Ｐ 中，解析 器将 向某种监 听器发送 事件 ．在诸如 Ｄ Ｍ这样基 于树 的 Ａ Ｉ中，解析 器 Ｏ Ｐ
将在 内存 中构造 一颗数 据树 ．本文就 四种不 同的解析 器进行性 能比较 ．
关 键 词 ：解 析 器 ；Ｄ Ｍ；Ｓ Ｘ；ＪＯ Ｏ Ａ Ｄ Ｍ；Ｄ Ｍ Ｊ Ｏ ４ 中图 分 类 号 ：Ｔ ３ １ １ Ｐ １ ．３ 文 献 标 识 码 ：Ａ 文 章 编 号 ：１７ —２０ （０７ ２— ０ ０ ２ ６３ ６Ｘ ２０ ）０ ０２ —０
１ ＤＵＭ
解析器常用 于 Ｘ Ｌ文档需要频繁 改变的服务 中． Ｍ
２ Ｓ ｘ Ａ
Ｄ Ｍ是 Ｄ ｅ ａ ｔ ｂ ｃ Ｍ ｄｌ Ｏ ｏｔ ｅ ｊ ｔ ｏｅ文档对 象模 型的缩 写 ． ｍ ｎＯ ｅ 根 据 ＷＫ Ｄ Ｍ规 范 ， Ｏ Ｏ Ｄ Ｍ是 一 种 与浏 览 器、 台 、 言 的接 平 语
＜ｆｅ ａ ｅ ｉ ｅｎ ． ｇ ｆｅ ａ ｅ ｉ Ｎ ｍ ＞ｔ ｏｅＪ ＜／ ｌ ｍ ＞ ｌ ｍ Ｐ ｉＮ
＜／ ｌ Ｉｆ ｉ ｆ ｅｎｏ＞ ＜／ ｏｋ ｏ ｗ ｒｆ ｗ＞ ｌ
些常用的方法 ．Ｏ Ｄ Ｍ以及 广义的基 于树 的处 理具有几 个优 点． 由于树在 内存 中是持久 的， 因此 可以修 改它 以便应用程 序能对数据和结构 出更 改 ． 它还可 以在任 何时候 在树 中 上下导航 ， 而不是像 Ｓ Ｘ那样 是一次性的处理 ． Ａ Ｄ Ｍ解析器把 Ｘ Ｌ文档转 化为一个 包含其内容的树 ， Ｏ Ｍ 并可以对树进 行 遍 历 ． Ｄ Ｍ解 析 模型 的优 点 是编 程 容 用 Ｏ 易， 开发 人员 只需 要 调用 建树 的指 令 ， 然后 利 用 ｎｖ ａｏ ａｉ ｔｎ ｇｉ
读写XML的四种方法
读写XML的四种方法XML（eXtensible Markup Language）是一种用于表示和传输数据的标记语言。
它具有良好的可读性和扩展性，被广泛应用于Web开发、数据交换和配置文件等领域。
在读写和处理XML数据时，有许多方法可供选择。
本文将介绍四种常见的读写XML的方法：DOM、SAX、JDOM、和XMLStreamReader/XMLStreamWriter。
1. DOM（Document Object Model）：DOM是一种基于树形结构的解析器，它将整个XML文档加载到内存中，并将其表示为一个对象树。
在DOM中，每个XML元素都被表示为一个节点（Node），可以通过节点的属性和方法对其进行操作。
读取XML文档时，可以使用DOM解析器将其转换为一个DOM树，然后通过节点的方法访问和修改树结构。
写入XML文档时，可以通过创建和修改节点来构建DOM树，并使用DOM解析器将其保存为XML文档。
使用DOM读取XML文档的基本步骤如下：- 创建一个DocumentBuilderFactory对象。
- 根据DocumentBuilderFactory对象创建一个DocumentBuilder对象。
- 使用DocumentBuilder对象解析XML文档，并返回一个Document对象。
- 通过Document对象的方法遍历和操作XML文档的节点。
使用DOM写入XML文档的基本步骤如下：- 创建一个DocumentBuilderFactory对象。
- 根据DocumentBuilderFactory对象创建一个DocumentBuilder对象。
- 使用DocumentBuilder对象创建一个Document对象。
- 通过Document对象的方法创建和添加元素节点、属性节点等。
- 使用TransformerFactory和Transformer对象将Document对象保存为XML文档。
DOM的优点是易于使用和理解，可以方便地遍历和修改XML文档。
XML应用的关键：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中xsd、xsi、xmlns的含义
xml中xsd、xsi、xmlns的含义XML是可扩展标记语⾔，它定义了按格式编码⽂件的⼀系列规则[3]，编码的⽂件是机器可读和⼈可读的。
XML⽂件对于机器可读是基于XSD(XML Schema Definition)[1]的。
XSD是受W3C推荐的XML⽂件的结构描述⽂件的规范⽂档，其中详细说明了如何正式描述XML⽂件中的元素[3]；也就是说，XSD是XML⽂件的结构描述⽂件（⽐如.xsd⽂件，⼀个XSD的实例，它是依照XSD的规范来书写的）的规范⽂档。
编译xml的⽅式是跨语⾔的，不同语⾔的解析⽅式相同，只是具有不同的语⾔形式。
java中解析XML的⽅式之⼀是DOM解析，他是基于jdk的lang包中DocumentBuilderFactory类的，如下所⽰[2]。
public class DOMTest {public static void main(String[] args) {//创建⼀个DocumentBuilderFactory的对象DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();//创建⼀个DocumentBuilder的对象try {//创建DocumentBuilder对象DocumentBuilder db = dbf.newDocumentBuilder();//通过DocumentBuilder对象的parser⽅法加载books.xml⽂件到当前项⽬下Document document = db.parse("books.xml");//获取所有book节点的集合NodeList bookList = document.getElementsByTagName("book");//通过nodelist的getLength()⽅法可以获取bookList的长度System.out.println("⼀共有" + bookList.getLength() + "本书");}}} 我刚开始接触XML时，对.xsd和XSD的区别⽐较困惑。
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 简单易用。
XML文件格式简介(经典篇)
〈!ELEMENT element-name element-definition〉
〈!ELEMENT：表示开始元素设置，注意此处 ELEMENT 关键字是大写。
element-name：表示要设置的元素的名称。
element-definition：指明要对此元素进行怎样的定义，就是说〈元素〉...〈/元素〉之间能够包含什么 内容，是其他元素还是一般性的文字。
使用了 DTD，那么文件中的根元素就在这里指定。
[.........]〉 ：在[ ]标记里面定义 XML 文件使用元素，然后用〉结束 DTD 的定义。
下面，我们来看一下怎样给 XML 文件定义 DTD，请见例 1。
例 1 中的 DTD 定义区可以看作是一个 DTD 定义的大概框架，为其他 XML 文件定义 DTD，结构和例 1 的 DTD 差不多，只是可能需要添加、删除或者更改一些东西而已。在 DTD 定义的中间是元素设定，这是一个 DTD 的最主要部分，其主要语法如下：
我们看到，在 XML 文件中，用的大多都是自定义的标记。但是大家考虑一下，如果两个同行业的公司 A 和 B 要用 XML 文件相互交换数据，A 公司用 〈价格〉标记来表示他们产品的价格信息，而 B 公司可能用 〈售价〉来表示价格信息。如果一个 XML 应用程序来读取他们各自的 XML 文件中的信息时，如果它只知道 〈价格〉标记里表示的是价格信息，那么 B 公司的价格信息就读不出来，必将产生错误。显然，对于想利 用 XML 文件来交换信息的实体来说，他们之间必须有 一个约定——即编写 XML 文件可以用哪些标记，母 元素中能够包括哪些子元素，各个元素出现的顺序，元素中的属性怎样定义等。这样他们在用 XML 交换数 据时才能够畅通无阻。这种约定称为 DTD（Document Type Definition，文档格式定义）。可以把 DTD 看作编写 XML 文件的模板。对于同行业之间的 XML 数据交换，有一个固定的 DTD 将会方便很多。比如 说， 如果网上的各大电子商场的 XML 网页都遵循同一个 DTD 时，那么我们就可以轻松地依据这个 DTD 编写一 个应用程序，去网上将我们感兴趣的东西自动抓回来。事实上已经有了好几个定义好的 DTD，如前面所说 的 MathML、SMIL 等。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
1.详解1）DOM（JAXP Crimson解析器）DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。
DOM是以层次结构组织的节点或信息片断的集合。
这个层次结构允许开发人员在树中寻找特定信息。
分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。
由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。
DOM以及广义的基于树的处理具有几个优点。
首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。
它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。
DOM使用起来也要简单得多。
2）SAXSAX处理的优点非常类似于流媒体的优点。
分析能够立即开始，而不是等待所有的数据被处理。
而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。
这对于大型文档来说是个巨大的优点。
事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。
一般来说，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解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。
3）JDOM JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。
由于是第一个Java特定模型，JDOM一直得到大力推广和促进。
正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。
从2000年初就已经开始了JDOM开发。
JDOM与DOM主要有两方面不同。
首先，JDOM仅使用具体类而不使用接口。
这在某些方面简化了API，但是也限制了灵活性。
第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。
JDOM文档声明其目的是“使用20%（或更少）的精力解决80%（或更多）Java/XML问题”（根据学习曲线假定为20%）。
JDOM对于大多数Java/XML应用程序来说当然是有用的，并且大多数开发者发现API比DOM容易理解得多。
JDOM还包括对程序行为的相当广泛检查以防止用户做任何在XML中无意义的事。
然而，它仍需要您充分理解XML以便做一些超出基本的工作（或者甚至理解某些情况下的错误）。
这也许是比学习DOM或JDOM接口都更有意义的工作。
JDOM自身不包含解析器。
它通常使用SAX2解析器来解析和验证输入XML文档（尽管它还可以将以前构造的DOM表示作为输入）。
它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。
JDOM是在Apache许可证变体下发布的开放源码。
4）DOM4J 虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一种智能分支。
它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。
它还提供了构建文档表示的选项，它通过DOM4J API和标准DOM接口具有并行访问功能。
从2000下半年开始，它就一直处于开发之中。
为支持所有这些功能，DOM4J使用接口和抽象基本类方法。
DOM4J大量使用了API中的Collections类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。
直接好处是，虽然DOM4J付出了更复杂的API的代价，但是它提供了比JDOM大得多的灵活性。
在添加灵活性、XPath集成和对大文档处理的目标时，DOM4J的目标与JDOM是一样的：针对Java开发者的易用性和直观操作。
它还致力于成为比JDOM更完整的解决方案，实现在本质上处理所有Java/XML问题的目标。
在完成该目标时，它比JDOM更少强调防止不正确的应用程序行为。
DOM4J是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。
如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML，特别值得一提的是连Sun的JAXM也在用DOM4J.2。
比较1）DOM4J性能最好，连Sun的JAXM也在用DOM4J.目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。
如果不考虑可移植性，那就采用DOM4J.2）JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。
在小文档情况下还值得考虑使用DOM和JDOM.虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。
另外，DOM仍是一个非常好的选择。
DOM实现广泛应用于多种编程语言。
它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐（与基于非标准的Java模型相对），所以在某些类型的项目中可能也需要它（如在JavaScript中使用DOM）。
3）SAX表现较好，这要依赖于它特定的解析方式－事件驱动。
一个SAX检测即将到来的XML流，但并没有载入到内存（当然当XML流被读入时，会有部分文档暂时隐藏在内存中）。
3. 四种xml操作方式的基本使用方法xml文件：Xml代码1.<?xml version="1.0"encoding="gbk"?><list><node><name>weidewei</name><space>http://</space></node><node><name>flying</name><space>http://user.qz /94611981</space></node></list>程序代码:Java代码1.import java.io.File;2.import java.util.Iterator;3.import java.util.List;4.5.import javax.xml.parsers.DocumentBuilder;6.import javax.xml.parsers.DocumentBuilderFactory;7.import javax.xml.parsers.SAXParser;8.import javax.xml.parsers.SAXParserFactory;9.10.import org.dom4j.io.SAXReader;11.import org.jdom.Element;12.import org.jdom.input.SAXBuilder;13.import org.w3c.dom.Document;14.import org.w3c.dom.NodeList;15.import org.xml.sax.Attributes;16.import org.xml.sax.InputSource;17.import org.xml.sax.SAXException;18.import org.xml.sax.helpers.DefaultHandler;19.20.public class MyXMLReader extends DefaultHandler {21.22.java.util.Stack tags = new java.util.Stack();23.public MyXMLReader() {24.super();25.}26./**27.* DOM方式28.* @since V2.029.* @author David.Wei30.* @date 2008-4-1131.* @return void32.*/33.public void DOM() {34.long lasting = System.currentTimeMillis();35.36.try {37.File f = new File("F:/xmltest.xml");38.DocumentBuilderFactory factory = DocumentBuilderFactory39..newInstance();40.DocumentBuilder builder = factory.newDocumentBuilder();41.Document doc = builder.parse(f);42.NodeList nl = doc.getElementsByTagName("node");43.for (int i = 0; i < nl.getLength(); i++) {44.System.out.println("|| Name: |"45.+ doc.getElementsByTagName("name").item(i)46..getFirstChild().getNodeValue());47.System.out.println("||Space: |"48.+ doc.getElementsByTagName("space").item(i)49..getFirstChild().getNodeValue());50.System.out.println("-------------------------------------------------"); }51.} catch (Exception e) {52. e.printStackTrace();53.}54.System.out.println("DOM RUNTIME："55.+ (System.currentTimeMillis() - lasting) + " MS");56.}57.58.59.60./**61.* SAX方式62.* @since V2.063.* @author David.Wei64.* @date 2008-4-1165.* @return void66.*/67.public void SAX() {68.70.try {71.SAXParserFactory sf = SAXParserFactory.newInstance();72.SAXParser sp = sf.newSAXParser();73.MyXMLReader reader = new MyXMLReader();74.sp.parse(new InputSource("F:/xmltest.xml"), reader);75.} catch (Exception e) {76. e.printStackTrace();77.}78.System.out.println("SAX RUNTIME："79.+ (System.currentTimeMillis() - lasting) + " MS");80.}81.82.public void startElement(String uri, String localName, String qName,83.Attributes attrs) {84.tags.push(qName);85.}86.87.public void characters(char ch[], int start, int length)88.throws SAXException {89.String tag = (String) tags.peek();90.if (tag.equals("name")) {91.System.out.println("|| Name: |" + new String(ch, start, length));92.}93.if (tag.equals("space")) {94.System.out.println("||Space: |" + new String(ch, start, length));95.}96.System.out.println("-------------------------------------------------");97.}98.99./**100.* JDOM方式101.* @since V2.0102. * @author David.Wei103. * @date 2008-4-11104. * @return void105. */106. public void JDOM() {108. try {109. SAXBuilder builder = new SAXBuilder();110. org.jdom.Document doc = builder.build(new File("F:/xmlte st.xml"));111. Element foo = doc.getRootElement();112. List allChildren = foo.getChildren();113. for (int i = 0; i < allChildren.size(); i++) { 114. System.out.println("|| Name: |"115. + ((Element) allChildren.get(i)).g etChild("name")116. .getText());117. System.out.println("||Space: |"118. + ((Element) allChildren.get(i)).g etChild("space")119. .getText());120. System.out.println("-------------------------------------------------"); }121. } catch (Exception e) {122. e.printStackTrace();123. }124. System.out.println("JDOM RUNTIME："125. + (System.currentTimeMillis() - lasting) + " M S");126. }127.128. /**129. * DOM4J方式130. * @since V2.0131. * @author David.Wei132. * @date 2008-4-11133. * @return void134. */135. public void DOM4J() {136. long lasting = System.currentTimeMillis();137. try {138. File f = new File("F:/xmltest.xml");139. SAXReader reader = new SAXReader();140. org.dom4j.Document doc = reader.read(f);141. org.dom4j.Element root = doc.getRootElement();142. org.dom4j.Element foo;143. for (Iterator i = root.elementIterator("node"); i.hasNe xt();) {144. foo = (org.dom4j.Element) i.next();145. System.out.println("|| Name: |" + foo.elementT ext("name"));146. System.out.println("||Space: |" + foo.elementTe xt("space"));147. System.out.println("-------------------------------------------------");148. }149. } catch (Exception e) {150. e.printStackTrace();151. }152. System.out.println("DOM4J RUNTIME："153. + (System.currentTimeMillis() - lasting) + " M S");154. }155.156. public static void main(String arge[]) {157. MyXMLReader myXML = new MyXMLReader();158. System.out.println("=====================DOM======================== =");159. myXML.DOM();160. System.out.println("=====================SAX======================== =");161. myXML.SAX();162. System.out.println("=====================JDOM======================= =");163. myXML.JDOM();164. System.out.println("=====================DOM4J====================== =");165. myXML.DOM4J();166. System.out.println("================================================ =");167. }168.}运行结果:Html代码1.=====================DOM=========================2.|| Name: |weidewei3.||Space: |4.-------------------------------------------------5.|| Name: |flying6.||Space: |/946119817.-------------------------------------------------8.DOM RUNTIME：62 MS9.=====================SAX=========================10.|| Name: |weidewei11.-------------------------------------------------12.||Space: |13.-------------------------------------------------14.|| Name: |flying15.-------------------------------------------------16.||Space: |/9461198117.-------------------------------------------------18.SAX RUNTIME：16 MS19.=====================JDOM========================20.|| Name: |weidewei21.||Space: |22.-------------------------------------------------23.|| Name: |flying24.||Space: |/9461198125.-------------------------------------------------26.JDOM RUNTIME：78 MS27.=====================DOM4J=======================28.|| Name: |weidewei29.||Space: |30.-------------------------------------------------31.|| Name: |flying32.||Space: |/9461198133.-------------------------------------------------34.DOM4J RUNTIME：78 MS35.=================================================运行时如果有错误可能原因(我碰到的就这两个,解决了就OK了):1.错误现象: Caused by: org.xml.sax.SAXParseException: Content is not allowed in prolog.解决办法:xml文件换行问题,编写xml文件时不要换行就可以了.2.dom4j错误现象: org.dom4j.DocumentException: Error on line 1 of document : Content is not allowed in prolog.解决方法:dom4j的jar包使用dom4j1.6就可以了.。