libxml2的安装及使用

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

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

你若想详细学习前端的一套东西，即xml   html  css   JavaScript(JS)等，可以登录这个网站http://www.runoob.com/

一、libxml2的安装

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

http://pan.baidu.com/share/link?shareid=1620097182&uk=572753958&fid=406043969259270

具体安装步骤：
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文件：

[html]  view plain  copy

 print ?

1. <?xml version="1.0" encoding="UTF-8"?>  
2. <phone_books>  
3.   <phone id="1">  
4.      <name>Anker</name>  
5.      <tel>18923873456</tel>  
6.      <address>Shenzheng</address>  
7.   </phone>  
8.   <phone id="2">  
9.     <name>Jermey</name>  
10.     <tel>18623873456</tel>  
11.     <address>Beijing</address>  
12.   </phone>  
13.   <phone id="3">  
14.     <name>Lili</name>  
15.     <tel>13223873456</tel>  
16.     <address>Shanghai</address>  
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文件

测试程序如下所示：

[html]  view plain  copy

 print ?

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

[html]  view plain  copy

 print ?

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>Anker</name>  
10.     <tel>13223246599</tel>  
11.     <address>Shenzheng</address>  
12.   </phone>  
13. </phone_books>  

（2）解析xml文档

[html]  view plain  copy

 print ?

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

[html]  view plain  copy

 print ?

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