Expat
Expat 是什么？
Expat 是一个用C语言开发的、用来解析XML文档的开发库，它最初是开源的、Mozilla 项目下的一个XML解析器。
关于作者
这个库的开发者是James Clark，还开发了很多我们所熟知的工具包：groff、Jade、XP (a Java XML parser package)、 and XT (a Java XSL engine)。
Expat XML Parser 概述
Expat是一个面向流的解析器。您注册的解析器回调（或handler）功能，然后开始搜索它的文档。当解析器识别该文件的指定的位置，它会调用该部分相应的处理程序（如果您已经注册的一个）。该文件被输送到解析器，会被分割成多个片断，并分段装到内存中。因此expat可以解析那些巨大的文件。
如何使用它们
Expat XML Parser支持设置多种不同的处理器。但是要使用它们，你只需要学习四个功能，即可满足80%的需要。它们是：
XML_ParserCreate Create a new parser object.
XML_SetElementHandler Set handlers for start and end tags.
XML_SetCharacterDataHandler Set handler for text.
XML_Parse Pass a buffer full of document to the parser
开源的XML Parser expat
文章分类:C++编程
expat是使用C所写的XML解释器，采用流的方式来解析XML文件，并且基于事件通知型来调用分析到的数据，并不需要把所有XML文件全部加载到内存里，这样可以分析非常大的XML文件。由于 expat库是由XML的主要负责人James Clark来实现的，因此它是符合W3C的XML标准的。
正因为源码全部是纯C所写，因此，非常容易移植，尤其是适用于嵌入式平台，我在往联芯的手机平台上移植时，几乎没改任何东西。
不过，优点也带来了缺点，因为是采用流的方式解析XML，所以不会像TinyXML那样在
一块内存中生成基于DOM的树。虽然这样解析起来略显麻烦，但是基于回调的机制，在我看来还是蛮方便的。下面就说使用方法：
首先是用XML_ParserCreate(const XML_Char *encodingName)，参数一般为NULL，函数返回一个XML_Parser类型指针，我们就当他是一个句柄吧，类似于Windows里的内核对象，一般需要保存在一个全局的指针里。
然后调用XML_SetElementHandler(XML_Parser parser,
XML_StartElementHandler start,
XML_EndElementHandler end)
第一个参数是那个Parser句柄，第二个和第三个参数则是整个Parser的核心，类型为CallBack的函数，不了解CallBack函数的，我在这里简单说下，函数调用一般分为两种，一种是主调，即编写代码者自己调用的函数，还一种称为Callback函数，编码者写好，但他自己却不主动调用，而是在某些条件下（编码者并不清楚具体时间和流程），由其他函数调用，比如设备驱动，操作系统提供了一组某个设备的函数指针，比如LCD屏驱动，由一组画点，画线，画块等函数组成，当更换LCD时，只需要把操作系统开放的函数指针，指向你提供的接口即可，操作系统再需要时，会自动调用你的驱动函数，这就是回调函数一个典型的例子。
这二个回调分别是对应于解析<>和，下面分别详细介绍这个2个回调函数。
typedef void (XMLCALL *XML_StartElementHandler) (
void *userData,
const XML_Char *name,
const XML_Char **atts);
其中第一个参数userData, 可以由函数
XML_SetUserData(XML_Parser parser, void *p)
设置，参数就不用说了吧？后面两个参数，我用个具体的列子说明下，这样更好理解：比如有个标准XML，某个标签属性如下：
这时候必然有个对应的：
typedef void (XMLCALL *XML_EndElementHandler) (
void *userData,
const XML_Char *name);
就是处理标签结束的，name就是"feed”了，这个回调一般是用户设置自己的状态机的。
最后一个函数就是
XML_SetCharacterDataHandler(
XML_Parser parser,
XML_CharacterDataHandler handler)
这个函数是设置处理一个<>和之间的字段的回调。回调原型如下：
typedef void (XMLCALL *XML_CharacterDataHandler) (
void *userData,
const XML_Char *s,
int len);
其中第二个参数是一块Buffer的指针，如果你单步DEBUG后，你会发现expat用的就是你传入的那块Buffer(这块Buffer下面讲解），比如：
湖北北部、四川中东部、重庆西部和北部、贵州西部等地的部分地区有大雨或
暴雨，河南南部、湖北北部等地局部有大暴雨。【点击“更多”查询其他城市
天气】
假设目前解析到天气这个charData, 如果你看那个指针的所有内容的话，实际上是这样的：天气
但这里有个非常隐晦的问题，如果不知道的话，会带来很大麻烦，下面说。
最后就是parse，调用
XML_Parse(XML_Parser parser, const char *s, int len, int isFinal)
第二个参数是用户指定的Buffer指针，第三个是这块Buffer中实际内容的字节数，最后参数代表是否这块Buffer已经结束。比如要解析的XML文件太大，但内存比较吃紧，Buffer 比较小，则可以循环读取文件，然后丢给Parser，在文件读取结束前，isFinal参数为FALSE，反之为TRUE。
这里的Buffer如果太小则会造成上面提到那个隐晦的问题，
XML_CharacterDataHandler一次返回的可能并不是完整的CharData,比如这个charData的Len大于你的 Buffer大小，那这是会连续调用2次XML_CharacterDataHandler,我们需要将2次结果拼接起来，以得到正确结果，因此我们的状态机一定要考虑到这点。顺便说下
XML_ParserReset(XML_Parser parser, const XML_Char *encodingName)函数，在某些时候，如果你不确定前后2次XML是否一样的情况下，比如网络上投递的XML，在一次解析后最好调用一次本函数，否则会出现意料之外的结果。比如前后两次XML完全一样，可这你并不知情，那么XML_Parse（）会返回失败。
XML解析－libxml库函数解释
libxml（一）
绪论
Libxml是一个实现读、创建及操纵XML数据功能的C语言库。这个指南提供例子代码并给出它基本功能的解释。在这个项目的主页上有Libxml及更多关于它可用的资料。包含
有完整的API文档。这个指南并不能替代这些完整的文档，但是阐明功能需要使用库来完成基本操作。
这个指南基于一个简单的XML应用，它使用我写的一篇文章生成，它包含有元数据和文章的主体。
本指南中的例子代码示范如何做到：
?解析文档
?取得指定元素的文本
?添加一个元素及它的内容
?添加一个属性
?取得一个属性的值
例子的完整代码包含在附录中
数据类型
Libxml定义了许多数据类型，我们将反复碰到它们，它隐藏了杂乱的来源以致你不必处理它除非你有特定的需要。xmlChar替代char,使用UTF-8编码的一字节字符串。如果你的数据使用其它编码，它必须被转换到UTF-8才能使用libxml的函数。在libxml编码支持WEB页面有更多关于编码的有用信息。
XmlDoc包含由解析文档建立的树结构，xmlDocPtr是指向这个结构的指针。
xmlNodePtr and xmlNode包含单一结点的结构xmlNodePtr是指向这个结构的指针，它被用于遍历文档树。
解析文档
解析文档时仅仅需要文件名并只调用一个函数，并有错误检查。完整代码：附录C, Keyword例程代码
①xmlDocPtr doc;
②xmlNodePtr cur;
③doc = xmlParseFile(docname);
④if (doc == NULL ) {
fprintf(stderr,"Document not parsed successfully. \n");
return;
}
⑤cur = xmlDocGetRootElement(doc);
⑥if (cur == NULL) {
fprintf(stderr,"empty document\n");
xmlFreeDoc(doc);
return;
}
⑦if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {
fprintf(stderr,"document of the wrong type, root node != story");
xmlFreeDoc(doc);
return;
}
①定义解析文档指针。
②定义结点指针(你需要它为了在各个结点间移动)。
④检查解析文档是否成功，如果不成功，libxml将指一个注册的错误并停止。
注释
一个常见错误是不适当的编码。XML标准文档除了用UTF-8或UTF-16外还可用其它编码保存。如果文档是这样，libxml将自动地为你转换到UTF-8。更多关于XML编码信息包含在XML标准中。
⑤取得文档根元素
⑥检查确认当前文档中包含内容。
⑦在这个例子中，我们需要确认文档是正确的类型。“Story”是在这个指南中使用文档的根类型。
取得元素内容
你找到在文档树中你要查找的元素后可以取得它的内容。在这个例子中我们查找“story”元素。进程将在冗长的树中查找我们感兴趣的元素。我们假定你已经有了一个名为doc的xmlDocPtr和一个名为cur的xmlNodPtr。
①cur = cur->xmlChildrenNode;
②while (cur != NULL) {
if ((!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo"))){
parseStory (doc, cur);
}
cur = cur->next;
}
①取得cur的第一个子结点，cur指向文档的根，即“story”元素。
②这个循环迭代通过“story”的子元素查找“storyinfo”。这是一个包含有我们将查找的“keywords”的元素。它使用了libxml字符串比较函数xmlStrcmp。如果相符，它调用函数parseStory。
void parseStory (xmlDocPtr doc, xmlNodePtr cur) {
xmlChar *key;
① cur = cur->xmlChildrenNode;
② while (cur != NULL) {
if ((!xmlStrcmp(cur->name, (const xmlChar *)"keyword"))) {
③ key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
printf("keyword: %s\n", key);
xmlFree(key);
}
cur = cur->next;
}
return;
}
①再次取得第一个子结点。
②像上面那个循环一样，我们能够迭代，查找我们感兴趣的叫做“keyword”的元素。
③当我们找到元素“keyword”时，我们需要打印它包含在XML中的记录的内容，文本被包含于元素的子结点中，因此我们借助了cur->xmlChildrenNode，为了取得文本，我们使用函数xmlNodeListGetString，它有一个文档指针参数，在这个例子中，我们仅仅打印它。注释
因为xmlNodeListGetString为它返回的字符串分配内存，你必须使用xmlFree释放它。
使用XPath取得元素内容
除了一步步遍历文档树查找元素外，Libxml2包含支持使用Xpath表达式取得指定结点集。完整的Xpath API文档在这里。Xpath允许通过路径文档搜索匹配指定条件的结点。在下面的例子中，我们搜索文档中所有的“keyword”元素。
注释
下面是Xpath完整的讨论。它详细的使用资料，请查阅Xpath规范。这个例子完整的代码参见附录D，XPath例程代码。
Using XPath requires setting up an xmlXPathContext and then supplying the XPath expression and the context to the xmlXPathEvalExpression
function.
The function returns an xmlXPathObjectPtr, which includes the set of nodes satisfying the XPath expression.
使用XPath需要安装xmlXPathContext才支持XPath表达式及xmlXPathEvalExpression函数，这个函数返回一个xmlXPathObjectPtr，它包含有
XPath表达式的结点集。
xmlXPathObjectPtr
getnodeset (xmlDocPtr doc, xmlChar *xpath){
①xmlXPathContextPtr context;
xmlXPathObjectPtr result;
②context = xmlXPathNewContext(doc);
③result = xmlXPathEvalExpression(xpath, context);
④if(xmlXPathNodeSetIsEmpty(result->nodesetval)){
printf("No result\n");
return NULL;
}
xmlXPathFreeContext(context);
return result;
}
①首先定义变量
②初始化变量context
③应用XPath表达式
④检查结果
由函数返回的xmlPathObjectPtr包含一个结点集和其它需要被迭代及操作的信息。在这个例子中我们的函数返回xmlXPathObjectPtr，我们使用它打印我们文档中keyword结点的内容。这个结点集对象包含在集合(nodeNr)中的元素数目及一个结点(nodeTab)数组。
①for (i=0; i < nodeset->nodeNr; i++) {
②keyword = xmlNodeListGetString(doc,
nodeset->nodeTab[i]->xmlChildrenNode, printf("keyword: %s\n", keyword); xmlFree(keyword);
}
①变量nodeset->Nr持有结点集中元素的数量。我们使用它遍历数组。
②打印每个结点包含的内容。
注释
Note that we are printing the child node of the node that is returned, because the contents of the keyword element are a child text node.注意我们打印的是结点的子结点的返回值，因为keyword元素的内容是一个子文本结点。
写（插入）元素
写元素内容使用上面许多一样的步骤—解析文档并遍历树。我们先解析文档然后遍历树查找我们想插入元素的位置。在这个例子中，我们再一次查找“storyinfo”元素并插入一个keyword。然后我们装文件写入磁盘。完整代码：附录E，添加keyword例程
本例中主要的不同在于parseStory
void
parseStory (xmlDocPtr doc, xmlNodePtr cur, char *keyword) {
①xmlNewTextChild (cur, NULL, "keyword", keyword);
return;
}
①XmlNewTextChild函数添加一个当前结点的新的子元素到树中
一旦结点被添加，我们应当写文档到文件中。你是否想给元素指定一个命名空间？你能添加它，在我们的例子中，命名空间是NULL。
xmlSaveFormatFile (docname, doc, 1);
第一个参数是写入文件的名，你注意到和我们刚刚读入的文件名是一样的。在这个例子中，我们仅仅覆盖原来的文件。第二个参数是一个xmlDoc结构指针，第三个参数设定为1，保证在输出上写入。
libxml（二）
写属性
写属性类似于给一个新元素写文本。在这个例子中，我们将添加一个reference结点URI属性到我们的文档中。完整代码：附录F，添加属性例程代码。reference是story元素的一个子结点，所以找到并插入新元素及其属性是简单的。一旦我们在parseDoc进行了错误检查，我们将在正确的位置加放我们的新元素。但进行之前我们需要定义一个此前我们不见过的数据类型。
xmlAttrPtr newattr;
我们也需要xmlNodePtr：
xmlNodePtr newnode;
剩下的parseDoc则和前面一样，检查根结点是否为story。如果是的，那我们知道我们将在指定的位置添加我们的元素。
① newnode = xmlNewTextChild (cur, NULL, "reference", NULL);
②newattr = xmlNewProp (newnode, "uri", uri);
①使用xmlNewTextChild函数添国一个新结点到当前结点位置。
一旦结点被添加，文件应像前面的例子将我们添加的元素及文本内容写入磁盘。
取得属性
取得属性值类似于前面我们取得一个结点的文本内容。在这个例子中，我们将取出我们在前一部分添加的URI的值。完整代码：附录G，取得属性值例程代码。
这个例子的初始步骤和前面是类似的：解析文档，查找你感兴趣的元素，然后进入一个函数完成指定的请求任务。在这个例子中，我们调用getReference。
void getReference (xmlDocPtr doc, xmlNodePtr cur) {
xmlChar *uri;
cur = cur->xmlChildrenNode;
while (cur != NULL) {
if ((!xmlStrcmp(cur->name, (const xmlChar *)"reference"))) {
① uri = xmlGetProp(cur, "uri");
printf("uri: %s\n", uri);
xmlFree(uri);
}
cur = cur->next;
}
return;
}
①关键函数是xmlGetProp,它返回一个包含属性值的xmlChar。在本例中，我们仅仅打印它。
注释
如果你使用DTD定义属性的固定值或缺省值，这个函数也将取得它。
编码转换
数据编码兼容问题是程序员新建普通的XML或特定XML时最常见的困难。稍后的讨论来思考设计你的应用程序将帮助你避免这个困难。实际上，libxml能以UTF-8格式保存和操纵多种数据
你的程序使用其它的数据格式，比如常见的ISO-8859-1编码，必须使用libxml函数转换到UTF-8。如果你想你的程序以除UTF-8外的其它编码方式输出也必须做转换。
如果能有效地转换数据Libxml将使用转换器。无转换器时，仅仅UTF-8、UTF-16和ISO-8859-1能够被作为外部格式使用。有转换器时，它能将从其它格式与UTF-8互换的任何格式均可使用。当前转换器支持大约150种不同的编码格式之间的相互转换。实际支持的格式数量正在被实现。每一个实现在的转换器尽可能的支持每一种格式。
警告：一个常见错误是在内部数据不同的部分使用不同的编码格式。最常见的情况是一个用以ISO-8859-1作为内部数据格式，结合libxml部分使用UTF-8格式。结果是一个应用程序要面对不同地内部数据格式。一部分代码执行后，它或其它部分代码将使用曲解的数据。
这个例子构造一个简单的文档，然后添加在命令行提供的内容到根元素并使用适当的编码将结果输出到标准输出设备上。在这个例子中，我们使用ISO-8859-1编码。在命令输入的内容将被从ISO-8859-1转换到UTF-8。完整代码：附件H，编码转换例程代码。
包含在例子中的转换函数使用libxml的xmlFindCharEncodingHandler函数。
①xmlCharEncodingHandlerPtr handler;
②size = (int)strlen(in)+1;
out_size = size*2-1;
out = malloc((size_t)out_size);
…
③handler = xmlFindCharEncodingHandler(encoding);
…
④handler->input(out, &out_size, in, &temp);
…
⑤xmlSaveFormatFileEnc("-", doc, encoding, 1);
①定义一个xmlCharEncodingHandler函数指针。
②XmlCharEncodingHandler函数需要给出输入和输出字符串的大小，这里计算输入输出字符串。
③XmlFindCharEncodingHandler使用数据初始编码作为参数搜索libxml已经完成的转换器句柄并将找到的函数指针返回，如果没有找到则返回NULL。
④The conversion function identified by handler requires as its arguments pointers to the input and output strings, along with the length of each. The lengths must be determined separately by the application.
由句柄指定的转换函数请求输入、输出字符中及它们的长度作为参数。这个长度必须由应用程序分别指定。
⑤用指定编码而不是UTF-8输出，我们使用xmlSaveFormatFileEnc指不定期编码方式。libxml2在linux下的使用
官网地址：https://www.doczj.com/doc/a57710482.html,
1.下载和安装LIBXML2
Libxml2是个C语言的XML程式库，能够简单方便的提供对XML文档的各种操作，并且支持XPATH查询，连同部分的支持XSLT转换等功能。Libxml2的下载地址是
https://www.doczj.com/doc/a57710482.html,/，完全版的库是开源的，并且带有例子程式和说明文档。最好将这个库先下载下来，因为这样能够查看其中的文档和例子。
由于我是在linux下用C语言进行研发的，所以我下载的是libxml2-2.6.20.tar.gz
版本的源码包。具体安装步骤：
1、解压：$tar zxvf libxml2-2.6.20.tar.gz
2、进入解压后的安装目录：$cd libxml2-2.6.20
3、安装三部曲：1）$./configure
2)$make
3)$make install(安装完毕)
2. Libxml2中的数据类型和函数
一个函数库中可能有几百种数据类型连同几千个函数，但是记住大师的话，90%的功能都是由30%的内容提供的。对于libxml2，我认为搞懂以下的数据类型和函数就足够了。
2.1 内部字符类型xmlChar
xmlChar是Libxml2中的字符类型，库中任何字符、字符串都是基于这个数据类型。事实上他的定义是：xmlstring.h->typedef unsigned char xmlChar;
使用unsigned char作为内部字符格式是考虑到他能很好适应UTF-8编码，而UTF-8编码正是libxml2的内部编码，其他格式的编码要转换为这个编码才能在libxml2中使用。还经常能够看到使用xmlChar*作为字符串类型，很多函数会返回一个动态分配内存的xmlChar*变量，使用这样的函数时记得要手动删除内存。
2.2 xmlChar相关函数
如同标准c中的char类型相同，xmlChar也有动态内存分配、字符串操作等相关函数。例如xmlMalloc是动态分配内存的函数；xmlFree是配套的释放内存函数；xmlStrcmp是字符串比较函数等等。
基本上xmlChar字符串相关函数都在xmlstring.h中定义；而动态内存分配函数在xmlmemory.h中定义。
2.3 xmlChar*和其他类型之间的转换
另外要注意，因为总是要在xmlChar*和char*之间进行类型转换，所以定义了一个宏BAD_CAST，其定义如下：xmlstring.h->#define BAD_CAST (xmlChar *)。原则上来说，unsigned char和char之间进行强制类型转换是没有问题的。
2.4文档类型xmlDoc、指针xmlDocPtr
xmlDoc是个struct，保存了一个xml的相关信息，例如文档名、文档类型、子节点等等；xmlDocPtr等于xmlDoc*，他搞成这个样子总让人以为是智能指针，其实不是，要手动删除的。
●xmlNewDoc函数创建一个新的文档指针。
●xmlParseFile函数以默认方式读入一个UTF-8格式的文档，并返回文档指针。
●xmlReadFile函数读入一个带有某种编码的xml文档，并返回文档指针；细节见libxml2
参考手册。
●xmlFreeDoc释放文档指针。特别注意，当您调用xmlFreeDoc时，该文档任何包含的节
点内存都被释放，所以一般来说无需手动调用xmlFreeNode或xmlFreeNodeList来释放动态分配的节点内存，除非您把该节点从文档中移除了。一般来说，一个文档中任何节点都应该动态分配，然后加入文档，最后调用xmlFreeDoc一次释放任何节点申请的动态内存，这也是为什么我们很少看见xmlNodeFree的原因。
●xmlSaveFile将文档以默认方式存入一个文档。
●xmlSaveFormatFileEnc可将文档以某种编码/格式存入一个文档中。
2.5 节点类型xmlNode、指针xmlNodePtr
节点应该是xml中最重要的元素了，xmlNode代表了xml文档中的一个节点，实现为一个struct，内容很丰富：
tree.h
typedef struct _xmlNode xmlNode;
typedef xmlNode *xmlNodePtr;
struct _xmlNode {
void *_private; /* application data */
xmlElementType type; /* type number, must be second ! */
const xmlChar *name; /* the name of the node, or the entity */ struct _xmlNode *children; /* parent->childs link */
struct _xmlNode *last; /* last child link */
struct _xmlNode *parent; /* child->parent link */
struct _xmlNode *next; /* next sibling link */
struct _xmlNode *prev; /* previous sibling link */
struct _xmlDoc *doc; /* the containing document */
/* End of common part */
xmlNs *ns; /* pointer to the associated namespace */
xmlChar *content; /* the content */
struct _xmlAttr *properties; /* properties list */
xmlNs *nsDef; /* namespace definitions on this node */
void *psvi; /* for type/PSVI informations */
unsigned short line; /* line number */
unsigned short extra; /* extra data for XPath/XSLT */
};
能够看到，节点之间是以链表和树两种方式同时组织起来的，next和prev指针能够组成链表，而parent和children能够组织为树。同时更有以下重要元素：
●节点中的文字内容：content；
●节点所属文档：doc；
●节点名字：name；
●节点的namespace：ns；
●节点属性列表：properties；
Xml文档的操作其根本原理就是在节点之间移动、查询节点的各项信息，并进行增加、删除、修改的操作。
xmlDocSetRootElement函数能够将一个节点配置为某个文档的根节点，这是将文档和节点连接起来的重要手段，当有了根结点以后，任何子节点就能够依次连接上根节点，从而组织成为一个xml树。
2.6 节点集合类型xmlNodeSet、指针xmlNodeSetPtr
节点集合代表一个由节点组成的变量，节点集合只作为Xpath的查询结果而出现（XPATH 的介绍见后面），因此被定义在xpath.h中，其定义如下：
/*
* A node-set (an unordered collection of nodes without duplicates).
*/
typedef struct _xmlNodeSet xmlNodeSet;
typedef xmlNodeSet *xmlNodeSetPtr;
struct _xmlNodeSet {
int nodeNr; /* number of nodes in the set */
int nodeMax; /* size of the array as allocated */
xmlNodePtr *nodeTab; /* array of nodes in no particular order */
/* @@ with_ns to check wether namespace nodes should be looked at @@ */ };
能够看出，节点集合有三个成员，分别是节点集合的节点数、最大可容纳的节点数，连同节点数组头指针。对节点集合中各个节点的访问方式很简单，如下：
xmlNodeSetPtr nodeset = XPATH查询结果;
for (int i = 0; i nodeNr; i++)
{
nodeset->nodeTab;
}
注意，libxml2是个c函数库，因此其函数和数据类型都使用c语言的方式来处理。假如是c++，我想我宁愿用STL中的vector来表示一个节点集合更好，而且没有内存泄漏或溢出的担忧。
3. 简单xml操作例子
了解以上基本知识之后，就能够进行一些简单的xml操作了。当然，还没有涉及到内码转换（使得xml中能够处理中文）、xpath等较复杂的操作。
3.1 创建xml文档
有了上面的基础，创建一个xml文档显得很简单，其流程如下：
l 用xmlNewDoc函数创建一个文档指针doc；
l 用xmlNewNode函数创建一个节点指针root_node；
l 用xmlDocSetRootElement将root_node配置为doc的根结点；
l 给root_node添加一系列的子节点，并配置子节点的内容和属性；
l 用xmlSaveFile将xml文档存入文档；
l 用xmlFreeDoc函数关闭文档指针，并清除本文档中任何节点动态申请的内存。注意，有多种方式能够添加子节点：第一是用xmlNewTextChild直接添加一个文本子节点；第二是先创建新节点，然后用xmlAddChild将新节点加入上层节点。
源代码文档是CreateXmlFile.cpp，如下：
/********************************************************************
created: 2007/11/09
created: 9:11:2007 15:34
filename: CreateXmlFile.cpp
author: Wang xuebin
depend: libxml2.lib
build: nmake TARGET_NAME=CreateXmlFile
purpose: 创建一个xml文档
*********************************************************************/
#include
#include
#include
#include
int main()
{
//定义文档和节点指针
xmlDocPtr doc = xmlNewDoc(BAD_CAST"1.0");
xmlNodePtr root_node = xmlNewNode(NULL,BAD_CAST"root");
//配置根节点
xmlDocSetRootElement(doc,root_node);
//在根节点中直接创建节点
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode1", BAD_CAST "newNode1 content");
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode2", BAD_CAST "newNode2 content");
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode3", BAD_CAST "newNode3 content");
//创建一个节点，配置其内容和属性，然后加入根结点
xmlNodePtr node = xmlNewNode(NULL,BAD_CAST"node2");
xmlNodePtr content = xmlNewText(BAD_CAST"NODE CONTENT");
xmlAddChild(root_node,node);
xmlAddChild(node,content);
xmlNewProp(node,BAD_CAST"attribute",BAD_CAST "yes");
//创建一个儿子和孙子节点
node = xmlNewNode(NULL, BAD_CAST "son");
xmlAddChild(root_node,node);
xmlNodePtr grandson = xmlNewNode(NULL, BAD_CAST "grandson");
xmlAddChild(node,grandson);
xmlAddChild(grandson, xmlNewText(BAD_CAST "This is a grandson node"));
//存储xml文档
int nRel = xmlSaveFile("CreatedXml.xml",doc);
if (nRel != -1)
{
cout一个xml文档被创建,写入"个字节" }
//释放文档内节点动态申请的内存
xmlFreeDoc(doc);
return 1;
}
编译链接命令如下：
nmake TARGET_NAME=CreateXmlFile
然后执行可执行文档CreateXmlFile.exe，会生成一个xml文档CreatedXml.xml，打开后如下所示：
root>
newNode1>newNode1 contentnewNode1>
newNode2>newNode2 contentnewNode2>
newNode3>newNode3 contentnewNode3>
node2 attribute="yes">NODE CONTENTnode2>
son>
grandson>This is a grandson nodegrandson>
son>
root>
最好使用类似XMLSPY这样的工具打开，因为这些工具能够自动整理xml文档的栅格，否则很有可能是没有任何换行的一个xml文档，可读性较差。
3.2 解析xml文档
解析一个xml文档，从中取出想要的信息，例如节点中包含的文字，或某个节点的属性，其流程如下：
l 用xmlReadFile函数读出一个文档指针doc；
l 用xmlDocGetRootElement函数得到根节点curNode；
l curNode->xmlChildrenNode就是根节点的子节点集合；
l 轮询子节点集合，找到所需的节点，用xmlNodeGetContent取出其内容；
l 用xmlHasProp查找含有某个属性的节点；
l 取出该节点的属性集合，用xmlGetProp取出其属性值；
l 用xmlFreeDoc函数关闭文档指针，并清除本文档中任何节点动态申请的内存。注意：节点列表的指针依然是xmlNodePtr，属性列表的指针也是xmlAttrPtr，并没有xmlNodeList或xmlAttrList这样的类型。看作列表的时候使用他们的next和prev链表指针来进行轮询。只有在Xpath中有xmlNodeSet这种类型，其使用方法前面已介绍了。
源代码如下：ParseXmlFile.cpp
/********************************************************************
created: 2007/11/15
created: 15:11:2007 11:47
filename: ParseXmlFile.cpp
author: Wang xuebin
depend: libxml2.lib
build: nmake TARGET_NAME=ParseXmlFile
purpose: 解析xml文档
*********************************************************************/
#include
#include
int main(int argc, char* argv[])
{
xmlDocPtr doc; //定义解析文档指针
xmlNodePtr curNode; //定义结点指针(您需要他为了在各个结点间移动)
xmlChar *szKey; //临时字符串变量
char *szDocName;
if (argc {
printf("Usage: %s docname"n", argv[0]);
return(0);
}
szDocName = argv[1];
doc = xmlReadFile(szDocName,"GB2312",XML_PARSE_RECOVER); //解析文档
//检查解析文档是否成功，假如不成功，libxml将指一个注册的错误并停止。
//一个常见错误是不适当的编码。XML标准文档除了用UTF-8或UTF-16外还可用其他编码保存。
//假如文档是这样，libxml将自动地为您转换到UTF-8。更多关于XML编码信息包含在XML标准中.
if (NULL == doc)
{
fprintf(stderr,"Document not parsed successfully. "n");
return -1;
}
curNode = xmlDocGetRootElement(doc); //确定文档根元素
/*检查确认当前文档中包含内容*/
if (NULL == curNode)
{
fprintf(stderr,"empty document"n");
xmlFreeDoc(doc);
return -1;
}
/*在这个例子中，我们需要确认文档是正确的类型。“root”是在这个示例中使用文档的根类型。*/
if (xmlStrcmp(curNode->name, BAD_CAST "root"))
{
fprintf(stderr,"document of the wrong type, root node != root");
xmlFreeDoc(doc);
return -1;
}
curNode = curNode->xmlChildrenNode;
xmlNodePtr propNodePtr = curNode;
while(curNode != NULL)
{
//取出节点中的内容
if ((!xmlStrcmp(curNode->name, (const xmlChar *)"newNode1")))
{
szKey = xmlNodeGetContent(curNode);
printf("newNode1: %s"n", szKey);
xmlFree(szKey);
}
//查找带有属性attribute的节点
if (xmlHasProp(curNode,BAD_CAST "attribute"))
propNodePtr = curNode;
}
curNode = curNode->next;
}
//查找属性
xmlAttrPtr attrPtr = propNodePtr->properties;
while (attrPtr != NULL)
{
if (!xmlStrcmp(attrPtr->name, BAD_CAST "attribute"))
{
xmlChar* szAttr = xmlGetProp(propNodePtr,BAD_CAST "attribute");
cout xmlFree(szAttr);
}
attrPtr = attrPtr->next;
}
xmlFreeDoc(doc);
return 0;
}
编译链接命令如下：
nmake TARGET_NAME=ParseXmlFile
执行命令如下，使用第一次创建的xml文档作为输入：
ParseXmlFile.exe CreatedXml.xml
观察源代码可发现，任何以查询方式得到的xmlChar*字符串都必须使用xmlFree函数手动释放。否则会造成内存泄漏。
3.3 修改xml文档
有了上面的基础，修改xml文档的内容就很简单了。首先打开一个已存在的xml文档，顺着根结点找到需要添加、删除、修改的地方，调用相应的xml函数对节点进行增、删、改操作。源代码见ChangeXmlFile，编译链接方法如上。执行下面的命令：
ChangeXmlFile.exe CreatedXml.xml
能够得到一个修改后的xml文档ChangedXml.xml，如下：
root>
newNode2>content changednewNode2>
newNode3 newAttr="YES">newNode3 contentnewNode3>
node2 attribute="no">NODE CONTENTnode2>
son>
grandson>This is a grandson nodegrandson>
newGrandSon>new contentnewGrandSon>
root>
需要注意的是，并没有xmlDelNode或xmlRemoveNode函数，我们删除节点使用的是以下一段代码：
if (!xmlStrcmp(curNode->name, BAD_CAST "newNode1"))
{
xmlNodePtr tempNode;
tempNode = curNode->next;
xmlUnlinkNode(curNode);
xmlFreeNode(curNode);
curNode = tempNode;
continue;
}
即将当前节点从文档中断链（unlink），这样本文档就不会再包含这个子节点。这样做需要使用一个临时变量来存储断链节点的后续节点，并记得要手动删除断链节点的内存。
3.4 使用XPATH查找xml文档
简而言之，XPATH之于xml，好比SQL之于关系数据库。要在一个复杂的xml文档中查找所需的信息，XPATH简直是必不可少的工具。XPATH语法简单易学，并且有一个很好的官方教程，见
https://www.doczj.com/doc/a57710482.html,/xxl/XPathTutorial/Output_chi/introduction.html
。这个站点的XML各种教程齐全，并且有包括中文在内的各国语言版本，真是让我喜欢到很！使用XPATH之前，必须首先熟悉几个数据类型和函数，他们是使用XPATH的前提。在libxml2中使用Xpath是很简单的，其流程如下：
l 定义一个XPATH上下文指针xmlXPathContextPtr context，并且使用xmlXPathNewContext函数来初始化这个指针；
l 定义一个XPATH对象指针xmlXPathObjectPtr result，并且使用xmlXPathEvalExpression函数来计算Xpath表达式，得到查询结果，将结果存入对象指针中；
l 使用result->nodesetval得到节点集合指针，其中包含了任何符合Xpath查询结果的节点；
l 使用xmlXPathFreeContext释放上下文指针；
l 使用xmlXPathFreeObject释放Xpath对象指针；
具体的使用方法能够看XpathForXmlFile.cpp的这一段代码，其功能是查找符合某个Xpath 语句的对象指针：
xmlXPathObjectPtr getNodeSet(xmlDocPtr doc, const xmlChar *szXpath)
{
xmlXPathContextPtr context; //XPATH上下文指针
xmlXPathObjectPtr result; //XPATH对象指针，用来存储查询结果
context = xmlXPathNewContext(doc); //创建一个XPath上下文指针
if (context == NULL)
{
printf("context is NULL"n");
return NULL;
}
result = xmlXPathEvalExpression(szXpath, context); //查询XPath表达式，得到一个查询结果
xmlXPathFreeContext(context); //释放上下文指针
if (result == NULL)
{
printf("xmlXPathEvalExpression return NULL"n");
return NULL;
}
if (xmlXPathNodeSetIsEmpty(result->nodesetval)) //检查查询结果是否为空
{
xmlXPathFreeObject(result);
printf("nodeset is empty"n");
return NULL;
}
return result;
}
一个完整的使用Xpath的例子在代码XpathForXmlFile.cpp中，他查找一个xml文档中符合"/root/node2[@attribute='yes']"语句的结果，并且将找到的节点的属性和内容打印出来。编译链接命令如下：
nmake TARGET_NAME=XpathForXmlFile
执行方式如下：
XpathForXmlFile.exe CreatedXml.xml
观察结果能够看出找到了一个节点，即root下面node2节点，他的attribute属性值正好等于yes。更多关于Xpath的内容能够参考XPATH官方手册。只有掌控了XPATH，才掌控了使用大型XML文档的方法，否则每寻找一个节点都要从根节点找起，会把人累死。
4. 用ICONV解决XML中的中文问题
Libxml2中默认的内码是UTF-8，任何使用libxml2进行处理的xml文档，必须首先显式或默认的转换为UTF-8编码才能被处理。
要在xml中使用中文，就必须能够在UTF-8和GB2312内码（较常用的一种简体中文编码）之间进行转换。Libxml2提供了默认的内码转换机制，并且在libxml2的Tutorial中有一个例子，事实证实这个例子并不适合用来转换中文。
一、什么是 XML？ XML 被设计用来传输和存储数据。它也是元标记语言，即定义了用于定义其他与特定领域有关的、语义的、结构化的标记语言的句法语言。 准备一个解析用的xml如下：
所有的
) 4、XML 标签对大小写敏感 比如和是不一样的 5、XML 属性值必须加引号 < account name=laoz>这样会报错的,必须"laoz"才行 二、Python 对 XML 的解析 Python 有三种方法解析 XML，SAX，DOM，以及 ElementTree。 DOM会把整个XML读入内存，解析为树，因此占用内存大，解析慢，优点是可以任意遍历树的节点。SAX是流模式，边读边解析，占用内存小，解析快，缺点是我们需要自己处理事件。 1、利用DOM解析XML 一个 DOM 的解析器在解析一个 XML 文档时，一次性读取整个文档，把文档中所有元素保存在内存中的一个树结构里，之后你可以利用DOM 提供的不同的函数来读取或修改文档的内容和结构，也可以把修改过的内容写入xml文件。
学习：Dom4j 1、DOM4J简介 DOM4J是https://www.doczj.com/doc/a57710482.html, 出品的一个开源XML 解析包。DOM4J应用于Java 平台，采用了Java 集合框架并完全支持DOM，SAX 和JAXP。 DOM4J 使用起来非常简单。只要你了解基本的XML-DOM 模型，就能使用。 Dom：把整个文档作为一个对象。 DOM4J 最大的特色是使用大量的接口。它的主要接口都在org.dom4j里面定义：
接口之间的继承关系如下： interface https://www.doczj.com/doc/a57710482.html,ng.Cloneable interface org.dom4j.Node interface org.dom4j.Attribute interface org.dom4j.Branch interface org.dom4j.Document interface org.dom4j.Element interface org.dom4j.CharacterData interface org.dom4j.CDATA interface https://www.doczj.com/doc/a57710482.html,ment interface org.dom4j.Text interface org.dom4j.DocumentType interface org.dom4j.Entity interface org.dom4j.ProcessingInstruction 2、XML文档操作1 2.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();
XML报文解析测试 在平时工作中，难免会遇到把 XML 作为数据存储格式。面对目前种类繁多的解决方案，哪个最适合我们呢？在这篇文章中，我对这四种主流方案做一个不完全评测，仅仅针对遍历 XML 这块来测试，因为遍历 XML 是工作中使用最多的（至少我认为）。 预备 测试环境： AMD 毒龙1.4G OC 1.5G、256M DDR333、Windows2000 Server SP4、Sun JDK 1.4.1+Eclipse 2.1+Resin 2.1.8，在 Debug 模式下测试。 XML 文件格式如下： ＜?xml version="1.0" encoding="GB2312"?＞ ＜RESULT＞ ＜VALUE＞ ＜NO＞A1234＜/NO＞ ＜ADDR＞四川省XX县XX镇XX路X段XX号＜/ADDR＞ ＜/VALUE＞ ＜VALUE＞ ＜NO＞B1234＜/NO＞ ＜ADDR＞四川省XX市XX乡XX村XX组＜/ADDR＞ ＜/VALUE＞ ＜/RESULT＞ 测试方法： 采用 JSP 端调用Bean（至于为什么采用JSP来调用，请参考： https://www.doczj.com/doc/a57710482.html,/rosen/archive/2004/10/15/138324.aspx），让每一种方案分别解析10K、100K、1000K、10000K的 XML 文件，计算其消耗时间（单位:毫秒）。 JSP 文件： ＜%@ page contentType="text/html; charset=gb2312" %＞ ＜%@ page import="com.test.*"%＞ ＜html＞ ＜body＞ ＜% String args[]={""}; MyXMLReader.main(args); %＞
1.详解 1）DOM（JAXP Crimson解析器） DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。 2）SAX 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解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。 3）JDOM https://www.doczj.com/doc/a57710482.html, 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应用程序来说当然是有用的，并且大多数开
DOM解析器是通过将XML文档解析成树状模型并将其放入内存来完成解析工作的，而后对文档的操作都是在这个树状模型上完成的。这个在内存中的文档树将是文档实际大小的几倍。这样做的好处是结构清除、操作方便，而带来的麻烦就是极其耗费系统资源。而SAX正好克服了DOM的缺点，分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中，这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。 选择DOM 还是选择SAX，这取决于下面几个因素： 应用程序的目的：如果打算对数据作出更改并将它输出为XML，那么在大多数情况下，DOM 是适当的选择。并不是说使用SAX 就不能更改数据，但是该过程要复杂得多，因为您必须对数据的一份拷贝而不是对数据本身作出更改。 数据容量：对于大型文件，SAX 是更好的选择。 数据将如何使用：如果只有数据中的少量部分会被使用，那么使用SAX 来将该部分数据提取到应用程序中可能更好。另一方面，如果您知道自己以后会回头引用已处理过的大量信息，那么SAX 也许不是恰当的选择。 对速度的需要：SAX 实现通常要比DOM 实现更快。 基于上面的分析，在基于Android系统的内存和CPU资源比较有限的手持设备上，只要我们不需要修改XML数据或者随机的访问XML数据，SAX尽管可能需要更多的编码工作，但是为了更小的内存和CPU 消耗，还是值得的。 另外，Android SDK中已经包含了JAXP对应的javax.xml.parsers包，和SAX对应org.xml.sax（当然DOM对应的org.w3c.dom包也包含在内），加上Android还提供了android.sax这样的包来方便SAX Handle的开发，基于JAXP和SAX这样的标准方法来开发不仅复杂度不高，即使出现问题在讨论组中寻求解决方案也是比较容易的。 android 中的xml解析应该是和java中一条道路主要分为sax 解析和的Dom 解析。 如下的介绍的相关的包和类均为android 环境下： sax解析对应为： org\xml\sax 包：xml解析 javax.xml.parsers.SAXParserFactory javax.xml.parsers.SAXParser 两个主要用于SAXParser的上下文建立
一选择题 1.W3C的DOM核心定义（A）的最小集合 A.访问和操纵文档对象的接口 B.用XML解析器实现JA V A对象 C.创建“活的”HTML页面的惯例和过程 D.多个文档树 2.下面哪一个选项只包含Schema中的简单类型（D） A.anvURL.char,encoding,UTF-8 B.fullname,double,long,int C.TOKEN,timestamp,range,char D.byte,duration,ENTITY,NMTOKEN 3.对一个复杂结构的呈现时，使用元素而不使用属性的原因是因为 解析：属性取值只能为简单类型，不能包含子元素。 4.在下面XML文档解析过程中，有多少个各startElement 解析：有多少个元素就有多少个startELEMENT 5.下面的XML片断中，元素item1属于（B）名字空间
MySAX.java package org.lxh.xml.sax; import org.xml.sax.*; import org.xml.sax.helpers.*; public class MySAX extends DefaultHandler{ public void startDocument()throws SAXException{ System.out.println(""); } public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException{ System.out.print("<"); System.out.print(qName); if(attributes != null){//如果存在了属性 for(int x = 0;x
XML解析方式介绍 1.DOM4J(Document Object Model for Java) 虽然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. 【优点】 ①大量使用了Java集合类，方便Java开发人员，同时提供一些提高性能的替代方法。 ②支持XPath。 ③有很好的性能。 【缺点】 ①大量使用了接口，API较为复杂。 2.SAX（Simple API for XML) SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。 选择DOM还是选择SAX？对于需要自己编写代码来处理XML文档的开发人员来说，选择DOM还是SAX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档，而SAX 采用的是事件模型。
XML文件学习总结 掌握了XML文件解析的常用的4中方式：DOM解析、SAX 解析、STAX解析以及DOM4j解析XML文件。 一、DOM 解析xml文件 public List 1）DOM(JAXP Crimson解析器) DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM 是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。 2）SAX 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解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。 3）JDOM https://www.doczj.com/doc/a57710482.html,/ JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。 JDOM与DOM主要有两方面不同。首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。 SAX是一个用于处理XML事件驱动的“推”模型，虽然它不是 W3C标准，但它却是一个得到了广泛认可的API。SAX解析器不像DOM那样建立一个完整的文档树，而是在读取文档时激活一系列事件，这些事件被推给事件处理器，然后由事件处理器提供对文档内容的访问。 常见的事件处理器有三种基本类型： ● 用于访问XML DTD内容的DTDHandler； ● 用于低级访问解析错误的ErrorHandler； ● 用于访问文档内容的ContentHandler，这也是最普遍使用的事件处理器。 图 2显示了SAX解析器如何通过一个回调机制报告事件。解析器读取输入文档并在处理文档时将每个事件推给文档处理器（MyContentHandler）。 与DOM相比，SAX解析器能提供更好的性能优势，它提供对XML文档内容的有效低级访问。SAX模型最大的优点是内存消耗小，因为整个文档无需一次加载到内存中，这使SAX解析器可以解析大于系统内存的文档。另外，你无需像在DOM中那样为所有节点创建对象。最后，SAX“推”模型可用于广播环境，能够同时注册多个ContentHandler，并行接收事件，而不是在一个管道中一个接一个地进行处理。 SAX的缺点是你必须实现多个事件处理程序以便能够处理所有到来的事件，同时你还必须在应用程序代码中维护这个事件状态，因为SAX解析器不能交流元信息，如DOM的父/子支持，所以你必须跟踪解析器处在文档层次的哪个位置。如此一来，你的文档越复杂，你的应用逻辑就越复杂。虽然没有必要一次将整个文档加载到内存中，但SAX解析器仍然需要解析整个文档，这点和DOM一样。 也许SAX面临的最大问题是它没有内置如XPath所提供的那些导航支持。再加上它的单遍解析，使它不能支持随机访问。这一限制也表现在名字空间上： 对有继承名字空间的元素不做注解。这些限制使SAX很少被用于操作或修改文档。 那些只需要单遍读取内容的应用程序可以从SAX解析中大大受益。很多B2B和EAI应用程序将XML用做封装格式，接收端用这种格式简单地接收所有数据。这就是SAX明显优于DOM的地方：因高效而获得高吞吐率。在SAX 2.0 中有一个内置的过滤机制，可以很轻松地输出一个文档子集或进行简单的文档转换。 这个是主类： import java.io.StringReader; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.xml.sax.InputSource; import org.xml.sax.XMLReader; import android.app.Activity; import android.os.Bundle; import android.util.Log; import android.widget.TextView; public class ParsingXML extends Activity { private final String MY_DEBUG_TAG = "WeatherForcaster"; public void onCreate(Bundle icicle) { super.onCreate(icicle); TextView tv = new TextView(this); String xml = " Xml文件： Java解析XML文件 ========================================== xml文件 ＜?xml version="1.0" encoding="GB2312"?＞ ＜RESULT＞ ＜VALUE＞ ＜NO＞A1234＜/NO＞ ＜ADDR＞四川省XX县XX镇XX路X段XX号＜/ADDR＞ ＜/VALUE＞ ＜VALUE＞ ＜NO＞B1234＜/NO＞ ＜ADDR＞四川省XX市XX乡XX村XX组＜/ADDR＞ ＜/VALUE＞ ＜/RESULT＞ ========================================== 1）DOM（JAXP Crimson解析器） DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。 import java.io.*; import java.util.*; import org.w3c.dom.*; import javax.xml.parsers.*; public class MyXMLReader{ public static void main(String arge[]){ long lasting =System.currentTimeMillis(); try{ File f=new File("data_10k.xml"); DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance(); DocumentBuilder builder=factory.newDocumentBuilder(); Document doc = builder.parse(f); NodeList nl = doc.getElementsByT agName("VALUE"); for (int i=0;i＜nl.getLength();i++){ System.out.print("车牌号码:" + xml的四种解析方法及源代码(SAX、DOM、JDOM、DOM4J) 第一种：SAX解析 SAX处理机制：SAX是一种基于事件驱动的API。利用SAX解析XML文档，牵涉到两个部分：解析器和事件处理器。解析器负责读取XML文档，并向事件处理器发生事件，如元素开始和元素结束事件；而事件处理器则负责对事件做出响应，对传递的XML数据进行处理。 测试用的xml文件：db.xml Xml代码 SAX解析实例一 org.xml.sax.DefalutHandler类: 可以扩展该类，给出自己的解析实现SAXPrinter.java Java代码 import java.io.File; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHandler; public class SAXPrinter extends DefaultHandler { /** *//** * 文档开始事件 */ public void startDocument() throws SAXException { System.out.println(""); SAX解析XML（自主判断） 实现方法一： ContentHandler接口：接收文档逻辑内容的通知的处理器接口 import org.xml.sax.Attributes; import org.xml.sax.ContentHandler; import org.xml.sax.Locator; import org.xml.sax.SAXException; class MyContentHandler implements ContentHandler{ StringBuffer jsonStringBuffer ; int frontBlankCount = 0; public MyContentHandler(){ jsonStringBuffer = new StringBuffer(); } /* * 接收字符数据的通知。 * 在DOM中ch[begin:end] 相当于Text节点的节点值（nodeV alue） */ @Override public void characters(char[] ch, int begin, int length) throws SAXException { StringBuffer buffer = new StringBuffer(); for(int i = begin ; i < begin+length ; i++){ switch(ch[i]){ case '\\':buffer.append("\\\\");break; case '\r':buffer.append("\\r");break; case '\n':buffer.append("\\n");break; case '\t':buffer.append("\\t");break; case '\"':buffer.append("\\\"");break; default : buffer.append(ch[i]); } } System.out.println(this.toBlankString(this.frontBlankCount)+ ">>> characters("+length+"): "+buffer.toString()); } /* * 接收文档的结尾的通知。 */ @Override public void endDocument() throws SAXException { System.out.println(this.toBlankString(--this.frontBlankCount)+ ">>> end document"); 查找结点，读取结点属性------------------------------------------------------ 获取结点的属性------------------------------------- 设置结点的属性------------------------------------------------ 给结点添加新属性------------------------------------------- 设置一个结点的内容---------------------------------------------------- 添加新节点---------------------------------------------------- 编码问题------------------------------------------------------------------ XML树： jdom学习读取XML文件 用JDOM读取XML文件需先用org.jdom.input.SAXBuilder对象的build()方法创建Document对象,然后用Document类、Element类等的方法读取所需的内容。 例如： XML的四种解析器(dom,sax,jdom,dom4j)原理及性能比较[收藏]
SAX解析XML原理
Android SAX 方式解析XML 字符串
使用DOM4j解析xml文件
Java解析XML文件
xml的四种解析方法及源代码
SAX解析XML(自主判断)
xml文件解析
jdom读取解析XML文件
相关主题
文本预览