libxml2 解析xml文件常见方法举例

XML 前端之家
前端之家收集整理的这篇文章主要介绍了libxml2 解析xml文件常见方法举例，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。
转自：http://blog.csdn.net/zhoudaxia/article/details/8565731
=======================================================
本文整理自官方使用教程 http://xmlsoft.org/tutorial/index.html。

示例文档story.xml如下：

[html] view plain copy
  1. <?xmlversion="1.0"?>
  2. <story>
  3. storyinfo>
  4. author>JohnFleck</datewritten>June2,2002keyword>examplekeywordbodyheadline>Thisistheheadlinepara>Thisisthebodytext.>
    5. @H_403_105@
1、解析xml文档
解析文档时只需要文档名和一个函数调用，再加上错误处理。下面代码查找keyword节点并打印节点下的文本内容，如下：
[cpp] copy
    #include<stdio.h>
  1. #include<string.h>
  2. #include<stdlib.h>
  3. #include<libxml/xmlmemory.h>
  4. #include<libxml/parser.h>
  6. /*解析storyinfo节点，打印keyword节点的内容*/
  7. voidparseStory(xmlDocPtrdoc,xmlNodePtrcur){
  8. xmlChar*key;
  9. cur=cur->xmlChildrenNode;
  10. while(cur!=NULL){
  11. /*找到keyword子节点*/
  12. if(!xmlStrcmp(cur->name,(constxmlChar*)"keyword")){
  13. key=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
  14. printf("keyword:%s\n",key);
  15. xmlFree(key);
  16. }
  17. cur=cur->next;/*下一个子节点*/
  18. return;
  19. }
  21. /*解析文档*/
  22. staticvoidparseDoc(char*docname){
  23. /*定义文档和节点指针*/
  24. xmlDocPtrdoc;
  25. xmlNodePtrcur;
  26. /*进行解析，如果没成功，显示一个错误并停止*/
  27. doc=xmlParseFile(docname);
  28. if(doc==NULL){
  29. fprintf(stderr,"Documentnotparsesuccessfully.\n");
  30. return;
  31. /*获取文档根节点，若无内容则释放文档树并返回*/
  32. cur=xmlDocGetRootElement(doc);
  33. if(cur==NULL){
  34. fprintf(stderr,"emptydocument\n");
  35. xmlFreeDoc(doc);
  36. /*确定根节点名是否为story，不是则返回*/
  37. if(xmlStrcmp(cur->name,153); background-color:inherit; font-weight:bold">constxmlChar*)"story")){
  38. "documentofthewrongtype,rootnode!=story");
  39. xmlFreeDoc(doc);
  40. /*遍历文档树*/
  41. cur=cur->xmlChildrenNode;
  42. while(cur!=NULL){
  43. /*找到storyinfo子节点*/
  44. constxmlChar*)"storyinfo")){
  45. parseStory(doc,cur);/*解析storyinfo子节点*/
  46. cur=cur->next;/*下一个子节点*/
  47. xmlFreeDoc(doc);/*释放文档树*/
  48. intmain(intargc,char**argv){
  49. char*docname;
  50. if(argc<=1){
  51. printf("Usage:%sdocname\n",argv[0]);
  52. return0;
  53. docname=argv[1];
  54. parseDoc(docname);
  55. return1;
  56. }
    57. @H_403_105@
解析XML文档的基本流程如下：
（1）定义文档指针和节点指针。
（2）调用xmlParseFile()解析文档。如果不成功，注册一个错误并停止。一个常见错误是不适当的编码。XML标准文档除了用默认的UTF-8或UTF-16外，还可显式指定用其它编码保存。如果文档是这样，libxml2将自动地为你转换到UTF-8。更多关于XML编码信息包含在XML标准中。
（3）调用xmlDocGetRootElement()获取文档根节点，若无根节点则释放文档树并返回。
（4）确认文档是正确的类型，通过检查根节点名称来判断。
（5）检索节点的内容，这需要遍历文档树。对每个节点，遍历其子节点都需要一个循环。先用cur = cur->xmlChildrenNode获取第一个子节点，然后通过cur = cur->next不断向前遍历，直到cur==NULL。查找找指定节点时使用xmlStrcmp()函数，如果你指定的名称相同，就找到了你要的节点。通常把查找某个子节点的过程封装成函数。
（6）获取节点中的内容。查找到指定节点后，调用xmlNodeListGetString()获取节点下的文本。注意在XML中，包含在节点中的文本是这个节点的子节点，因此获取的是cur->xmlChildrenNode中的字符串。xmlNodeListGetString()会为返回的字符串分配内存，因此记得要用xmlFree()来释放它。
（7）调用xmlFreeDoc()释放文档树指针。
2、使用XPath查询信息
在xml文档中查询信息是一项核心工作。Libxml2支持使用XPath表达式来查找匹配的节点集。简而言之，XPath之于xml，好比sql之于关系数据库。要在一个复杂的xml文档中查找所需的信息，XPath简直是必不可少的工具。下面代码查询所有keyword元素的内容。

copy
    #include<libxml/xpath.h>
  1. xmlDocPtrgetdoc( xmlDocPtrdoc;
  2. "Documentnotparsedsuccessfully.\n");
  3. returnNULL;
  4. returndoc;
  5. /*查询节点集*/
  6. xmlXPathObjectPtrgetnodeset(xmlDocPtrdoc,xmlChar*xpath){
  7. xmlXPathContextPtrcontext;
  8. xmlXPathObjectPtrresult;/*存储查询结果*/
  9. /*创建一个xpath上下文*/
  10. context=xmlXPathNewContext(doc);
  11. if(context==NULL){
  12. printf("ErrorinxmlXPathNewContext\n");
  13. returnNULL;
  14. /*查询XPath表达式*/
  15. result=xmlXPathEvalExpression(xpath,context);
  16. xmlXPathFreeContext(context);/*释放上下文指针*/
  17. if(result==NULL){
  18. printf("ErrorinxmlXPathEvalExpression\n");
  19. /*检查结果集是否为空*/
  20. if(xmlXPathNodeSetIsEmpty(result->nodesetval)){
  21. xmlXPathFreeObject(result);/*如为这空就释放*/
  22. printf("Noresult\n");
  23. returnresult;
  24. char**argv){
  25. char*docname;
  26. /*查找所有keyword元素，而不管它们在文档中的位置*/
  27. xmlChar*xpath=(xmlChar*)"//keyword";
  28. xmlNodeSetPtrnodeset;
  29. xmlXPathObjectPtrresult;
  30. inti;
  31. xmlChar*keyword;
  32. if(argc<=1){
  33. printf("Usage:%sdocname\n",argv[0]);
  34. return(0);
  35. doc=getdoc(docname);
  36. result=getnodeset(doc,xpath);
  37. if(result){
  38. /*得到keyword节点集*/
  39. nodeset=result->nodesetval;
  40. for(i=0;i<nodeset->nodeNr;i++){/*打印每个节点中的内容*/
  41. keyword=xmlNodeListGetString(doc,nodeset->nodeTab[i]->xmlChildrenNode,1);
  42. printf("keyword:%s\n",keyword);
  43. xmlFree(keyword);
  44. xmlXPathFreeObject(result);/*释放结果集*/
  45. xmlCleanupParser();/*清除库内存*/
  46. return(1);
  47. }
    48. @H_403_105@
可以在story.xml中多插入几个keyword元素，然后运行一下本程序看看效果。使用XPath查询信息的基本流程如下：
（1）调用xmlXPathNewContext()给文档树创建一个上下文指针。
（2）调用xmlXPathEvalExpression()，传入XPath表达式和上下文指针，返回一个xmlXPathObjectPtr结果集指针。nodesetval对象包含keyword节点个数(nodeNr)和节点列表(nodeTab)。在使用之前要和xmlXPathNodeSetIsEmpty()检查nodesetval节点列表是否为空。
（3）遍历节点列表nodeTab，用xmlNodeListGetString()获取每个keyword节点的内容。
（4）用xmlXPathFreeObject()释放查询结果，用xmlFreeDoc()释放文档树。
更多关于Xpath的内容可以参考XPath官方规范http://www.w3.org/TR/xpath/。XPath语法的介绍，可参考w3school上的教程http://www.w3school.com.cn/xpath/index.asp，或者http://w3schools.com/xpath/default.asp。只有掌握XPath，才能掌握使用大型XML文件获取信息的方法，否则每寻找一个节点都要从根节点找起，很耗时耗力。
3、修改xml文档
这与上面的过程类似，首先遍历文档树，找到要插入（或删除）的节点处，然后插入（或删除）相关的内容。下面代码在storyinfo节点下插入一个keyword元素。
copy
    void
  1. parseStory(xmlDocPtrdoc,xmlNodePtrcur,constxmlChar*keyword){
  2. /*在当前节点下插入一个keyword子节点*/
  3. xmlNewTextChild(cur,NULL,(constxmlChar*)"keyword",248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> xmlDocPtr
  4. parseDoc(char*docname,87); background-color:inherit; font-weight:bold">char*keyword){
  5. doc=xmlParseFile(docname);
  6. return(NULL);
  7. cur=xmlDocGetRootElement(doc);
  8. constxmlChar*)"story")){
  9. );
  10. if((!xmlStrcmp(cur->name,153); background-color:inherit; font-weight:bold">constxmlChar*)"storyinfo"))){
  11. parseStory(doc,cur,153); background-color:inherit; font-weight:bold">constxmlChar*)keyword);
  12. cur=cur->next;
  13. return(doc);
  14. int
  15. main(char*keyword;
  16. if(argc<=2){
  17. printf("Usage:%sdocname,keyword\n",108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> keyword=argv[2];
  18. doc=parseDoc(docname,keyword);
  19. if(doc!=NULL){
  20. xmlSaveFormatFile(docname,doc,0);
  21. }
    22. @H_403_105@
这里xmlNewTextChild函数在当前节点指针上添加一个子元素。如果希望元素有名字空间，则可以在这里加上。添加完后，就要用xmlSaveFormatFile()把修改后的文档写入到文件。我们这里使用原来doc文档指针，因此会覆盖原来的文件。第三个参数如果设置为1，则输出的文档会自动缩进。
若要删除某个节点，可以使用以下代码：
copy
    "keyword")){
  1. xmlNodePtrtempNode;
  2. tempNode=cur->next;
  3. xmlUnlinkNode(cur);
  4. xmlFreeNode(cur);
  5. cur=tempNode;
  6. continue;
  7. }
    8. @H_403_105@
注意libxml2并没有xmlDelNode或者xmlRemoveNode之类的函数。我们需要将当前节点从文档中断链（unlink），文档就不会再包含这个子节点。这样做需要使用一个临时变量来存储断链节点的后续节点，并记得要手动删除断链节点的内存。
若要给节点添加属性，可以这样：
copy
    xmlDocPtr
  1. parseDoc(char*uri){
  2. xmlNodePtrnewnode;
  3. xmlAttrPtrnewattr;
  4. if(doc==NULL){
  5. "Documentnotparsedsuccessfully.\n");
  6. return(NULL);
  7. newnode=xmlNewTextChild(cur,"reference",NULL);
  8. newattr=xmlNewProp(newnode,"uri",uri);
  9. }
    10. @H_403_105@ 我们用xmlAttrPtr声明一个属性指针。在找到story元素后，用xmlNewTextChild()新建一个reference子元素，用xmlNewProp()给这个子元素新建一个uri属性。文档修改完后要用xmlSaveFormatFile()写入到磁盘。
    查询属性的过程类似。如下：
    copy
      getReference(xmlDocPtrdoc,xmlNodePtrcur){
    1. xmlChar*uri;
    2. constxmlChar*)"reference"))){
    3. uri=xmlGetProp(cur,"uri");
    4. printf("uri:%s\n",108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> xmlFree(uri);
    5. }
      6. @H_403_105@ 关键函数为xmlGetProp()，用来获取节点中的指定属性。注意如果你使用DTD为属性声明一个固定的或默认的值，则该函数也查找这些值。
      4、创建xml文档
      有了上面的基础，创建一个xml文档显得非常简单，就是一个不断插入节点的过程。其流程如下：
      （1）用xmlNewDoc函数创建一个文档指针doc；
      （2）用xmlNewNode函数创建一个节点指针root_node；
      （3）用xmlDocSetRootElement将root_node设置为doc的根结点；
      （4）用xmlAddChild()给root_node添加一系列的子节点，并设置子节点的内容和属性；
      （5）用xmlSaveFile将xml文档存入文件；
      （6）用xmlFreeDoc函数关闭文档指针，并清除本文档中所有节点动态申请的内存。
      下面代码创建一个xml文档：
      copy
        #include<iostream>
      1. #include<libxml/tree.h>
      2. usingnamespacestd;
      3. char*argv[]){
      4. //定义文档和节点指针
      5. xmlDocPtrdoc=xmlNewDoc(BAD_CAST"1.0");
      6. xmlNodePtrroot_node=xmlNewNode(NULL,BAD_CAST"root");
      7. //设置根节点
      8. xmlDocSetRootElement(doc,root_node);
      9. //在根节点中直接创建节点
      10. xmlNewTextChild(root_node,BAD_CAST"newNode1",BAD_CAST"newNode1content");
      11. xmlNewTextChild(root_node,BAD_CAST"newNode2",BAD_CAST"newNode2content");
      12. "newNode3",BAD_CAST"newNode3content");
      13. //创建一个节点，设置其内容和属性，然后加入根结点
      14. xmlNodePtrnode=xmlNewNode(NULL,BAD_CAST"node2");
      15. xmlNodePtrcontent=xmlNewText(BAD_CAST"NODECONTENT");
      16. xmlAddChild(root_node,node);
      17. xmlAddChild(node,content);
      18. xmlNewProp(node,BAD_CAST"attribute",BAD_CAST"yes");
      19. //创建一个儿子和孙子节点
      20. node=xmlNewNode(NULL,BAD_CAST"son");
      21. xmlAddChild(root_node,node);
      22. xmlNodePtrgrandson=xmlNewNode(NULL,BAD_CAST"grandson");
      23. xmlAddChild(grandson,xmlNewText(BAD_CAST"Thisisagrandsonnode"));
      24. //存储xml文档
      25. intnRel=xmlSaveFile("CreatedXml.xml",doc);
      26. if(nRel!=-1){
      27. cout<<"一个xml文档被创建，写入"<<nRel<<"个字节"<<endl;
      28. //释放文档内节点动态申请的内存
      29. }
        30. @H_403_105@ 编译并运行这个程序，将创建CreatedXml.xml文档，内容如下：
        copy
          rootnewNode1>newNode1contentnewNode2>newNode2contentnewNode3>newNode3contentnode2attribute="yes">NODECONTENTnode2songrandson>Thisisagrandsonnode> @H_403_105@ 注意，有多种方式可以添加子节点。第一是用xmlNewTextChild直接添加一个文本子节点；第二是先创建新节点，然后用xmlAddChild将新节点加入上层节点。
          5、编码转换
          数据编码兼容性问题是很多开发人员都会遇到的一大难题，特别是在使用libxml时。libxml内部使用UTF-8格式存储和操作数据。你的应用程序数据如果使用其他格式的编码，例如ISO-8859-1编码，则在传给libxml之前必须转换成UTF-8格式。如果你的应用输出想用非UTF-8格式的编码，也需要进行转换。
          Libxml2本身只支持把UTF-8,UTF-16和ISO-8859-1格式的外部数据转换成内部使用的UTF-8格式，以及处理完后输出成这些格式的数据。对其他的字符编码，需要使用libiconv（当然你也可以使用其他的国际化库，例如ICU）。当前libiconv支持150多种不同的字符编码，libiconv的实现尽量保证支持所有我们听过的编码格式。在使用libxml之前，一般是通过libiconv把数据先转换UTF-8格式。在使用libxml处理完之后，再通过libiconv把数据输出成你要的编码格式。
          一个常见的错误是一份代码的不同部分的数据使用不同的编码格式。例如内部数据使用ISO-8859-1格式的应用程序，联合使用libxml，而它的内部数据格式为UTF-8。这样应用程序在运行不同的代码段时要不同地对待内部数据，这有可能导致解析数据出现错误。
          例子1：使用Libxml内建的编码处理器
          下面的例子创建一个简单的文档，添加从命令行得到的数据到文档根元素，并以合适的编码格式输出到stdout。对提供的数据我们使用ISO-8859-1编码，处理过程为从ISO-8859-1到UTF-8，再到ISO-8859-1。命令行上输入的字符串从ISO-8859-1格式转换成UTF-8格式，以供libxml使用，输出时又重新转换成ISO-8859-1格式。
          copy
            #include<string.h>
          1. #include<libxml/parser.h>
          2. /*对指定编码格式的外部数据，转换成libxml使用UTF-8格式*/
          3. unsignedchar*
          4. convert(unsignedchar*in,87); background-color:inherit; font-weight:bold">char*encoding){
          5. char*out;
          6. intret,size,out_size,temp;
          7. /*定义一个编码处理器指针*/
          8. xmlCharEncodingHandlerPtrhandler;
          9. size=(int)strlen((constchar*)in)+1;/*输入数据长度*/
          10. out_size=size*2-1;/*输出数据长度*/
          11. out=(unsignedchar*)malloc((size_t)out_size);/*存放输出数据*/
          12. if(out){
          13. /*查找内建的编码处理器*/
          14. handler=xmlFindCharEncodingHandler(encoding);
          15. if(!handler){
          16. free(out);
          17. out=NULL;
          18. temp=size-1;
          19. /*对输入数据进行编码转换*/
          20. ret=handler->input(out,&out_size,in,&temp);
          21. if(ret||temp-size+1){/*转换不成功*/
          22. if(ret){/*转换失败*/
          23. printf("conversionwasn'tsuccessful.\n");
          24. }else{/*只转换了一部分数据*/
          25. printf("conversionwasn'tsuccessful.converted:%ioctets.\n",temp);
          26. }/*转换成功*/
          27. out=(unsignedchar*)realloc(out,out_size+1);
          28. out[out_size]=0;/*输出的末尾加上null终止符*/
          29. else{
          30. printf("nomem\n");
          31. return(out);
          32. int
          33. main(char*content,*out;
          34. xmlNodePtrrootnode;
          35. char*encoding="ISO-8859-1";
          36. printf("Usage:%scontent\n",153); background-color:inherit; font-weight:bold">return(0);
          37. content=(unsignedchar*)argv[1];
          38. /*转换成libxml2使用的UTF-8格式*/
          39. out=convert(content,encoding);
          40. doc=xmlNewDoc(BAD_CAST"1.0");
          41. rootnode=xmlNewDocNode(doc,153); background-color:inherit; font-weight:bold">constxmlChar*)"root",out);
          42. /*以ISO-8859-1格式输出文档内容*/
          43. xmlSaveFormatFileEnc("-",encoding,1);
          44. return(1);
          45. }
            46. @H_403_105@ 编译运行这个程序，假设在命令行上提供的数据"zhou"是ISO-8859-1格式（我的系统中不是），则输出文档为：
            copy
              xmlversion="1.0"encoding="ISO-8859-1">zhou> @H_403_105@ 编码转换的基本流程如下：
              （1）用xmlCharEncodingHandlerPtr定义一个编码处理器指针，用xmlFindCharEncodingHandler()查找libxml2中指定的编码处理器。libxml2内建只支持把UTF-8,UTF-16和ISO-8859-1格式的外部数据转换成内部使用的UTF-8格式。如果要转换其他格式的数据（如中文编码），则要使用独立的libiconv库给libxml2注册新编码处理器。
              （2）调用编码处理器的input()函数，把外部数据转换成libxml2使用的格式。
              （3）进行xml处理，处理完若要保存成非UTF-8格式的文档，使用xmlSaveFormatFileEnc()函数。若保存的编码格式libxml2不支持，则只能用libiconv把保存的文档转换成需要的编码格式。
              例子2：通过iconv库给Libxml注册新的编码处理器
              下面例子先编写GBK的编码处理器gbk_input()和gbk_output()，前者是GBK到UTF-8输入处理，后者是UTF-8到GBK输出处理，这两个处理器都要用到iconv转换函数。然后调用xmlNewCharEncodingHandler()注册输入输出处理器。对输入输出数据的编码转换由convertToUTF8From()和utf8ConvertTo()来完成，它们都是调用xmlFindCharEncodingHandler()查找已注册的处理器，然后在处理器上调用input()或output()对数据进行编码转换。
              copy
                #include<iconv.h>
              1. #include<libxml/encoding.h>
              2. #include<libxml/xmlwriter.h>
              3. #include<libxml/xmlreader.h>
              4. /*输入编码处理器：GBK到UTF-8*/
              5. intgbk_input(unsignedchar*out,87); background-color:inherit; font-weight:bold">int*outlen,
              6. constunsignedint*inlen){
              7. char*outbuf=(char*)out;
              8. char*inbuf=(char*)in;
              9. iconv_ticonv_from;/*gbk到utf-8的转换描述符*/
              10. size_tlen1,len2,rslt;
              11. /*注意一般不直接从int*到size_t*的转换
              12. 这在32位平台下是正常的，但到了64平台下size_t为64位，
              13. 那(size_t*)inlen将是一个未知的数据
              14. */
              15. len1=*inlen;
              16. len2=*outlen;
              17. /*分配一个从GBK到UTF-8的转换描述符*/
              18. iconv_from=iconv_open("utf-8","gbk");
              19. /*根据转换描述符，对数据进行编码转换*/
              20. rslt=iconv(iconv_from,&inbuf,&len1,&outbuf,&len2);
              21. if(rslt<0){
              22. returnrslt;
              23. iconv_close(iconv_from);/*释放描述符*/
              24. *outlen=((unsignedchar*)outbuf-out);
              25. *inlen=((unsignedchar*)inbuf-in);
              26. return*outlen;
              27. /*输出编码处理器：UTF-8到GBK*/
              28. intgbk_output(unsignedint*inlen){
              29. char*)out;
              30. char*)in;
              31. iconv_ticonv_to;/*utf-8到gbk的转换描述符*/
              32. /*注意一般不直接从int*到size_t*的转换
              33. 这在32位平台下是正常的，但到了64平台下size_t为64位，
              34. 那(size_t*)inlen将是一个未知的数据
              35. */
              36. len1=*inlen;
              37. len2=*outlen;
              38. /*分配一个从UTF-8到GBK的转换描述符*/
              39. iconv_to=iconv_open("gbk","utf-8");
              40. /*根据转换描述符，对数据进行编码转换*/
              41. rslt=iconv(iconv_to,&len2);
              42. if(rslt<0){
              43. returnrslt;
              44. iconv_close(iconv_to);/*释放描述符*/
              45. *outlen=((unsignedchar*)outbuf-out);
              46. *inlen=((unsignedchar*)inbuf-in);
              47. return*outlen;
              48. /**
              49. *convertToUTF8From:
              50. *把encoding编码的输入数据in转换成utf-8格式返回
              51. *出错则返回NULL
              52. xmlChar*convertToUTF8From( xmlChar*out;
              53. intret;
              54. intsize;
              55. intout_size;
              56. inttemp;
              57. if(in==0)
              58. printf("convertToUTF8From:noencodinghandlerfoundfor'%s'\n",108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> encoding?encoding:"");
              59. int)strlen(in)+1;char*)xmlMalloc((size_t)out_size);
              60. memset(out,out_size);
              61. if(out!=NULL){
              62. /*对输入数据进行编码转换，成功后返回0*/
              63. constxmlChar*)in,&temp);
              64. printf("convertToUTF8From:conversionwasn'tsuccessful.\n");
              65. printf("convertToUTF8From:conversionwasn'tsuccessful.converted:%ioctets.\n",248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> xmlFree(out);/*释放输出缓冲区*/
              66. out=0;
              67. /*转换成功，在输出末尾加上null终止符*/
              68. char*)xmlRealloc(out,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> out[out_size]=0;
              69. else{
              70. printf("convertToUTF8From:nomem\n");
              71. returnout;
              72. /**
              73. *utf8ConvertTo:
              74. *把utf-8的数据转换成encoding编码返回
              75. *出错则返回NULL
              76. char*utf8ConvertTo(xmlChar*in,87); background-color:inherit; font-weight:bold">char*encoding){
              77. char*out;
              78. intret;
              79. intsize;
              80. intout_size;
              81. inttemp;
              82. xmlCharEncodingHandlerPtrhandler;
              83. if(!handler){
              84. printf("utf8ConvertTo:noencodinghandlerfoundfor'%s'\n",248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> encoding?encoding:"");
              85. return0;
              86. int)strlen(( out=( memset(out,out_size);
              87. ret=handler->output((xmlChar*)out,153); background-color:inherit; font-weight:bold">if(ret||temp-size+1){
              88. if(ret){
              89. printf("utf8ConvertTo:conversionwasn'tsuccessful.\n");
              90. printf("utf8ConvertTo:conversionwasn'tsuccessful.converted:%ioctets.\n",108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> out=(/*末尾加上null终止符*/
              91. printf("utf8ConvertTo:nomem\n");
              92. returnout;
              93. char*content;
              94. printf("Usage:%scontent\n",108); list-style:decimal-leading-zero outside; color:inherit; line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> content=(/*添加gbk编码支持*/
              95. xmlNewCharEncodingHandler("gbk",gbk_input,gbk_output);
              96. /*添加gb2312编码支持：仍然可以使用GBK的输入输出处理器*/
              97. xmlNewCharEncodingHandler("gb2312",0); background-color:inherit">/*输入的GBK数据转换成libxml2使用的UTF-8格式*/
              98. out=convertToUTF8From(content,"gbk");
              99. /*创建xml文档*/
              100. doc=xmlNewDoc(BAD_CAST"1.0");
              101. rootnode=xmlNewDocNode(doc,out);
              102. xmlDocSetRootElement(doc,rootnode);
              103. /*以gb2312格式保存文档内容："-"表示输出到终端*/
              104. xmlSaveFormatFileEnc("-","gb2312",1);
              105. xmlCleanupCharEncodingHandlers()；/*释放编码处理器资源*/
              106. }
                107. @H_403_105@ 这个例子在32位与64位Linux平台下测试通过。iconv库是Linux默认自带的组件，因此在Linux中使用libxml非常方便。我们先建立utf-8编码与gbk编码的转换接口，并将接口插入到libxml2库中，这样xml库就支持对gb2312和gbk编码的支持了。当然，这个转换不会自动完成，我们需要使用从libxml库中查找特定编码的接口，libxml支持一些基本的编码接口，如ISO-8859-1，UTF-16等编码，但不支持gbk，所以在上述代码中，我们定义了gbk_input，与gbk_output两个接口，这两个接口的原型声明是libxml库的标准声明，即xmlCharEncodingInputFunc和xmlCharEncodingOutputFunc。在使用完libxml库之后，我们需要释放libxml库的转换资源。
                例子3：直接使用iconv库进行转换
                下面例子直接使用iconv函数对输入输出进行编码转换，而不是通过注册编码处理器的方式。
                copy
                  #include<iconv.h>
                1. #include<libxml/tree.h>
                2. /*代码转换:从一种编码转为另一种编码*/
                3. intencoding_convert(char*from_charset,87); background-color:inherit; font-weight:bold">char*to_charset,87); background-color:inherit; font-weight:bold">char*inbuf,87); background-color:inherit; font-weight:bold">intinlen,87); background-color:inherit; font-weight:bold">char*outbuf,87); background-color:inherit; font-weight:bold">intoutlen){
                4. iconv_tcd;
                5. len1=inlen;
                6. len2=outlen;
                7. /*分配一个转换描述符*/
                8. cd=iconv_open(to_charset,from_charset);
                9. if(cd==0)
                10. return-1;
                11. memset(outbuf,len2);
                12. /*执行编码转换*/
                13. rslt=iconv(cd,153); background-color:inherit; font-weight:bold">if(rslt==-1)
                14. return-1;
                15. iconv_close(cd);/*GB2312转换为UTF-8
                16. *成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL
                17. char*gb2312_utf8(char*inbuf){
                18. intnOutLen=2*strlen(inbuf)-1;
                19. char*szOut=(char*)xmlMalloc(nOutLen);
                20. if(-1==encoding_convert("gb2312","uft-8",inbuf,strlen(inbuf),szOut,nOutLen)){
                21. xmlFree(szOut);
                22. szOut=NULL;
                23. returnszOut;
                24. /*UTF-8转换为GB2312
                25. *成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL
                26. char*utf8_gb2312(char*inbuf){
                27. intnOutLen=2*strlen(inbuf)-1;
                28. char*)xmlMalloc(nOutLen);
                29. if(-1==encoding_convert("utf-8",nOutLen)){
                30. xmlFree(szOut);
                31. szOut=NULL;
                32. returnszOut;
                33. /*定义文档节点和指针*/
                34. xmlDocPtrdoc=xmlNewDoc(BAD_CAST"1.0");
                35. xmlNodePtrroot_node=xmlNewNode(NULL,BAD_CAST"root");
                36. /*设置根节点*/
                37. /*一个中文字符串转换为UTF-8字符串，然后写入*/
                38. char*szOut=gb2312_utf8("节点1的内容");
                39. /*在根节点中直接创建节点*/
                40. xmlNewChild(root_node,BAD_CAST"node1",BAD_CASTszOut);
                41. /*创建一个节点，设置其内容和属性，然后加入根结点*/
                42. xmlNodePtrnode=xmlNewNode(NULL,BAD_CAST"node2");
                43. xmlNodePtrcontent=xmlNewText(BAD_CAST"NODECONTENT");
                44. xmlAddChild(node,content);
                45. szOut=gb2312_utf8("属性值");
                46. /*创建一个中文节点*/
                47. szOut=gb2312_utf8("中文节点");
                48. "contentofchinesenode");
                49. /*存储xml文档*/
                50. intnRel=xmlSaveFormatFileEnc("CreatedXml_cn.xml","GB2312",153); background-color:inherit; font-weight:bold">if(nRel!=-1){
                51. printf("一个xml文档被创建,写入%d个字节",nRel);
                52. return1;
                53. }
                  54. @H_403_105@ 这个例子中，当把中文数据写入到XML节点时，使用gb2312_utf8()直接转换成UTF-8格式，这种直接通过iconv转换的方式更高效。编译并运行程序，输出文档如下：
                  copy
                    xmlversion="1.0"encoding="GB2312"node1>节点1的内容node2attribute="属性值"<中文节点>contentofchinesenode</中文节点> @H_403_105@ 6、一个真实的例子
                    内容整理自 http://xmlsoft.org/example.html。
                    下面是一个真实的例子。应用程序数据的内容不使用DOM树，而是使用内部数据结构来保存。这是一个基于XML存储结构的数据库，它保存了与Gnome相关的任务。如下：
                    copy
                      gjob:Helpingxmlns:gjob="http://www.gnome.org/some-location"gjob:Jobsgjob:Jobgjob:ProjectID="3"/>
                    1. gjob:Application>GBackupgjob:Category>Developmentgjob:Updategjob:Status>Opengjob:Modified>Mon,07Jun199920:27:45-0400METDSTgjob:Salary>USD0.00gjob:Developersgjob:Developergjob:Contactgjob:Person>NathanClemonsgjob:Email>nathan@windsofstorm.netgjob:Companygjob:Organisationgjob:Webpagegjob:Snailmailgjob:Phonegjob:Requirements Theprogramshouldbereleasedasfreesoftware,undertheGPL.
                    2. gjob:Skillsgjob:Details AGNOMEbasedsystemthatwillallowasuperusertoconfigure
                    3. compressedanduncompressedfilesand/orfilesystemstobebacked
                    4. upwithasupportedmediainthesystem.Thisshouldbeableto
                    5. performviafindcommandsgeneratingalistoffilesthatarepassed
                    6. totar,dd,cpio,cp,gzip,etc.,tobedirectedtothetapemachine
                    7. orviaoperationsperformedonthefilesystemitself.Email
                    8. notificationandGUIstatusdisplayveryimportant.
                    9. gjob:Helping>
                      10. @H_403_105@ 把XML文件加载到一个内部DOM树中只是调用几个函数的问题，而遍历整个树来收集数据，并生成内部结构则更困难，也更容易出错。
                      对输入结构的定义法则是非常宽松的。属性的顺序无关紧要（XML规范清楚地说明了这一点），不要依赖于一个节点的子节点顺序通常是一个好的主意，除非这样做真的使事情变得更困难了。下面是解析person信息的一段代码：
                      copy
                        /*
                      1. *一个person记录
                      2. typedefstructperson{
                      3. char*name;
                      4. char*email;
                      5. char*company;
                      6. char*organisation;
                      7. char*smail;
                      8. char*webPage;
                      9. char*phone;
                      10. }person,*personPtr;
                      11. /*
                      12. *解析person的代码
                      13. personPtrparsePerson(xmlDocPtrdoc,xmlNsPtrns,xmlNodePtrcur){
                      14. personPtrret=NULL;
                      15. DEBUG("parsePerson\n");
                      16. *为结构分配内存
                      17. ret=(personPtr)malloc(sizeof(person));
                      18. if(ret==NULL){
                      19. "outofmemory\n");
                      20. memset(ret,153); background-color:inherit; font-weight:bold">sizeof(person));
                      21. /*我们不关心顶层的元素名是什么*/
                      22. if((!strcmp(cur->name,"Person"))&&(cur->ns==ns))
                      23. ret->name=xmlNodeListGetString(doc,"Email"))&&(cur->ns==ns))
                      24. ret->email=xmlNodeListGetString(doc,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> cur=cur->next;
                      25. return(ret);
                      26. }
                        27. @H_403_105@ 下面是要注意的一些事项：
                        （1）通常一个递归的解析风格是更方便的：XML数据天然地遵循重复式地构造，并且是高度结构化的。
                        （2）两个参数是xmlDocPtr和xmlNsPtr类型，即指向XML文档和应用程序保留的命名空间的指针。文档信息非常广泛，为你的应用程序数据集定义一个命名空间并测试元素和属性是否属性这个空间是一个好的编程实践。这只需一个简单的相等测试（cur->ns == ns）。
                        （3）为了查询文本和属性值，你可以使用函数xmlNodeListGetString()来获取所有文本，和由DOM输出生成的引用节点，并生成一个单一的文本字符串。
                        下面是解析另外一个结构的代码片段：
                        copy
                          *一个Job的描述
                        1. structjob{
                        2. char*projectID;
                        3. char*application;
                        4. char*category;
                        5. personPtrcontact;
                        6. intnbDevelopers;
                        7. personPtrdevelopers[100];/*usingdynamicallocisleftasanexercise*/
                        8. }job,*jobPtr;
                        9. *解析Job的代码
                        10. jobPtrparseJob(xmlDocPtrdoc,248); line-height:18px; margin:0px!important; padding:0px 3px 0px 10px!important"> jobPtrret=NULL;
                        11. DEBUG("parseJob\n");
                        12. ret=(jobPtr)malloc(sizeof(job));
                        13. sizeof(job));
                        14. /*我们不关心顶层元素名是什么*/
                        15. "Project"))&&(cur->ns==ns)){
                        16. ret->projectID=xmlGetProp(cur,"ID");
                        17. if(ret->projectID==NULL){
                        18. "ProjecthasnoID\n");
                        19. "Application"))&&(cur->ns==ns))
                        20. ret->application=xmlNodeListGetString(doc,"Category"))&&(cur->ns==ns))
                        21. ret->category=xmlNodeListGetString(doc,"Contact"))&&(cur->ns==ns))
                        22. ret->contact=parsePerson(doc,ns,cur);
                        23. return(ret);
                        24. }
                          25. @H_403_105@

                          一旦你会使用libxml2，编写这种类型的代码是非常简单的，也很无趣。最终，你可以写一个拥有C数据结构和一组XML文档例子或一个XML DTD的桩模块，并生成在C数据和XML存储之间导入和导出数据的代码。

                          7、详细代码示例
                          对Libxml2更详细的使用介绍，可参考官方的详细代码示例http://xmlsoft.org/examples/index.html。上面提供了Libxml2各个组件怎么使用的详细代码示例，包括以下部分：
                          xmlWriter:测试xmlWriter的各个API，包括写入到文件、写入到内存缓冲区、写入到新的文档或子树、字符串编码转换、对输出文档进行序列化。
                          InputOutput:演示使用xmlRegisterInputCallbacks来建立一个客户I/O层，这被用在XInclude方法上下文中，以显示怎样构建动态文档。还演示使用xmlDocDumpMemory来输出文档到字符缓冲区中。
                          Parsing:演示使用xmlReadMemory()读取XML文档，xmlFreeDoc()释放文档树；使用xmlCreatePushParserCtxt()和xmlParseChunk()一块一块地读取XML文档到文档树中。演示为XML文档创建一个解析上下文，然后解析并验证这个文档；创建一个文档树，检查并验证结果，最后用xmlFreeDoc()释放文档树。演示使用xmlReadFile()读取XML文档并用xmlFreeDoc()释放它。
                          Tree:演示怎样创建文档和节点，并把数据dump到标准输出或文件中。演示使用xmlDocGetRootElement()获取根元素，然后遍历文档并打印各个元素名。
                          XPath:演示怎样计算XPath表达式，并在XPath上下文注册名称空间，打印结果节点集。演示怎么加载一个文档、用XPath定位到某个子元素、修改这个元素并保存结果。这包含了加载/编辑/保存的一个完整来回。
                          xmlReader:演示使用xmlReaderForFile()解析XML文档，并dump出节点的信息。演示在用xmlReaderForFile()解析时验证文档的内容，激活各种选项，诸如实体替换、DTD属性不一致等。演示使用xmlTextReaderPreservePattern()提取XML文档中某一部分的子文档。演示重用xmlReader对象来解析多个XML文档。

                          猜你在找的XML相关文章

                          10分钟掌握XML、JSON及其解析
                          引言 NOKIA 有句著名的广告语：“科技以人为本”。任何技术都是为了满足人的生产生活需要而...
                          [CXF REST标准实战系列] 一、JAXB xml与javaBean的转换
                          Writer：BYSocket（泥沙砖瓦浆木匠） 微博：BYSocket 豆瓣：BYSocket Reprint it anywhere...
                          [CXF REST标准实战系列] 一、JAXB xml与javaBean的转换
                          Writer：BYSocket（泥沙砖瓦浆木匠） 微博：BYSocket 豆瓣：BYSocket Reprint it anywhere...
                          10分钟掌握XML、JSON及其解析
                          http://blog.jobbole.com/79252/ 引言 NOKIA 有句著名的广告语：“科技以人为本”。任何技...
                          自定义圆形控件RoundImageView并认识一下attr.xml
                          (点击上方公众号，可快速关注) 公众号：smart_android 作者：耿广龙｜loonggg 点击“阅读原...
                          10分钟掌握XML、JSON及其解析
                          引言 NOKIA 有句著名的广告语：“科技以人为本”。任何技术都是为了满足人的生产生活需要而...
                          10分钟掌握XML、JSON及其解析(上)
                           (点击上方公众号，可快速关注) 来源： Long Luo 的博客 链接：http://longluo.github.i...
                          10分钟掌握XML、JSON及其解析(中)
                          接上文 二、JSON XML很好很强大，但是最近有另外一个时代弄潮儿，这就是JSON。现在JSON的光...
                          10分钟掌握XML、JSON及其解析(下)
                          接上文 2.4 如何解析JSON？ Android JSON所有相关类，都在org.json包下。 包括JSONObject、...
                          10分钟掌握XML、JSON及其解析
                          原文出处：  Long Luo 的博客（@Long_Luo）   引言 NOKIA 有句著名的广告语：“科技以人...
                          HTMLHTML5JavaScriptCSSjQueryBootstrapAngularjsTypeScriptVueDojoJsonElectronNode.jsextjsExpress XMLES6AjaxFlashUnityReactFlexAnt DesignWeb前端微信小程序微信公众号
                          关闭广告单独headers封装代码提示错误整数正则非0开头跳页出页码antd table提示URL未注册公众号支付vue hash模式iSlider车牌键盘循环图片echarts 双折左右布局DllPlugin对象创建打字游戏圈选两栏云函数蒙版ES2020橱窗无缝滚动轮播色块碰撞组件销毁文档操作