`
chinamming
  • 浏览: 151343 次
  • 性别: Icon_minigender_1
  • 来自: 北京
文章分类
社区版块
存档分类
最新评论

libxml2剖析(3)：使用教程

 
阅读更多
本文整理自官方使用教程http://xmlsoft.org/tutorial/index.html。

示例文档story.xml如下：

[html] view plaincopyprint?
  1. <?xmlversion="1.0"?>
  2. <story>
  3. <storyinfo>
  4. <author>JohnFleck</author>
  5. <datewritten>June2,2002</datewritten>
  6. <keyword>examplekeyword</keyword>
  7. </storyinfo>
  8. <body>
  9. <headline>Thisistheheadline</headline>
  10. <para>Thisisthebodytext.</para>
  11. </body>
  12. </story>
1、解析xml文档
解析文档时只需要文档名和一个函数调用，再加上错误处理。下面代码查找keyword节点并打印节点下的文本内容，如下：
[cpp] view plaincopyprint?
  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<stdlib.h>
  4. #include<libxml/xmlmemory.h>
  5. #include<libxml/parser.h>
  7. /*解析storyinfo节点，打印keyword节点的内容*/
  8. voidparseStory(xmlDocPtrdoc,xmlNodePtrcur){
  9. xmlChar*key;
  10. cur=cur->xmlChildrenNode;
  11. while(cur!=NULL){
  12. /*找到keyword子节点*/
  13. if(!xmlStrcmp(cur->name,(constxmlChar*)"keyword")){
  14. key=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
  15. printf("keyword:%s\n",key);
  16. xmlFree(key);
  17. }
  18. cur=cur->next;/*下一个子节点*/
  19. }
  21. return;
  22. }
  24. /*解析文档*/
  25. staticvoidparseDoc(char*docname){
  26. /*定义文档和节点指针*/
  27. xmlDocPtrdoc;
  28. xmlNodePtrcur;
  30. /*进行解析，如果没成功，显示一个错误并停止*/
  31. doc=xmlParseFile(docname);
  32. if(doc==NULL){
  33. fprintf(stderr,"Documentnotparsesuccessfully.\n");
  34. return;
  35. }
  37. /*获取文档根节点，若无内容则释放文档树并返回*/
  38. cur=xmlDocGetRootElement(doc);
  39. if(cur==NULL){
  40. fprintf(stderr,"emptydocument\n");
  41. xmlFreeDoc(doc);
  42. return;
  43. }
  45. /*确定根节点名是否为story，不是则返回*/
  46. if(xmlStrcmp(cur->name,(constxmlChar*)"story")){
  47. fprintf(stderr,"documentofthewrongtype,rootnode!=story");
  48. xmlFreeDoc(doc);
  49. return;
  50. }
  52. /*遍历文档树*/
  53. cur=cur->xmlChildrenNode;
  54. while(cur!=NULL){
  55. /*找到storyinfo子节点*/
  56. if(!xmlStrcmp(cur->name,(constxmlChar*)"storyinfo")){
  57. parseStory(doc,cur);/*解析storyinfo子节点*/
  58. }
  59. cur=cur->next;/*下一个子节点*/
  60. }
  62. xmlFreeDoc(doc);/*释放文档树*/
  63. return;
  64. }
  66. intmain(intargc,char**argv){
  67. char*docname;
  68. if(argc<=1){
  69. printf("Usage:%sdocname\n",argv[0]);
  70. return0;
  71. }
  72. docname=argv[1];
  73. parseDoc(docname);
  74. return1;
  75. }
解析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元素的内容。

[cpp] view plaincopyprint?
  1. #include<libxml/parser.h>
  2. #include<libxml/xpath.h>
  4. /*解析文档*/
  5. xmlDocPtrgetdoc(char*docname){
  6. xmlDocPtrdoc;
  7. doc=xmlParseFile(docname);
  8. if(doc==NULL){
  9. fprintf(stderr,"Documentnotparsedsuccessfully.\n");
  10. returnNULL;
  11. }
  13. returndoc;
  14. }
  16. /*查询节点集*/
  17. xmlXPathObjectPtrgetnodeset(xmlDocPtrdoc,xmlChar*xpath){
  18. xmlXPathContextPtrcontext;
  19. xmlXPathObjectPtrresult;/*存储查询结果*/
  21. /*创建一个xpath上下文*/
  22. context=xmlXPathNewContext(doc);
  23. if(context==NULL){
  24. printf("ErrorinxmlXPathNewContext\n");
  25. returnNULL;
  26. }
  27. /*查询XPath表达式*/
  28. result=xmlXPathEvalExpression(xpath,context);
  29. xmlXPathFreeContext(context);/*释放上下文指针*/
  30. if(result==NULL){
  31. printf("ErrorinxmlXPathEvalExpression\n");
  32. returnNULL;
  33. }
  34. /*检查结果集是否为空*/
  35. if(xmlXPathNodeSetIsEmpty(result->nodesetval)){
  36. xmlXPathFreeObject(result);/*如为这空就释放*/
  37. printf("Noresult\n");
  38. returnNULL;
  39. }
  40. returnresult;
  41. }
  43. intmain(intargc,char**argv){
  44. char*docname;
  45. xmlDocPtrdoc;
  46. /*查找所有keyword元素，而不管它们在文档中的位置*/
  47. xmlChar*xpath=(xmlChar*)"//keyword";
  48. xmlNodeSetPtrnodeset;
  49. xmlXPathObjectPtrresult;
  50. inti;
  51. xmlChar*keyword;
  53. if(argc<=1){
  54. printf("Usage:%sdocname\n",argv[0]);
  55. return(0);
  56. }
  58. docname=argv[1];
  59. doc=getdoc(docname);
  60. result=getnodeset(doc,xpath);
  61. if(result){
  62. /*得到keyword节点集*/
  63. nodeset=result->nodesetval;
  64. for(i=0;i<nodeset->nodeNr;i++){/*打印每个节点中的内容*/
  65. keyword=xmlNodeListGetString(doc,nodeset->nodeTab[i]->xmlChildrenNode,1);
  66. printf("keyword:%s\n",keyword);
  67. xmlFree(keyword);
  68. }
  69. xmlXPathFreeObject(result);/*释放结果集*/
  70. }
  72. xmlFreeDoc(doc);/*释放文档树*/
  73. xmlCleanupParser();/*清除库内存*/
  74. return(1);
  75. }
可以在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元素。
[cpp] view plaincopyprint?
  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<stdlib.h>
  4. #include<libxml/xmlmemory.h>
  5. #include<libxml/parser.h>
  7. void
  8. parseStory(xmlDocPtrdoc,xmlNodePtrcur,constxmlChar*keyword){
  9. /*在当前节点下插入一个keyword子节点*/
  10. xmlNewTextChild(cur,NULL,(constxmlChar*)"keyword",keyword);
  11. return;
  12. }
  14. xmlDocPtr
  15. parseDoc(char*docname,char*keyword){
  17. xmlDocPtrdoc;
  18. xmlNodePtrcur;
  20. doc=xmlParseFile(docname);
  22. if(doc==NULL){
  23. fprintf(stderr,"Documentnotparsedsuccessfully.\n");
  24. return(NULL);
  25. }
  27. cur=xmlDocGetRootElement(doc);
  29. if(cur==NULL){
  30. fprintf(stderr,"emptydocument\n");
  31. xmlFreeDoc(doc);
  32. return(NULL);
  33. }
  35. if(xmlStrcmp(cur->name,(constxmlChar*)"story")){
  36. fprintf(stderr,"documentofthewrongtype,rootnode!=story");
  37. xmlFreeDoc(doc);
  38. return(NULL);
  39. }
  41. cur=cur->xmlChildrenNode;
  42. while(cur!=NULL){
  43. if((!xmlStrcmp(cur->name,(constxmlChar*)"storyinfo"))){
  44. parseStory(doc,cur,(constxmlChar*)keyword);
  45. }
  47. cur=cur->next;
  48. }
  49. return(doc);
  50. }
  52. int
  53. main(intargc,char**argv){
  55. char*docname;
  56. char*keyword;
  57. xmlDocPtrdoc;
  59. if(argc<=2){
  60. printf("Usage:%sdocname,keyword\n",argv[0]);
  61. return(0);
  62. }
  64. docname=argv[1];
  65. keyword=argv[2];
  66. doc=parseDoc(docname,keyword);
  67. if(doc!=NULL){
  68. xmlSaveFormatFile(docname,doc,0);
  69. xmlFreeDoc(doc);
  70. }
  72. return(1);
  73. }
这里xmlNewTextChild函数在当前节点指针上添加一个子元素。如果希望元素有名字空间，则可以在这里加上。添加完后，就要用xmlSaveFormatFile()把修改后的文档写入到文件。我们这里使用原来doc文档指针，因此会覆盖原来的文件。第三个参数如果设置为1，则输出的文档会自动缩进。
若要删除某个节点，可以使用以下代码：
[cpp] view plaincopyprint?
  1. if(!xmlStrcmp(cur->name,BAD_CAST"keyword")){
  2. xmlNodePtrtempNode;
  3. tempNode=cur->next;
  4. xmlUnlinkNode(cur);
  5. xmlFreeNode(cur);
  6. cur=tempNode;
  7. continue;
  8. }
注意libxml2并没有xmlDelNode或者xmlRemoveNode之类的函数。我们需要将当前节点从文档中断链（unlink），文档就不会再包含这个子节点。这样做需要使用一个临时变量来存储断链节点的后续节点，并记得要手动删除断链节点的内存。
若要给节点添加属性，可以这样：
[cpp] view plaincopyprint?
  1. xmlDocPtr
  2. parseDoc(char*docname,char*uri){
  3. xmlDocPtrdoc;
  4. xmlNodePtrcur;
  5. xmlNodePtrnewnode;
  6. xmlAttrPtrnewattr;
  8. doc=xmlParseFile(docname);
  9. if(doc==NULL){
  10. fprintf(stderr,"Documentnotparsedsuccessfully.\n");
  11. return(NULL);
  12. }
  14. cur=xmlDocGetRootElement(doc);
  15. if(cur==NULL){
  16. fprintf(stderr,"emptydocument\n");
  17. xmlFreeDoc(doc);
  18. return(NULL);
  19. }
  21. if(xmlStrcmp(cur->name,(constxmlChar*)"story")){
  22. fprintf(stderr,"documentofthewrongtype,rootnode!=story");
  23. xmlFreeDoc(doc);
  24. return(NULL);
  25. }
  27. newnode=xmlNewTextChild(cur,NULL,"reference",NULL);
  28. newattr=xmlNewProp(newnode,"uri",uri);
  29. return(doc);
  30. }
我们用xmlAttrPtr声明一个属性指针。在找到story元素后，用xmlNewTextChild()新建一个reference子元素，用xmlNewProp()给这个子元素新建一个uri属性。文档修改完后要用xmlSaveFormatFile()写入到磁盘。
查询属性的过程类似。如下：
[cpp] view plaincopyprint?
  1. void
  2. getReference(xmlDocPtrdoc,xmlNodePtrcur){
  3. xmlChar*uri;
  4. cur=cur->xmlChildrenNode;
  5. while(cur!=NULL){
  6. if((!xmlStrcmp(cur->name,(constxmlChar*)"reference"))){
  7. uri=xmlGetProp(cur,"uri");
  8. printf("uri:%s\n",uri);
  9. xmlFree(uri);
  10. }
  11. cur=cur->next;
  12. }
  13. return;
  14. }
关键函数为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文档：
[cpp] view plaincopyprint?
  1. #include<stdio.h>
  2. #include<iostream>
  3. #include<libxml/parser.h>
  4. #include<libxml/tree.h>
  5. usingnamespacestd;
  7. intmain(intargc,char*argv[]){
  8. //定义文档和节点指针
  9. xmlDocPtrdoc=xmlNewDoc(BAD_CAST"1.0");
  10. xmlNodePtrroot_node=xmlNewNode(NULL,BAD_CAST"root");
  11. //设置根节点
  12. xmlDocSetRootElement(doc,root_node);
  13. //在根节点中直接创建节点
  14. xmlNewTextChild(root_node,NULL,BAD_CAST"newNode1",BAD_CAST"newNode1content");
  15. xmlNewTextChild(root_node,NULL,BAD_CAST"newNode2",BAD_CAST"newNode2content");
  16. xmlNewTextChild(root_node,NULL,BAD_CAST"newNode3",BAD_CAST"newNode3content");
  17. //创建一个节点，设置其内容和属性，然后加入根结点
  18. xmlNodePtrnode=xmlNewNode(NULL,BAD_CAST"node2");
  19. xmlNodePtrcontent=xmlNewText(BAD_CAST"NODECONTENT");
  20. xmlAddChild(root_node,node);
  21. xmlAddChild(node,content);
  22. xmlNewProp(node,BAD_CAST"attribute",BAD_CAST"yes");
  23. //创建一个儿子和孙子节点
  24. node=xmlNewNode(NULL,BAD_CAST"son");
  25. xmlAddChild(root_node,node);
  26. xmlNodePtrgrandson=xmlNewNode(NULL,BAD_CAST"grandson");
  27. xmlAddChild(node,grandson);
  28. xmlAddChild(grandson,xmlNewText(BAD_CAST"Thisisagrandsonnode"));
  29. //存储xml文档
  30. intnRel=xmlSaveFile("CreatedXml.xml",doc);
  31. if(nRel!=-1){
  32. cout<<"一个xml文档被创建，写入"<<nRel<<"个字节"<<endl;
  33. }
  34. //释放文档内节点动态申请的内存
  35. xmlFreeDoc(doc);
  36. return1;
  37. }
编译并运行这个程序，将创建CreatedXml.xml文档，内容如下：
[html] view plaincopyprint?
  1. <root>
  2. <newNode1>newNode1content</newNode1>
  3. <newNode2>newNode2content</newNode2>
  4. <newNode3>newNode3content</newNode3>
  5. <node2attribute="yes">NODECONTENT</node2>
  6. <son>
  7. <grandson>Thisisagrandsonnode</grandson>
  8. </son>
  9. </root>
注意，有多种方式可以添加子节点。第一是用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格式。
[cpp] view plaincopyprint?
  1. #include<string.h>
  2. #include<libxml/parser.h>
  4. /*对指定编码格式的外部数据，转换成libxml使用UTF-8格式*/
  5. unsignedchar*
  6. convert(unsignedchar*in,char*encoding){
  7. unsignedchar*out;
  8. intret,size,out_size,temp;
  9. /*定义一个编码处理器指针*/
  10. xmlCharEncodingHandlerPtrhandler;
  12. size=(int)strlen((constchar*)in)+1;/*输入数据长度*/
  13. out_size=size*2-1;/*输出数据长度*/
  14. out=(unsignedchar*)malloc((size_t)out_size);/*存放输出数据*/
  16. if(out){
  17. /*查找内建的编码处理器*/
  18. handler=xmlFindCharEncodingHandler(encoding);
  19. if(!handler){
  20. free(out);
  21. out=NULL;
  22. }
  23. }
  24. if(out){
  25. temp=size-1;
  26. /*对输入数据进行编码转换*/
  27. ret=handler->input(out,&out_size,in,&temp);
  28. if(ret||temp-size+1){/*转换不成功*/
  29. if(ret){/*转换失败*/
  30. printf("conversionwasn'tsuccessful.\n");
  31. }else{/*只转换了一部分数据*/
  32. printf("conversionwasn'tsuccessful.converted:%ioctets.\n",temp);
  33. }
  34. free(out);
  35. out=NULL;
  36. }else{/*转换成功*/
  37. out=(unsignedchar*)realloc(out,out_size+1);
  38. out[out_size]=0;/*输出的末尾加上null终止符*/
  40. }
  41. }else{
  42. printf("nomem\n");
  43. }
  44. return(out);
  45. }
  47. int
  48. main(intargc,char**argv){
  49. unsignedchar*content,*out;
  50. xmlDocPtrdoc;
  51. xmlNodePtrrootnode;
  52. char*encoding="ISO-8859-1";
  54. if(argc<=1){
  55. printf("Usage:%scontent\n",argv[0]);
  56. return(0);
  57. }
  59. content=(unsignedchar*)argv[1];
  60. /*转换成libxml2使用的UTF-8格式*/
  61. out=convert(content,encoding);
  62. doc=xmlNewDoc(BAD_CAST"1.0");
  63. rootnode=xmlNewDocNode(doc,NULL,(constxmlChar*)"root",out);
  64. xmlDocSetRootElement(doc,rootnode);
  65. /*以ISO-8859-1格式输出文档内容*/
  66. xmlSaveFormatFileEnc("-",doc,encoding,1);
  67. return(1);
  68. }
编译运行这个程序，假设在命令行上提供的数据"zhou"是ISO-8859-1格式（我的系统中不是），则输出文档为：
[html] view plaincopyprint?
  1. <?xmlversion="1.0"encoding="ISO-8859-1"?>
  2. <root>zhou</root>
编码转换的基本流程如下：
（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()对数据进行编码转换。
[cpp] view plaincopyprint?
  1. #include<string.h>
  2. #include<iconv.h>
  3. #include<libxml/encoding.h>
  4. #include<libxml/xmlwriter.h>
  5. #include<libxml/xmlreader.h>
  7. /*输入编码处理器：GBK到UTF-8*/
  8. intgbk_input(unsignedchar*out,int*outlen,
  9. constunsignedchar*in,int*inlen){
  11. char*outbuf=(char*)out;
  12. char*inbuf=(char*)in;
  13. iconv_ticonv_from;/*gbk到utf-8的转换描述符*/
  14. size_tlen1,len2,rslt;
  15. /*注意一般不直接从int*到size_t*的转换
  16. 这在32位平台下是正常的，但到了64平台下size_t为64位，
  17. 那(size_t*)inlen将是一个未知的数据
  18. */
  19. len1=*inlen;
  20. len2=*outlen;
  21. /*分配一个从GBK到UTF-8的转换描述符*/
  22. iconv_from=iconv_open("utf-8","gbk");
  23. /*根据转换描述符，对数据进行编码转换*/
  24. rslt=iconv(iconv_from,&inbuf,&len1,&outbuf,&len2);
  25. if(rslt<0){
  26. returnrslt;
  27. }
  28. iconv_close(iconv_from);/*释放描述符*/
  29. *outlen=((unsignedchar*)outbuf-out);
  30. *inlen=((unsignedchar*)inbuf-in);
  31. return*outlen;
  32. }
  34. /*输出编码处理器：UTF-8到GBK*/
  35. intgbk_output(unsignedchar*out,int*outlen,
  36. constunsignedchar*in,int*inlen){
  38. char*outbuf=(char*)out;
  39. char*inbuf=(char*)in;
  40. iconv_ticonv_to;/*utf-8到gbk的转换描述符*/
  41. size_tlen1,len2,rslt;
  42. /*注意一般不直接从int*到size_t*的转换
  43. 这在32位平台下是正常的，但到了64平台下size_t为64位，
  44. 那(size_t*)inlen将是一个未知的数据
  45. */
  46. len1=*inlen;
  47. len2=*outlen;
  48. /*分配一个从UTF-8到GBK的转换描述符*/
  49. iconv_to=iconv_open("gbk","utf-8");
  50. /*根据转换描述符，对数据进行编码转换*/
  51. rslt=iconv(iconv_to,&inbuf,&len1,&outbuf,&len2);
  52. if(rslt<0){
  53. returnrslt;
  54. }
  55. iconv_close(iconv_to);/*释放描述符*/
  56. *outlen=((unsignedchar*)outbuf-out);
  57. *inlen=((unsignedchar*)inbuf-in);
  58. return*outlen;
  59. }
  61. /**
  62. *convertToUTF8From:
  63. *把encoding编码的输入数据in转换成utf-8格式返回
  64. *出错则返回NULL
  65. */
  66. xmlChar*convertToUTF8From(constchar*in,constchar*encoding){
  67. xmlChar*out;
  68. intret;
  69. intsize;
  70. intout_size;
  71. inttemp;
  72. xmlCharEncodingHandlerPtrhandler;
  73. if(in==0)
  74. return0;
  75. /*查找内建的编码处理器*/
  76. handler=xmlFindCharEncodingHandler(encoding);
  77. if(!handler){
  78. printf("convertToUTF8From:noencodinghandlerfoundfor'%s'\n",
  79. encoding?encoding:"");
  80. return0;
  81. }
  82. size=(int)strlen(in)+1;/*输入数据长度*/
  83. out_size=size*2-1;/*输出数据长度*/
  84. /*存放输出数据*/
  85. out=(unsignedchar*)xmlMalloc((size_t)out_size);
  86. memset(out,0,out_size);
  88. if(out!=NULL){
  89. temp=size-1;
  90. /*对输入数据进行编码转换，成功后返回0*/
  91. ret=handler->input(out,&out_size,(constxmlChar*)in,&temp);
  92. if(ret||temp-size+1){/*转换不成功*/
  93. if(ret){/*转换失败*/
  94. printf("convertToUTF8From:conversionwasn'tsuccessful.\n");
  95. }else{/*只转换了一部分数据*/
  96. printf("convertToUTF8From:conversionwasn'tsuccessful.converted:%ioctets.\n",temp);
  97. }
  98. xmlFree(out);/*释放输出缓冲区*/
  99. out=0;
  100. }else{/*转换成功，在输出末尾加上null终止符*/
  101. out=(unsignedchar*)xmlRealloc(out,out_size+1);
  102. out[out_size]=0;
  103. }
  104. }else{
  105. printf("convertToUTF8From:nomem\n");
  106. }
  107. returnout;
  108. }
  110. /**
  111. *utf8ConvertTo:
  112. *把utf-8的数据转换成encoding编码返回
  113. *出错则返回NULL
  114. */
  115. char*utf8ConvertTo(xmlChar*in,constchar*encoding){
  116. char*out;
  117. intret;
  118. intsize;
  119. intout_size;
  120. inttemp;
  121. xmlCharEncodingHandlerPtrhandler;
  123. if(in==0)
  124. return0;
  126. handler=xmlFindCharEncodingHandler(encoding);
  128. if(!handler){
  129. printf("utf8ConvertTo:noencodinghandlerfoundfor'%s'\n",
  130. encoding?encoding:"");
  131. return0;
  132. }
  134. size=(int)strlen((char*)in)+1;/*输入数据长度*/
  135. out_size=size*2-1;/*输出数据长度*/
  136. out=(char*)malloc((size_t)out_size);/*存放输出数据*/
  137. memset(out,0,out_size);
  138. if(out!=NULL){
  139. temp=size-1;
  140. /*对输入数据进行编码转换，成功后返回0*/
  141. ret=handler->output((xmlChar*)out,&out_size,(constxmlChar*)in,&temp);
  142. if(ret||temp-size+1){
  143. if(ret){
  144. printf("utf8ConvertTo:conversionwasn'tsuccessful.\n");
  145. }else{
  146. printf("utf8ConvertTo:conversionwasn'tsuccessful.converted:%ioctets.\n",temp);
  147. }
  148. free(out);
  149. out=0;
  150. }else{
  151. out=(char*)realloc(out,out_size+1);
  152. out[out_size]=0;/*末尾加上null终止符*/
  153. }
  154. }else{
  155. printf("utf8ConvertTo:nomem\n");
  156. }
  158. returnout;
  159. }
  161. intmain(intargc,char**argv){
  162. constchar*content;
  163. xmlChar*out;
  164. xmlDocPtrdoc;
  165. xmlNodePtrrootnode;
  167. if(argc<=1){
  168. printf("Usage:%scontent\n",argv[0]);
  169. return(0);
  170. }
  171. content=(constchar*)argv[1];
  173. /*添加gbk编码支持*/
  174. xmlNewCharEncodingHandler("gbk",gbk_input,gbk_output);
  175. /*添加gb2312编码支持：仍然可以使用GBK的输入输出处理器*/
  176. xmlNewCharEncodingHandler("gb2312",gbk_input,gbk_output);
  178. /*输入的GBK数据转换成libxml2使用的UTF-8格式*/
  179. out=convertToUTF8From(content,"gbk");
  180. /*创建xml文档*/
  181. doc=xmlNewDoc(BAD_CAST"1.0");
  182. rootnode=xmlNewDocNode(doc,NULL,(constxmlChar*)"root",out);
  183. xmlDocSetRootElement(doc,rootnode);
  184. /*以gb2312格式保存文档内容："-"表示输出到终端*/
  185. xmlSaveFormatFileEnc("-",doc,"gb2312",1);
  187. xmlCleanupCharEncodingHandlers()；/*释放编码处理器资源*/
  188. return(1);
  189. }
这个例子在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函数对输入输出进行编码转换，而不是通过注册编码处理器的方式。
[cpp] view plaincopyprint?
  1. #include<stdio.h>
  2. #include<string.h>
  3. #include<iconv.h>
  4. #include<libxml/parser.h>
  5. #include<libxml/tree.h>
  7. /*代码转换:从一种编码转为另一种编码*/
  8. intencoding_convert(constchar*from_charset,constchar*to_charset,
  9. char*inbuf,intinlen,
  10. char*outbuf,intoutlen){
  12. iconv_tcd;
  13. size_tlen1,len2,rslt;
  15. /*注意一般不直接从int*到size_t*的转换
  16. 这在32位平台下是正常的，但到了64平台下size_t为64位，
  17. 那(size_t*)inlen将是一个未知的数据
  18. */
  19. len1=inlen;
  20. len2=outlen;
  21. /*分配一个转换描述符*/
  22. cd=iconv_open(to_charset,from_charset);
  23. if(cd==0)
  24. return-1;
  25. memset(outbuf,0,len2);
  26. /*执行编码转换*/
  27. rslt=iconv(cd,&inbuf,&len1,&outbuf,&len2);
  28. if(rslt==-1)
  29. return-1;
  31. iconv_close(cd);/*释放描述符*/
  32. return0;
  34. }
  36. /*GB2312转换为UTF-8
  37. *成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL
  38. */
  39. char*gb2312_utf8(char*inbuf){
  40. intnOutLen=2*strlen(inbuf)-1;
  41. char*szOut=(char*)xmlMalloc(nOutLen);
  42. if(-1==encoding_convert("gb2312","uft-8",inbuf,strlen(inbuf),szOut,nOutLen)){
  43. xmlFree(szOut);
  44. szOut=NULL;
  45. }
  46. returnszOut;
  47. }
  49. /*UTF-8转换为GB2312
  50. *成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL
  51. */
  52. char*utf8_gb2312(char*inbuf){
  53. intnOutLen=2*strlen(inbuf)-1;
  54. char*szOut=(char*)xmlMalloc(nOutLen);
  55. if(-1==encoding_convert("utf-8","gb2312",inbuf,strlen(inbuf),szOut,nOutLen)){
  56. xmlFree(szOut);
  57. szOut=NULL;
  58. }
  59. returnszOut;
  60. }
  62. intmain(intargc,char**argv){
  63. /*定义文档节点和指针*/
  64. xmlDocPtrdoc=xmlNewDoc(BAD_CAST"1.0");
  65. xmlNodePtrroot_node=xmlNewNode(NULL,BAD_CAST"root");
  66. /*设置根节点*/
  67. xmlDocSetRootElement(doc,root_node);
  69. /*一个中文字符串转换为UTF-8字符串，然后写入*/
  70. char*szOut=gb2312_utf8("节点1的内容");
  71. /*在根节点中直接创建节点*/
  72. xmlNewTextChild(root_node,NULL,BAD_CAST"newNode1",BAD_CAST"newNode1content");
  73. xmlNewTextChild(root_node,NULL,BAD_CAST"newNode2",BAD_CAST"newNode2content");
  74. xmlNewTextChild(root_node,NULL,BAD_CAST"newNode3",BAD_CAST"newNode3content");
  75. xmlNewChild(root_node,NULL,BAD_CAST"node1",BAD_CASTszOut);
  76. xmlFree(szOut);
  78. /*创建一个节点，设置其内容和属性，然后加入根结点*/
  79. xmlNodePtrnode=xmlNewNode(NULL,BAD_CAST"node2");
  80. xmlNodePtrcontent=xmlNewText(BAD_CAST"NODECONTENT");
  81. xmlAddChild(root_node,node);
  82. xmlAddChild(node,content);
  83. szOut=gb2312_utf8("属性值");
  84. xmlNewProp(node,BAD_CAST"attribute",BAD_CASTszOut);
  85. xmlFree(szOut);
  87. /*创建一个中文节点*/
  88. szOut=gb2312_utf8("中文节点");
  89. xmlNewChild(root_node,NULL,BAD_CASTszOut,BAD_CAST"contentofchinesenode");
  90. xmlFree(szOut);
  92. /*存储xml文档*/
  93. intnRel=xmlSaveFormatFileEnc("CreatedXml_cn.xml",doc,"GB2312",1);
  94. if(nRel!=-1){
  95. printf("一个xml文档被创建,写入%d个字节",nRel);
  96. }
  98. xmlFreeDoc(doc);
  99. return1;
  100. }
这个例子中，当把中文数据写入到XML节点时，使用gb2312_utf8()直接转换成UTF-8格式，这种直接通过iconv转换的方式更高效。编译并运行程序，输出文档如下：
[html] view plaincopyprint?
  1. <?xmlversion="1.0"encoding="GB2312"?>
  2. <root>
  3. <newNode1>newNode1content</newNode1>
  4. <newNode2>newNode2content</newNode2>
  5. <newNode3>newNode3content</newNode3>
  6. <node1>节点1的内容</node1>
  7. <node2attribute="属性值">NODECONTENT</node2>
  8. <中文节点>contentofchinesenode</中文节点>
  9. </root>
6、一个真实的例子
内容整理自http://xmlsoft.org/example.html。
下面是一个真实的例子。应用程序数据的内容不使用DOM树，而是使用内部数据结构来保存。这是一个基于XML存储结构的数据库，它保存了与Gnome相关的任务。如下：
[html] view plaincopyprint?
  1. <?xmlversion="1.0"?>
  2. <gjob:Helpingxmlns:gjob="http://www.gnome.org/some-location">
  3. <gjob:Jobs>
  5. <gjob:Job>
  6. <gjob:ProjectID="3"/>
  7. <gjob:Application>GBackup</gjob:Application>
  8. <gjob:Category>Development</gjob:Category>
  10. <gjob:Update>
  11. <gjob:Status>Open</gjob:Status>
  12. <gjob:Modified>Mon,07Jun199920:27:45-0400METDST</gjob:Modified>
  13. <gjob:Salary>USD0.00</gjob:Salary>
  14. </gjob:Update>
  16. <gjob:Developers>
  17. <gjob:Developer>
  18. </gjob:Developer>
  19. </gjob:Developers>
  21. <gjob:Contact>
  22. <gjob:Person>NathanClemons</gjob:Person>
  23. <gjob:Email>nathan@windsofstorm.net</gjob:Email>
  24. <gjob:Company>
  25. </gjob:Company>
  26. <gjob:Organisation>
  27. </gjob:Organisation>
  28. <gjob:Webpage>
  29. </gjob:Webpage>
  30. <gjob:Snailmail>
  31. </gjob:Snailmail>
  32. <gjob:Phone>
  33. </gjob:Phone>
  34. </gjob:Contact>
  36. <gjob:Requirements>
  37. Theprogramshouldbereleasedasfreesoftware,undertheGPL.
  38. </gjob:Requirements>
  40. <gjob:Skills>
  41. </gjob:Skills>
  43. <gjob:Details>
  44. AGNOMEbasedsystemthatwillallowasuperusertoconfigure
  45. compressedanduncompressedfilesand/orfilesystemstobebacked
  46. upwithasupportedmediainthesystem.Thisshouldbeableto
  47. performviafindcommandsgeneratingalistoffilesthatarepassed
  48. totar,dd,cpio,cp,gzip,etc.,tobedirectedtothetapemachine
  49. orviaoperationsperformedonthefilesystemitself.Email
  50. notificationandGUIstatusdisplayveryimportant.
  51. </gjob:Details>
  53. </gjob:Job>
  55. </gjob:Jobs>
  56. </gjob:Helping>
把XML文件加载到一个内部DOM树中只是调用几个函数的问题，而遍历整个树来收集数据，并生成内部结构则更困难，也更容易出错。
对输入结构的定义法则是非常宽松的。属性的顺序无关紧要（XML规范清楚地说明了这一点），不要依赖于一个节点的子节点顺序通常是一个好的主意，除非这样做真的使事情变得更困难了。下面是解析person信息的一段代码：
[cpp] view plaincopyprint?
  1. /*
  2. *一个person记录
  3. */
  4. typedefstructperson{
  5. char*name;
  6. char*email;
  7. char*company;
  8. char*organisation;
  9. char*smail;
  10. char*webPage;
  11. char*phone;
  12. }person,*personPtr;
  14. /*
  15. *解析person的代码
  16. */
  17. personPtrparsePerson(xmlDocPtrdoc,xmlNsPtrns,xmlNodePtrcur){
  18. personPtrret=NULL;
  20. DEBUG("parsePerson\n");
  21. /*
  22. *为结构分配内存
  23. */
  24. ret=(personPtr)malloc(sizeof(person));
  25. if(ret==NULL){
  26. fprintf(stderr,"outofmemory\n");
  27. return(NULL);
  28. }
  29. memset(ret,0,sizeof(person));
  31. /*我们不关心顶层的元素名是什么*/
  32. cur=cur->xmlChildrenNode;
  33. while(cur!=NULL){
  34. if((!strcmp(cur->name,"Person"))&&(cur->ns==ns))
  35. ret->name=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
  36. if((!strcmp(cur->name,"Email"))&&(cur->ns==ns))
  37. ret->email=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
  38. cur=cur->next;
  39. }
  41. return(ret);
  42. }
下面是要注意的一些事项：
（1）通常一个递归的解析风格是更方便的：XML数据天然地遵循重复式地构造，并且是高度结构化的。
（2）两个参数是xmlDocPtr和xmlNsPtr类型，即指向XML文档和应用程序保留的命名空间的指针。文档信息非常广泛，为你的应用程序数据集定义一个命名空间并测试元素和属性是否属性这个空间是一个好的编程实践。这只需一个简单的相等测试（cur->ns == ns）。
（3）为了查询文本和属性值，你可以使用函数xmlNodeListGetString()来获取所有文本，和由DOM输出生成的引用节点，并生成一个单一的文本字符串。
下面是解析另外一个结构的代码片段：
[cpp] view plaincopyprint?
  1. #include<libxml/tree.h>
  2. /*
  3. *一个Job的描述
  4. */
  5. typedefstructjob{
  6. char*projectID;
  7. char*application;
  8. char*category;
  9. personPtrcontact;
  10. intnbDevelopers;
  11. personPtrdevelopers[100];/*usingdynamicallocisleftasanexercise*/
  12. }job,*jobPtr;
  14. /*
  15. *解析Job的代码
  16. */
  17. jobPtrparseJob(xmlDocPtrdoc,xmlNsPtrns,xmlNodePtrcur){
  18. jobPtrret=NULL;
  20. DEBUG("parseJob\n");
  21. /*
  22. *为结构分配内存
  23. */
  24. ret=(jobPtr)malloc(sizeof(job));
  25. if(ret==NULL){
  26. fprintf(stderr,"outofmemory\n");
  27. return(NULL);
  28. }
  29. memset(ret,0,sizeof(job));
  31. /*我们不关心顶层元素名是什么*/
  32. cur=cur->xmlChildrenNode;
  33. while(cur!=NULL){
  35. if((!strcmp(cur->name,"Project"))&&(cur->ns==ns)){
  36. ret->projectID=xmlGetProp(cur,"ID");
  37. if(ret->projectID==NULL){
  38. fprintf(stderr,"ProjecthasnoID\n");
  39. }
  40. }
  41. if((!strcmp(cur->name,"Application"))&&(cur->ns==ns))
  42. ret->application=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
  43. if((!strcmp(cur->name,"Category"))&&(cur->ns==ns))
  44. ret->category=xmlNodeListGetString(doc,cur->xmlChildrenNode,1);
  45. if((!strcmp(cur->name,"Contact"))&&(cur->ns==ns))
  46. ret->contact=parsePerson(doc,ns,cur);
  47. cur=cur->next;
  48. }
  50. return(ret);
  51. }

一旦你会使用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文档。

更多 0
分享到：
| libxml2剖析(1)：功能特性
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    对libxml2封装的简单C++ xml操作类，libxml入门经典

    "对libxml2封装的简单C++ xml操作类，libxml入门经典" 这个标题表明我们即将探讨的是一个基于C++的XML处理库——libxml2的使用，特别是针对初学者的一个经典教程。它强调的是通过封装libxml2库，创建一个易于使用的...

    libxml2 参考资料

    通过阅读和分析这个文件，开发者可以更好地理解和掌握 libxml2 的 API 使用。 5. **test.c**: 这是另一个测试文件，通常用于验证库的功能或者演示某个特定功能的用法。开发者可以通过这个文件了解如何在实际项目中...

    NS3教程，高手绕道.doc

    NS3教程，高手绕道 NS3是网络模拟器，它可以模拟各种网络场景，例如无线网络、有线网络、移动网络等。NS3提供了一个灵活的平台，允许用户定义和模拟复杂的网络场景。下面是NS3的安装说明和简单的使用方法。 一、NS...

    Cocos2dx入门初级教程

    Cocos2dx入门初级教程的知识点详解 一、Cocos2dx简介 Cocos2dx是一个用于构建2D游戏、演示程序和图形/交互式应用程序的框架。它基于OpenGL进行开发，并且依赖于一系列的库，包括GLEW（OpenGL扩展库）、libxml2...

    cacti使用教程

    在Linux系统上，你可以使用`yum`命令安装这些基础组件： 1. 安装MySQL服务器和开发库，以支持Cacti的数据存储： ``` yum -y install mysql mysql-server mysql-devel ``` 2. 安装Apache Web服务器： ``` yum -...

    NS3对于初学者的教程,高手忽略这个吧.docx

    ### NS3对于初学者的教程 #### 一、NS3简介 NS3（Network Simulator 3）是一款开源的网络仿真平台，广泛应用于学术研究和工业界。它支持广泛的网络协议和应用模型，能够帮助研究人员和工程师们理解网络行为并评估新...

    ganglia安装所需依赖和软件总包附安装教程

    2. **安装依赖**：使用包管理器安装必要的依赖，例如在Ubuntu上： ``` sudo apt-get install build-essential perl libpam0g-dev libxml2-dev python-dev python-setuptools ``` 在CentOS/RHEL上： ``` sudo ...

    PERL编程24学时教程

    14. **脚本自动化**：使用Perl编写系统管理脚本，例如监控、备份、日志分析等。 15. **Perl最佳实践**：学习编写清晰、可维护的代码，包括命名规范、注释、代码组织和测试。 通过这个24学时的教程，你将不仅能够...

    第三章：数据解析_Python爬虫教程_源码

    本教程主要聚焦于数据解析，这是爬虫过程中至关重要的一个环节。数据解析是指将爬取到的原始网页数据转换为结构化的、有意义的信息。下面，我们将深入探讨Python中用于数据解析的一些关键技术和工具。 1. **...

    PHP 教程.docxPHP 教程.docx

    - **LibXML 函数**：如 libxml_use_internal_errors()，用于处理XML文档。 - **Mail 函数**：如 mail()，用于发送邮件。 - **Math 函数**：如 sqrt()，用于数学运算。 - **Misc 函数**：如 getrandmax()，用于其他...

    sipp 文档 教程

    3. **依赖库**：确保系统上安装了所有必要的依赖库，例如libxml2、libcurl等。如果在编译过程中遇到错误，可能需要手动安装这些依赖。 **SIPP教程** SIPP的主要使用方式是通过命令行参数和自定义脚本来操作。以下...

    gdal-1.10.0源码及编译步骤

    2. **解压文件**：使用命令行工具（如`tar`或`7-zip`）解压下载的文件到适当目录，例如`/usr/local/src/`。 3. **进入源码目录**：使用`cd`命令进入解压后的源码目录，例如`cd gdal-1.10.0`。 4. **配置GDAL**：运行...

    Python实现简单HTML表格解析的方法

    本教程使用的Python库为`libxml2dom`，这是一个强大的XML文档处理库，能够方便地读取、创建和修改XML文档。虽然HTML与XML格式有所差异，但`libxml2dom`也能够很好地解析HTML文档。 **安装步骤：** 确保已安装`...

    greenplum5.8源码，来源于GitHub，可以编译安装

    3. 其他依赖库：包括OpenSSL、 readline、libxml2、zlib、ncurses等。 四、编译步骤 1. 解压源码：`tar -zxvf gpdb-5.8.0.tar.gz` 2. 进入源码目录：`cd gpdb-5.8.0` 3. 配置编译环境：根据实际系统环境执行相应的...

    lxml详解.rar

    2. **内存优化**：使用迭代器或流式处理大文件，避免一次性加载整个文档到内存。 3. **性能优化**：了解并使用`lxml.objectify`模块，它提供了一种面向对象的API，适合处理大型XML数据。 4. **XSLT转换**：lxml支持...

    搜索引擎与信息检索教程-ppt加示例源代码

    这通常涉及正则表达式或DOM解析库的使用，如libxml2或TinyXML。 3. **文本分词**：对提取的文本进行分词，是将连续的字符流转换成有意义的词汇单元。分词器的设计需要考虑语言特点和停用词列表，常见的分词算法有...

    socket tcp截包工具

    3. `user-guide.chm`：用户指南，通常包含详细的操作步骤和使用教程。 4. `ws.css`：样式表文件，用于控制Wireshark用户界面的显示样式。 5. `libwireshark.dll`、`libgtk-win32-2.0-0.dll`：动态链接库文件，分别为...

    网页解析文档

    4. **CSS选择器**：使用库提供的功能，根据CSS选择器定位到目标元素。例如， AngleSharp 提供了类似jQuery的API，方便我们像在浏览器中那样选择元素。 5. **JavaScript执行**：如果网页包含JavaScript，可能需要...

    Python网络爬虫项目开发实战_数据抓取_编程案例解析实例详解课程教程.pdf

    3. **lxml**：lxml是Python的一个高效库，它结合了libxml2和libxslt的功能，提供了对HTML和XML的高性能解析和处理。lxml不仅速度快，而且功能强大，支持XPath和CSS选择器，适用于处理大规模和复杂结构的网页数据。 ...

Magicbox
Global site tag (gtag.js) - Google Analytics