Chinaunix首页 | 论坛 | 博客
  • 博客访问: 782493
  • 博文数量: 611
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 3792
  • 用 户 组: 普通用户
  • 注册时间: 2016-11-11 09:12
  • 认证徽章:
个人简介

To be a better coder

文章分类

全部博文(611)

文章存档

2019年(167)

2018年(217)

2017年(146)

2016年(82)

分类: LINUX

2019-09-05 17:44:14

https://blog.csdn.net/zhangna20151015/article/details/51332550

本文着重介绍解析xml的libxml2库的安装及使用,举例说明创建和解析xml的过程。是针对C语言开发人员使用


libxml2的安装

  关于libxml2的介绍请参考官方网址http://xmlsoft.org/,下载最新的libxml2库http://xmlsoft.org/downloads.html

具体安装步骤:
1、解压:$tar zxvf  libxml2-2.9.1.tar.gz
2、进入解压后的安装目录:$cd  libxml2-2.9.1
3、安装三部曲:

     1)$./configure
              2)$make
              3)$make install
安装完毕。

注意:libxml2默认安装到/usr/local/include/libxml2目录下

当然,如果你是centos系统也可以在命令行模式下,输入:yum install libxml

二、Libxml2中的数据类型和函数

一个函数库中可能有几百种数据类型及几千个函数,不过记住大师的话,90%的功能都是由30%的内容提供的。对于libxml2(http://blog.csdn.net/shanzhizi),我认为搞懂以下的数据类型和函数就足够了。

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能组织为树。同时更有以下重要元素:
l         节点中的文字内容:content;
l         节点所属文件:doc;
l         节点名字:name;
l         节点的namespace:ns;
l         节点属性列表: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来表示一个节点集合更好,而且没有内存泄漏或溢出的担忧。

三、xml文档结构


  xml按照树形结构进行存储,节点分为元素和文本,必须有根节点。如下的xml文件:

  1. xml version="1.0" encoding="UTF-8"?>
  2. <phone_books>
  3. <phone id="1">
  4. <name>Ankername>
  5. <tel>18923873456tel>
  6. <address>Shenzhengaddress>
  7. phone>
  8. <phone id="2">
  9. <name>Jermeyname>
  10. <tel>18623873456tel>
  11. <address>Beijingaddress>
  12. phone>
  13. <phone id="3">
  14. <name>Liliname>
  15. <tel>13223873456tel>
  16. <address>Shanghaiaddress>
  17. phone>
  18. phone_books>

四、测试例子

关于libxml2的提供的接口,可以参考http://blog.csdn.net/shanzhizi/article/details/7726679。libxml2常用的接口如下:

  内部字符类型:xmlChar,定义为:typedef unsigned char xmlChar,用无符号型的char方便表示utf-8编码。libxml2提供了一个宏进行转换,#define BAD_CAST (xmlChar *)。

     文档类型xmlDoc,指针类型xmlDocPtr。xmlDoc是个struct,保存了一个xml的相关信息,例如文件名、文件类型、子节点等等;xmlDocPtr等于xmlDoc*。

  xmlNewDoc函数创建一个新的文件指针。

  xmlParseFile函数以默认方式读入一个UTF-8格式的文件,并返回文件指针。

  xmlReadFile函数读入一个带有某种编码的xml文件,并返回文件指针;细节见libxml2参考手册。

  xmlFreeDoc释放文件指针。特别注意,当你调用xmlFreeDoc时,该文件所有包含的节点内存都被释放。 

  xmlFreeNodeList来释放动态分配的节点内存,除非你把该节点从文件中移除了。

     xmlSaveFile将文件以默认方式存入一个文件。

     xmlSaveFormatFileEnc可将文件以某种编码/格式存入一个文件中。

  节点类型xmlNode、指针xmlNodePtr

  节点应该是xml中最重要的元素了,xmlNode代表了xml文件中的一个节点,实现为一个struct,内容非常丰富:tree.h

  xmlDocSetRootElement函数能将一个节点设置为某个文件的根节点

     xmlNewNode函数创建一个节点指针root_node

(1)创建xml文件

测试程序如下所示:


  1. /****************************************
  2. *练习libxml库,创建通讯录xml文档,新增一个通讯录,
  3. *如果xml文件存在,则添加一个新节点
  4. *如果xml文件不存在,则新建一个xml文件
  5. *
  6. *@author: Anker @date: 2014/02/09
  7. * ***************************************/
  8. #include
  9. #include
  10. #include
  11. #include
  12. #include
  13. #include
  14. #include
  15. #define PHONE_BOOK_FILE "phone_book.xml"
  16. #define ID_STR_LEN 16
  17. #define NAME_STR_LEN 32
  18. #define TEL_STR_LEN 16
  19. #define ADDR_STR_LEN 128
  20. //电话通讯录结构体
  21. typedef struct phone_t {
  22. int id; //编号
  23. char name[NAME_STR_LEN]; //姓名
  24. char tel[TEL_STR_LEN]; //电话
  25. char address[ADDR_STR_LEN]; //地址
  26. }phone;
  27. //设置通讯录项
  28. static void set_phone_item(phone *phone_item)
  29. {
  30. assert(phone_item);
  31. phone_item->id = 10;
  32. snprintf(phone_item->name, NAME_STR_LEN, "%s", "Anker");
  33. snprintf(phone_item->tel, TEL_STR_LEN, "%s", "13223246599");
  34. snprintf(phone_item->address, ADDR_STR_LEN, "%s", "Shenzheng");
  35. }
  36. //创建phone节点
  37. static xmlNodePtr create_phone_node(const phone *phone_item)
  38. {
  39. assert(phone_item);
  40. char id[ID_STR_LEN] = {0};
  41. xmlNodePtr phone_node = NULL;
  42. phone_node = xmlNewNode(NULL, BAD_CAST"phone");
  43. if (phone_node == NULL) {
  44. fprintf(stderr, "Failed to create new node.\n");
  45. return NULL;
  46. }
  47. //设置属性
  48. snprintf(id, ID_STR_LEN, "%d", phone_item->id);
  49. xmlNewProp(phone_node, BAD_CAST"id", (xmlChar*)id);
  50. xmlNewChild(phone_node, NULL, BAD_CAST"name", (xmlChar *)phone_item->name);
  51. xmlNewChild(phone_node, NULL, BAD_CAST"tel", (xmlChar *)phone_item->tel);
  52. xmlNewChild(phone_node, NULL, BAD_CAST"address", (xmlChar *)phone_item->address);
  53. return phone_node;
  54. }
  55. //向根节点中添加一个phone节点
  56. static int add_phone_node_to_root(xmlNodePtr root_node)
  57. {
  58. xmlNodePtr phone_node = NULL;
  59. phone *phone_item = NULL;
  60. //创建一个新的phone
  61. phone_item = (phone *)malloc(sizeof(phone));
  62. if (phone_item == NULL) {
  63. fprintf(stderr, "Failed to malloc memory.\n");
  64. return -1;
  65. }
  66. set_phone_item(phone_item);
  67. //创建一个phone节点
  68. phone_node = create_phone_node(phone_item);
  69. if (phone_node == NULL) {
  70. fprintf(stderr, "Failed to create phone node.\n");
  71. goto FAILED;
  72. }
  73. //根节点添加一个子节点
  74. xmlAddChild(root_node, phone_node);
  75. free(phone_item);
  76. return 0;
  77. FAILED:
  78. if (phone_item){
  79. free(phone_item);
  80. }
  81. return -1;
  82. }
  83. //创建phone_books
  84. static int create_phone_books(const char *phone_book_file)
  85. {
  86. assert(phone_book_file);
  87. xmlDocPtr doc = NULL;
  88. xmlNodePtr root_node = NULL;
  89. //创建一个xml 文档
  90. doc = xmlNewDoc(BAD_CAST"1.0");
  91. if (doc == NULL) {
  92. fprintf(stderr, "Failed to new doc.\n");
  93. return -1;
  94. }
  95. //创建根节点
  96. root_node = xmlNewNode(NULL, BAD_CAST"phone_books");
  97. if (root_node == NULL) {
  98. fprintf(stderr, "Failed to new root node.\n");
  99. goto FAILED;
  100. }
  101. //将根节点添加到文档中
  102. xmlDocSetRootElement(doc, root_node);
  103. if (add_phone_node_to_root(root_node) != 0) {
  104. fprintf(stderr, "Failed to add a new phone node.\n");
  105. goto FAILED;
  106. }
  107. //将文档保存到文件中,按照utf-8编码格式保存
  108. xmlSaveFormatFileEnc(phone_book_file, doc, "UTF-8", 1);
  109. //xmlSaveFile("test.xml", doc);
  110. xmlFreeDoc(doc);
  111. return 0;
  112. FAILED:
  113. if (doc) {
  114. xmlFreeDoc(doc);
  115. }
  116. return -1;
  117. }
  118. static int add_phone_node(const char *phone_book_file)
  119. {
  120. assert(phone_book_file);
  121. xmlDocPtr doc = NULL;
  122. xmlNodePtr root_node = NULL;
  123. xmlNodePtr phone_node = NULL;
  124. phone *phone_item = NULL;
  125. doc = xmlParseFile(phone_book_file);
  126. if (doc == NULL) {
  127. fprintf(stderr, "Failed to parser xml file:%s\n", phone_book_file);
  128. return -1;
  129. }
  130. root_node = xmlDocGetRootElement(doc);
  131. if (root_node == NULL) {
  132. fprintf(stderr, "Failed to get root node.\n");
  133. goto FAILED;
  134. }
  135. if (add_phone_node_to_root(root_node) != 0) {
  136. fprintf(stderr, "Failed to add a new phone node.\n");
  137. goto FAILED;
  138. }
  139. //将文档保存到文件中,按照utf-8编码格式保存
  140. xmlSaveFormatFileEnc(phone_book_file, doc, "UTF-8", 1);
  141. xmlFreeDoc(doc);
  142. return 0;
  143. FAILED:
  144. if (doc) {
  145. xmlFreeDoc(doc);
  146. }
  147. return -1;
  148. }
  149. int main(int argc, char *argv[])
  150. {
  151. char *phone_book_file = PHONE_BOOK_FILE;
  152. if (argc == 2) {
  153. phone_book_file = argv[1];
  154. }
  155. if (access(phone_book_file, F_OK) == 0) {
  156. //文件存在,添加一个新的phone节点
  157. add_phone_node(phone_book_file);
  158. }
  159. else {
  160. //文件不存在,创建一个信息的phone book
  161. create_phone_books(phone_book_file);
  162. }
  163. return 0;
  164. }
  1. [root@nn test]# gcc -g create_phone_book.c -o create_phone_book -I /usr/local/include/libxml2/ -lxml2
  2. [root@nn test]# ls
  3. create_phone_book create_phone_book.c phone_book.c 新文件~
  4. [root@nn test]# ./create_phone_book phone_book.xml
  5. [root@nn test]# cat phone_book.xml
  6. xml version="1.0" encoding="UTF-8"?>
  7. <phone_books>
  8. <phone id="10">
  9. <name>Ankername>
  10. <tel>13223246599tel>
  11. <address>Shenzhengaddress>
  12. phone>
  13. phone_books>

(2)解析xml文档
  1. /************************************
  2. * 调用libxml2库解析xml,提取出电话薄信息
  3. *
  4. * @author:Anker @date:2014/02/09
  5. * *********************************/
  6. #include
  7. #include
  8. #include
  9. #include
  10. #define DEFAULT_XML_FILE "phone_book.xml"
  11. //解析每一个phone,提取出name、tel、address
  12. static int parse_phone(xmlDocPtr doc, xmlNodePtr cur)
  13. {
  14. assert(doc || cur);
  15. xmlChar *key;
  16. cur = cur->xmlChildrenNode;
  17. while (cur != NULL) {
  18. //获取name
  19. if ((!xmlStrcmp(cur->name, (const xmlChar *)"name"))) {
  20. key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
  21. printf("name: %s\t", key);
  22. xmlFree(key);
  23. }
  24. //获取tel
  25. if ((!xmlStrcmp(cur->name, (const xmlChar *)"tel"))) {
  26. key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
  27. printf("tel: %s\t", key);
  28. xmlFree(key);
  29. }
  30. //获取address
  31. if ((!xmlStrcmp(cur->name, (const xmlChar *)"address"))) {
  32. key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
  33. printf("address: %s\n", key);
  34. xmlFree(key);
  35. }
  36. cur = cur->next;
  37. }
  38. return 0;
  39. }
  40. static int parse_phone_book(const char *file_name)
  41. {
  42. assert(file_name);
  43. xmlDocPtr doc; //xml整个文档的树形结构
  44. xmlNodePtr cur; //xml节点
  45. xmlChar *id; //phone id
  46. //获取树形结构
  47. doc = xmlParseFile(file_name);
  48. if (doc == NULL) {
  49. fprintf(stderr, "Failed to parse xml file:%s\n", file_name);
  50. goto FAILED;
  51. }
  52. //获取根节点
  53. cur = xmlDocGetRootElement(doc);
  54. if (cur == NULL) {
  55. fprintf(stderr, "Root is empty.\n");
  56. goto FAILED;
  57. }
  58. if ((xmlStrcmp(cur->name, (const xmlChar *)"phone_books"))) {
  59. fprintf(stderr, "The root is not phone_books.\n");
  60. goto FAILED;
  61. }
  62. //遍历处理根节点的每一个子节点
  63. cur = cur->xmlChildrenNode;
  64. while (cur != NULL) {
  65. if ((!xmlStrcmp(cur->name, (const xmlChar *)"phone"))) {
  66. id = xmlGetProp(cur, "id");
  67. printf("id:%s\t",id);
  68. parse_phone(doc, cur);
  69. }
  70. cur = cur->next;
  71. }
  72. xmlFreeDoc(doc);
  73. return 0;
  74. FAILED:
  75. if (doc) {
  76. xmlFreeDoc(doc);
  77. }
  78. return -1;
  79. }
  80. int main(int argc, char*argv[])
  81. {
  82. char *xml_file = DEFAULT_XML_FILE;
  83. if (argc == 2) {
  84. xml_file = argv[1];
  85. }
  86. if (parse_phone_book(xml_file) != 0) {
  87. fprintf(stderr, "Failed to parse phone book.\n");
  88. return -1;
  89. }
  90. return 0;
  91. }

  1. [root@nn test]# gcc -g phone_book.c -o phone_book -I /usr/local/include/libxml2/ -lxml2[root@nn test]# ./phone_book
  2. id:10 name: Anker tel: 13223246599 address: Shenzheng
阅读(72) | 评论(0) | 转发(0) |
0

上一篇:ping报文里的ttl

下一篇:onos容器化部署

给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册