xml 数据格式作为当今WEB开发的重要数据格式之一，应用很是普及，在文章 <acl 之 xml 流解析器> 中， 专门讲述了 acl 库中是如何实现流式 xml 数据解析的，在 acl_cpp 库中利用 c++ 语言特色对 acl 中的 xml 流式解析进行了进一步封装，从而更加方便用户使用，其中主要涉及到两个类：xml 类和 xml_node 类，如今分别就这两个类的函数功能作一简单介绍。node
1、解析过程当中的用法c++
一、 xml 类中的主要方法以下：数组
/**
* 以流式方式循环调用本函数添加 XML 数据，也能够一次性添加
* 完整的 XML 数据，若是是重复使用该 XML 解析器解析多个 XML
* 对象，则应该在解析下一个 XML 对象前调用 reset() 方法来清
* 除上一次的解析结果
* @param data {const char*} xml 数据
*/
void update(const char* data);
/**
* 从 XML 对象中取得某个标签名的全部结点集合
* @param tag {const char*} 标签名(不区分大小写)
* @return {const std::vector<xml_node*>&} 返回结果集的对象引用，
* 若是查询结果为空，则该集合为空，即：empty() == true
* 注：返回的数组中的 xml_node 结点数据能够修改，但不能删除该结点，
* 由于该库内部有自动删除的机制
*/
const std::vector<xml_node*>& getElementsByTagName(const char* tag) const;
/**
* 从 xml 对象中得到全部的与给定多级标签名相同的 xml 结点的集合
* @param tags {const char*} 多级标签名，由 '/' 分隔各级标签名，如针对 xml 数据：
* <root> <first> <second> <third name="test1"> text1 </third> </second> </first> ...
* <root> <first> <second> <third name="test2"> text2 </third> </second> </first> ...
* <root> <first> <second> <third name="test3"> text3 </third> </second> </first> ...
* 能够经过多级标签名：root/first/second/third 一次性查出全部符合条件的结点
* @return {const std::vector<xml_node*>&} 符合条件的 xml 结点集合,
* 若是查询结果为空，则该集合为空，即：empty() == true
* 注：返回的数组中的 xml_node 结点数据能够修改，但不能删除该结点，
* 由于该库内部有自动删除的机制
*/
const std::vector<xml_node*>& getElementsByTags(const char* tags) const;
/**
* 从 xml 对象中得到全部的与给定属性名 name 的属性值相同的 xml 结点元素集合
* @param name {const char*} 属性名为 name 的属性值
* @return {const std::vector<xml_node*>&} 返回结果集的对象引用，
* 若是查询结果为空，则该集合为空，即：empty() == true
* 注：返回的数组中的 xml_node 结点数据能够修改，但不能删除该结点，
* 由于该库内部有自动删除的机制
*/
const std::vector<xml_node*>& getElementsByName(const char* value) const;
/**
* 从 xml 对象中得到全部给定属性名及属性值的 xml 结点元素集合
* @param name {const char*} 属性名
* @param value {const char*} 属性值
* @return {const std::vector<xml_node*>&} 返回结果集的对象引用，
* 若是查询结果为空，则该集合为空，即：empty() == true
*/
const std::vector<xml_node*>& getElementsByAttr(const char* name, const char* value) const;
/**
* 从 xml 对象中得到指定 id 值的 xml 结点元素
* @param id {const char*} id 值
* @return {const xml_node*} xml 结点元素, 若返回 NULL 则表示没有符合
* 条件的 xml 结点, 返回值不须要释放
*/
const xml_node* getElementById(const char* id) const;
/**
* 开始遍历该 xml 对象并得到第一个结点
* @return {xml_node*} 返回空表示该 xml 对象为空结点
* 注：返回的结点对象用户不能手工释放，由于该对象被
* 内部库自动释放
*/
xml_node* first_node(void);
/**
* 遍历该 xml 对象的下一个 xml 结点
* @return {xml_node*} 返回空表示遍历完毕
* 注：返回的结点对象用户不能手工释放，由于该对象被
* 内部库自动释放
*/
xml_node* next_node(void);
二、xml_node 类中的主要方法网络
/**
* 取得本 XML 结点的标签名
* @return {const char*} 返回 XML 结点标签名，若是返回空，则说明
* 不存在标签？xxxx，以防万一，调用者须要判断返回值
*/
const char* tag_name(void) const;
/**
* 若是该 XML 结点的 ID 号属性不存在，则返回空指针
* @return {const char*} 当 ID 属性存在时返回对应的值，不然返回空
*/
const char* id(void) const;
/**
* 返回该 XML 结点的正文内容
* @return {const char*} 返回空说明没有正文内容
*/
const char* text(void) const;
/**
* 返回该 XML 结点的某个属性值
* @param name {const char*} 属性名
* @return {const char*} 属性值，若是返回空则说明该属性不存在
*/
const char* attr_value(const char* name) const;
/**
* 遍历结点的全部属性时，须要调用此函数来得到第一个属性对象
* @return {const xml_attr*} 返回第一个属性对象，若为空，则表示
* 该结点没有属性
*/
const xml_attr* first_attr(void) const;
/**
* 遍历结点的全部属性时，调用本函数得到下一个属性对象
* @return {const xml_attr*} 返回下一下属性对象，若为空，则表示
* 遍历完毕
*/
const xml_attr* next_attr(void) const;
/**
* 得到本结点的父级结点对象的引用
* @return {xml_node&}
*/
xml_node& get_parent(void) const;
/**
* 得到本结点的第一个子结点，须要遍历子结点时必须首先调用此函数
* @return {xml_node*} 返回空表示没有子结点
*/
xml_node* first_child(void);
/**
* 得到本结点的下一个子结点
* @return {xml_node*} 返回空表示遍历过程结束
*/
xml_node* next_child(void);
/**
* 返回该 xml 结点的下一级子结点的个数
* @return {int} 永远 >= 0
*/
int children_count(void) const;
上面列出的函数接口比较多，还有一些未列出，用户在用时难免会被这么多接口搞晕，下面就写一个简单的例子说明如何使用这两个类。app
#include <vector>
#include "xml.hpp"
static void test1(void)
{
const char *data =
"<?xml version=\"1.0\"?>\r\n"
"<?xml-stylesheet type=\"text/xsl\"\r\n"
" href=\"http://docbook.sourceforge.net/release/xsl/current/manpages/docbook.xsl\"?>\r\n"
"<!DOCTYPE refentry PUBLIC \"-//OASIS//DTD DocBook XML V4.1.2//EN\"\r\n"
" \"http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd\" [\r\n"
" <!ENTITY xmllint \"<command>xmllint</command>\">\r\n"
"]>\r\n"
"<root>test\r\n"
" <!-- <edition> - <!--0.5--> - </edition> -->\r\n"
" <user name = user_name>zsx\r\n"
" <age>38</age>\r\n"
" </user>\r\n"
"</root>\r\n"
"<!-- <edition><!-- 0.5 --></edition> -->\r\n"
"<!-- <edition>0.5</edition> -->\r\n"
"<!-- <edition> -- 0.5 -- </edition> -->\r\n"
"<root name='root' id='root_id'>test</root>\r\n";
acl::xml xml; // xml 解析器对象定义
xml.update(data); // 将 xml 数据输入并进行解析
// 根据 xml 标签名得到全部相应的 xml 结点对象
const std::vector<acl::xml_node*>& elements = xml.getElementsByTagName("user");
if (!elements.empty()) {
// 遍历查询结果集
std::vector<acl::xml_node*>::const_iterator cit = elements.begin();
for (; cit != elements.end(); cit++) {
acl::xml_node *node = *cit;
printf("tagname: %s, text: %s\n", node->tag_name() ? node->tag_name() : "",
node->text() ? node->text() : "");
// 遍历一个结点的全部属性
const acl::xml_attr* attr = (*cit)->first_attr(); // 取得结点的第一个属性
while (attr)
{
printf("test1: %s=%s\r\n", attr->get_name(), attr->get_value());
attr = (*cit)->next_attr(); // 取得结点的下一个属性
}
}
}
}
上面的例子中是一次性将 xml 数据传给 acl::xml 解析器进行解析的，固然也能够采用以下的方法：函数
const char* ptr;
char buf[2];
ptr = data;
while (*ptr) {
buf[0] = *ptr++;
buf[1] = 0;
xml.update(buf);
}
每次传给xml解析器一个字节的解析效率比较低，这只是展现 acl_cpp 中的 xml 的流式解析器的特色，这对于网络通讯中尤为是 HTTP 数据流中针对 xml 数据流的解析比较有帮助。ui
另外，xml 解析器还给出一个用于遍历全部 xml 结点对象的函数：first_node 和 next_node，经过这两个函数能够得到一个完整的 xml 树的全部结点，示例以下：.net
acl::xml xml;
...
acl::xml_node* node = xml.first_node(); // 取得第一个 xml 结点
while (node) {
printf("tag: %s\r\n", node->tag_name());
node = xml.next_node(); // 取得下一个 xml 结点
}
不只 xml 树对象有遍历的功能函数，xml_node 结点对象也有遍历其下一级子结点的功能函数，示例以下：指针
acl::xml xml;
...
acl::xml_node* node = xml.first_node(); //取得 xml 对象的第一个xml_node 结点
if (node) {
acl::xml_node* child = node->first_child(); // 取得该 xml_node 结点的第一个第一级子结点
while (child) {
printf("child tag: %s\r\n", child->tag_name());
child = node->next_child(); // 取得该 xml_node 结点的下一下第一级子结点
}
}
2、生成 xml 字符串的用法code
为了便于生成 xml 对象，acl_cpp 的 xml 模块增长了相应的函数接口用于生成 xml 数据流，下面介绍如何生成 xml 数据流。
一、在 xml 类中相关函数接口：
/**
* 建立一个 xml_node 结点对象
* @param tag {const char*} 标签名
* @param text {const char*} 文本字符串
* @return {xml_node*} 新产生的 xml_node 对象不须要用户手工释放，由于在
* xml 对象被释放时这些结点会自动被释放，固然用户也能够在不用时调用
* reset 来释放这些 xml_node 结点对象
*/
xml_node& create_node(const char* tag, const char* text = NULL);
/**
* 得到根结点对象
* @return {xml_node&}
*/
xml_node& get_root();
在 xml 解析器中，有一个虚拟的 xml 根结点，这个结点自己不存任何 xml 数据，但全部的 xml_node 结点都属于这个根结点的子结点。
二、在 xml_node 类中相关函数接口：
/**
* 添加 XML 结点属性
* @param name {const char*} 属性名
* @param value {const char*} 属性值
* @return {xml_node&}
*/
xml_node& add_attr(const char* name, const char* value);
/**
* 设置 xml 结点的文本内容
* @param str {const char*} 字符串内容
* @return {xml_node&}
*/
xml_node& set_text(const char* str);
/**
* 给本 xml 结点添加 xml_node 子结点对象
* @param child {xml_node*} 子结点对象
* @return {xml_node&} return_child 为 true 返回子结点的引用，
* 不然返回本 xml 结点引用
*/
xml_node& add_child(xml_node* child, bool return_child = false);
/**
* 给本 xml 结点添加 xml_node 子结点对象
* @param child {xml_node&} 子结点对象
* @return {xml_node&} return_child 为 true 返回子结点的引用，
* 不然返回本 xml 结点引用
*/
xml_node& add_child(xml_node& child, bool return_child = false);
/**
* 给本 xml 结点添加 xml_node 子结点对象
* @param tag {const char* tag} 子结点对象的标签名
* @return {xml_node&} return_child 为 true 返回子结点的引用，
* @param str {const char*} 文本字符串
* 不然返回本 xml 结点引用
*/
xml_node& add_child(const char* tag, bool return_child = false,
const char* str = NULL);
下面举几个简单的例子来讲明如何生成 xml 数据流：
acl::xml xml;
acl::xml_node& root = xml.get_root(); // 得到 xml 的根结点
acl::xml_node* node1, *node2, *node11;
// 建立一个 xml_node 结点
node1 = &xml.create_node("test1");
// 给 node1 结点添加属性值
(*node1).add_attr("name1_1", "value1_1")
.add_attr("name1_2", "value1_2")
.add_attr("name1_3", "value1_3");
// 将 node1 作为 xml 根结点的第一个子结点
root.add_child(node1);
// 建立一个 xml_node 结点
node11 = &xml.create_node("test11");
// 给 node11 结点添加属性值
(*node11).add_attr("name11_1", "value11_1")
.add_attr("name11_2", "value11_2")
.add_attr("name11_3", "value11_3");
// 将 node11 作为 node1 根结点的第一个子结点
node1.add_child(node11);
// 建立一个 xml_node 结点
node2 = &xml.create_node("test2");
// 给 node2 结点添加属性值
(*node2).add_attr("name2_1", "value2_1")
.add_attr("name2_2", "value2_2")
.add_attr("name2_3", "value2_3");
// 将 node2 作为 xml 根结点的第二个子结点
root.add_child(node2);
acl::string buf("<?xml version=\"1.0\"?>");
xml.build_xml(buf); // 生成 xml 数据流，注：在 函数 build_xml 内部对于缓冲区 buf 的处理方式是 append 模式，即若是在 buf 里有数据，build_xml 只是在 buf 原来的数据尾部追加数据而已
printf("xml: %s\r\n", buf.c_str()); // 打印生成的 xml 数据
其实，上面的示例还有一个更加简洁的写法，以下：
acl::xml_node& root = xml.get_root(); // 得到 xml 的根结点
acl::xml_node* node1, *node2, *node11;
// 建立一个 xml_node 结点
xml.get_root()
.add_child("test1", true) // 因第二个参数为 true，因此 add_child 函数返回新建立子结点的引用
.add_attr("name1_1", "value1_1") // 给 test1 结点添加属性
.add_attr("name1_2", "value1_2")
.add_attr("name1_3", "value1_3");
.add_child("test11", true) // 给 test1 结点添加一个标签值为 test11 的子结点
.add_attr("name11_1", "value11_1") // 给 test11 子结点添加属性
.add_attr("name11_2", "value11_2")
.add_attr("name11_3", "value11_3");
.get_parent() // 返回 test11 结点的父结点的引用，即返回 test1 结点
.get_parent() // 返回 test1 结点的引用即返回 xml 的 root 结点
.add_child("test2", true) // 给 xml 根结点添加 test2 子结点
.add_attr("name2_1", "value2_1") // 给 test2 子结点添加属性
.add_attr("name2_2", "value2_2")
.add_attr("name2_3", "value2_3");
能够看出，第二种写法更加简洁有效，同时逻辑关系更为清晰，有种一鼓作气的感受，呵呵。固然，读者能够根据本身的习惯使用其中任意一种写法。另外，你们仔 细查看 xml_node 类的声明可能会看出，该类的构造函数和析构函数是私有的，这意味着用户不能使用 new 或delete 来手工建立和销毁 xml_node 类对象，同时不能如 acl::xml_node node 这样定义对象，这就说，xml_node 对象只能是由 acl::xml 类对象或 acl::xml_node 类对象来建立，同时对全部 xml_node 类对象的销毁都是在 acl::xml 类对象内部自动完成的，即当 xml 对象销毁时，这些内部动态建立的 xml_node 结点会被自动销毁；若是用户想在 acl::xml 类对象销毁以前提早销毁全部的 acl::xml_node 类对象，则用户能够手工调用 acl::xml类中的 reset() 方法来达到此目的。
使用 xml 的例子在：samples/xml 目录下
acl_cpp 下载：http://sourceforge.net/projects/acl/
原文地址：http://zsxxsz.iteye.com/blog/1506643
QQ 群：242722074