mcgrady_tracy
mcgrady_tracy

libxml2 使用教程

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

    示例文档story.xml如下：

[html]  view plain copy
  1. <?xml version="1.0"?>  
  2. <story>  
  3.   <storyinfo>  
  4.     <author>John Fleck</author>  
  5.     <datewritten>June 2, 2002</datewritten>  
  6.     <keyword>example keyword</keyword>  
  7.   </storyinfo>  
  8.   <body>  
  9.     <headline>This is the headline</headline>  
  10.     <para>This is the body text.</para>  
  11.   </body>  
  12. </story>  
     1、解析xml文档
    解析文档时只需要文档名和一个函数调用，再加上错误处理。下面代码查找keyword节点并打印节点下的文本内容，如下：
[cpp]  view plain copy
  1. #include <stdio.h>  
  2. #include <string.h>  
  3. #include <stdlib.h>  
  4. #include <libxml/xmlmemory.h>  
  5. #include <libxml/parser.h>  
  6.   
  7. /* 解析storyinfo节点，打印keyword节点的内容 */  
  8. void parseStory(xmlDocPtr doc, xmlNodePtr cur){  
  9.     xmlChar* key;  
  10.     cur=cur->xmlChildrenNode;  
  11.     while(cur != NULL){  
  12.         /* 找到keyword子节点 */  
  13.         if(!xmlStrcmp(cur->name, (const xmlChar *)"keyword")){  
  14.             key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);  
  15.             printf("keyword: %s\n", key);  
  16.             xmlFree(key);  
  17.         }  
  18.         cur=cur->next; /* 下一个子节点 */  
  19.     }  
  20.   
  21.     return;  
  22. }  
  23.   
  24. /* 解析文档 */  
  25. static void parseDoc(char *docname){  
  26.     /* 定义文档和节点指针 */  
  27.     xmlDocPtr doc;  
  28.     xmlNodePtr cur;  
  29.       
  30.     /* 进行解析，如果没成功，显示一个错误并停止 */  
  31.     doc = xmlParseFile(docname);  
  32.     if(doc == NULL){  
  33.         fprintf(stderr, "Document not parse successfully. \n");  
  34.         return;  
  35.     }  
  36.   
  37.     /* 获取文档根节点，若无内容则释放文档树并返回 */  
  38.     cur = xmlDocGetRootElement(doc);  
  39.     if(cur == NULL){  
  40.         fprintf(stderr, "empty document\n");  
  41.         xmlFreeDoc(doc);  
  42.         return;  
  43.     }  
  44.   
  45.     /* 确定根节点名是否为story，不是则返回 */  
  46.     if(xmlStrcmp(cur->name, (const xmlChar *)"story")){  
  47.         fprintf(stderr, "document of the wrong type, root node != story");  
  48.         xmlFreeDoc(doc);  
  49.         return;  
  50.     }  
  51.   
  52.     /* 遍历文档树 */  
  53.     cur = cur->xmlChildrenNode;  
  54.     while(cur != NULL){  
  55.         /* 找到storyinfo子节点 */  
  56.         if(!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo")){  
  57.             parseStory(doc, cur); /* 解析storyinfo子节点 */  
  58.         }  
  59.         cur = cur->next; /* 下一个子节点 */  
  60.     }  
  61.   
  62.     xmlFreeDoc(doc); /* 释放文档树 */  
  63.     return;  
  64. }  
  65.   
  66. int main(int argc, char **argv){  
  67.     char *docname;  
  68.     if(argc <= 1){  
  69.         printf("Usage: %s docname\n", argv[0]);  
  70.         return 0;  
  71.     }  
  72.     docname=argv[1];  
  73.     parseDoc(docname);  
  74.     return 1;  
  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 plain copy
  1. #include <libxml/parser.h>  
  2. #include <libxml/xpath.h>  
  3.   
  4. /* 解析文档 */  
  5. xmlDocPtr getdoc(char *docname){  
  6.     xmlDocPtr doc;  
  7.     doc = xmlParseFile(docname);  
  8.     if(doc == NULL){  
  9.         fprintf(stderr, "Document not parsed successfully. \n");  
  10.         return NULL;  
  11.     }  
  12.   
  13.     return doc;  
  14. }  
  15.   
  16. /* 查询节点集 */  
  17. xmlXPathObjectPtr getnodeset(xmlDocPtr doc, xmlChar *xpath){  
  18.     xmlXPathContextPtr context;  
  19.     xmlXPathObjectPtr result; /* 存储查询结果 */  
  20.   
  21.     /* 创建一个xpath上下文 */  
  22.     context = xmlXPathNewContext(doc);  
  23.     if(context == NULL){  
  24.         printf("Error in xmlXPathNewContext\n");  
  25.         return NULL;  
  26.     }  
  27.     /* 查询XPath表达式 */  
  28.     result = xmlXPathEvalExpression(xpath, context);  
  29.     xmlXPathFreeContext(context); /* 释放上下文指针 */  
  30.     if(result == NULL){  
  31.         printf("Error in xmlXPathEvalExpression\n");  
  32.         return NULL;  
  33.     }  
  34.     /* 检查结果集是否为空 */  
  35.     if(xmlXPathNodeSetIsEmpty(result->nodesetval)){  
  36.         xmlXPathFreeObject(result); /* 如为这空就释放 */  
  37.         printf("No result\n");  
  38.         return NULL;  
  39.     }  
  40.     return result;  
  41. }  
  42.   
  43. int main(int argc, char ** argv){  
  44.     char *docname;  
  45.     xmlDocPtr doc;  
  46.     /* 查找所有keyword元素，而不管它们在文档中的位置 */  
  47.     xmlChar *xpath=(xmlChar*)"//keyword";  
  48.     xmlNodeSetPtr nodeset;  
  49.     xmlXPathObjectPtr result;  
  50.     int i;  
  51.     xmlChar *keyword;  
  52.   
  53.     if(argc <= 1){  
  54.         printf("Usage: %s docname\n", argv[0]);  
  55.         return(0);  
  56.     }  
  57.   
  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.     }  
  71.   
  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 plain copy
  1. #include <stdio.h>  
  2. #include <string.h>  
  3. #include <stdlib.h>  
  4. #include <libxml/xmlmemory.h>  
  5. #include <libxml/parser.h>  
  6.   
  7. void  
  8. parseStory(xmlDocPtr doc, xmlNodePtr cur, const xmlChar* keyword) {  
  9.     /* 在当前节点下插入一个keyword子节点 */  
  10.     xmlNewTextChild(cur, NULL, (const xmlChar*)"keyword", keyword);  
  11.     return;  
  12. }  
  13.   
  14. xmlDocPtr  
  15. parseDoc(char *docname, char *keyword) {  
  16.   
  17.     xmlDocPtr doc;  
  18.     xmlNodePtr cur;  
  19.   
  20.     doc = xmlParseFile(docname);  
  21.       
  22.     if (doc == NULL ) {  
  23.         fprintf(stderr,"Document not parsed successfully. \n");  
  24.         return (NULL);  
  25.     }  
  26.       
  27.     cur = xmlDocGetRootElement(doc);  
  28.       
  29.     if (cur == NULL) {  
  30.         fprintf(stderr,"empty document\n");  
  31.         xmlFreeDoc(doc);  
  32.         return (NULL);  
  33.     }  
  34.       
  35.     if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {  
  36.         fprintf(stderr,"document of the wrong type, root node != story");  
  37.         xmlFreeDoc(doc);  
  38.         return (NULL);  
  39.     }  
  40.       
  41.     cur = cur->xmlChildrenNode;  
  42.     while (cur != NULL) {  
  43.         if ((!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo"))){  
  44.             parseStory (doc, cur, (const xmlChar*)keyword);  
  45.         }  
  46.            
  47.     cur = cur->next;  
  48.     }  
  49.     return(doc);  
  50. }  
  51.   
  52. int  
  53. main(int argc, char **argv) {  
  54.   
  55.     char *docname;  
  56.     char *keyword;  
  57.     xmlDocPtr doc;  
  58.   
  59.     if (argc <= 2) {  
  60.         printf("Usage: %s docname, keyword\n", argv[0]);  
  61.         return(0);  
  62.     }  
  63.   
  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.     }  
  71.       
  72.     return (1);  
  73. }  
    这里xmlNewTextChild函数在当前节点指针上添加一个子元素。如果希望元素有名字空间，则可以在这里加上。添加完后，就要用xmlSaveFormatFile()把修改后的文档写入到文件。我们这里使用原来doc文档指针，因此会覆盖原来的文件。第三个参数如果设置为1，则输出的文档会自动缩进。
    若要删除某个节点，可以使用以下代码：
[cpp]  view plain copy
  1. if(!xmlStrcmp(cur->name, BAD_CAST "keyword")){  
  2.     xmlNodePtr tempNode;  
  3.     tempNode = cur->next;  
  4.     xmlUnlinkNode(cur);  
  5.     xmlFreeNode(cur);  
  6.     cur = tempNode;  
  7.     continue;  
  8. }  
    注意libxml2并没有xmlDelNode或者xmlRemoveNode之类的函数。我们需要将当前节点从文档中断链（unlink），文档就不会再包含这个子节点。这样做需要使用一个临时变量来存储断链节点的后续节点，并记得要手动删除断链节点的内存。
    若要给节点添加属性，可以这样：
[cpp]  view plain copy
  1. xmlDocPtr  
  2. parseDoc(char *docname, char *uri) {  
  3.     xmlDocPtr doc;  
  4.     xmlNodePtr cur;  
  5.     xmlNodePtr newnode;  
  6.     xmlAttrPtr newattr;  
  7.   
  8.     doc = xmlParseFile(docname);      
  9.     if (doc == NULL ) {  
  10.         fprintf(stderr,"Document not parsed successfully. \n");  
  11.         return (NULL);  
  12.     }  
  13.       
  14.     cur = xmlDocGetRootElement(doc);      
  15.     if (cur == NULL) {  
  16.         fprintf(stderr,"empty document\n");  
  17.         xmlFreeDoc(doc);  
  18.         return (NULL);  
  19.     }  
  20.       
  21.     if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {  
  22.         fprintf(stderr,"document of the wrong type, root node != story");  
  23.         xmlFreeDoc(doc);  
  24.         return (NULL);  
  25.     }  
  26.       
  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 plain copy
  1. void  
  2. getReference(xmlDocPtr doc, xmlNodePtr cur) {  
  3.     xmlChar *uri;  
  4.     cur = cur->xmlChildrenNode;  
  5.     while (cur != NULL) {  
  6.         if ((!xmlStrcmp(cur->name, (const xmlChar *)"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 plain copy
  1. #include <stdio.h>  
  2. #include <iostream>  
  3. #include <libxml/parser.h>  
  4. #include <libxml/tree.h>  
  5. using namespace std;  
  6.   
  7. int main(int argc, char* argv[]){  
  8.     //定义文档和节点指针  
  9.     xmlDocPtr doc=xmlNewDoc(BAD_CAST"1.0");  
  10.     xmlNodePtr root_node=xmlNewNode(NULL,BAD_CAST"root");  
  11.     //设置根节点  
  12.     xmlDocSetRootElement(doc,root_node);  
  13.     //在根节点中直接创建节点  
  14.     xmlNewTextChild(root_node, NULL, BAD_CAST"newNode1", BAD_CAST"newNode1 content");  
  15.     xmlNewTextChild(root_node, NULL, BAD_CAST"newNode2", BAD_CAST"newNode2 content");  
  16.     xmlNewTextChild(root_node, NULL, BAD_CAST"newNode3", BAD_CAST"newNode3 content");  
  17.     //创建一个节点，设置其内容和属性，然后加入根结点  
  18.     xmlNodePtr node=xmlNewNode(NULL, BAD_CAST"node2");  
  19.     xmlNodePtr content=xmlNewText(BAD_CAST"NODE CONTENT");  
  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.     xmlNodePtr grandson=xmlNewNode(NULL,BAD_CAST"grandson");  
  27.     xmlAddChild(node,grandson);  
  28.     xmlAddChild(grandson,xmlNewText(BAD_CAST"This is a grandson node"));  
  29.     //存储xml文档  
  30.     int nRel=xmlSaveFile("CreatedXml.xml",doc);  
  31.     if(nRel!=-1){  
  32.         cout<<"一个xml文档被创建，写入"<<nRel<<"个字节"<<endl;  
  33.     }  
  34.     //释放文档内节点动态申请的内存  
  35.     xmlFreeDoc(doc);  
  36.     return 1;  
  37. }  
    编译并运行这个程序，将创建CreatedXml.xml文档，内容如下：
[html]  view plain copy
  1. <root>  
  2.     <newNode1>newNode1 content</newNode1>  
  3.     <newNode2>newNode2 content</newNode2>  
  4.     <newNode3>newNode3 content</newNode3>  
  5.     <node2 attribute="yes">NODE CONTENT</node2>  
  6.     <son>  
  7.         <grandson>This is a grandson node</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 plain copy
  1. #include <string.h>  
  2. #include <libxml/parser.h>  
  3.   
  4. /* 对指定编码格式的外部数据，转换成libxml使用UTF-8格式 */  
  5. unsigned char*  
  6. convert(unsigned char *in, char *encoding){  
  7.     unsigned char *out;  
  8.     int ret,size,out_size,temp;  
  9.     /* 定义一个编码处理器指针 */  
  10.     xmlCharEncodingHandlerPtr handler;  
  11.   
  12.     size = (int)strlen((const char*)in)+1; /* 输入数据长度 */  
  13.     out_size = size*2-1; /* 输出数据长度 */  
  14.     out = (unsigned char*)malloc((size_t)out_size); /* 存放输出数据 */  
  15.   
  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("conversion wasn't successful.\n");  
  31.             } else { /* 只转换了一部分数据 */  
  32.                 printf("conversion wasn't successful. converted: %i octets.\n",temp);  
  33.             }  
  34.             free(out);  
  35.             out = NULL;  
  36.         }else { /* 转换成功 */  
  37.             out = (unsigned char*)realloc(out,out_size+1);  
  38.             out[out_size]=0; /* 输出的末尾加上null终止符 */  
  39.                           
  40.         }  
  41.     } else {  
  42.         printf("no mem\n");  
  43.     }  
  44.     return (out);  
  45. }     
  46.   
  47. int  
  48. main(int argc, char **argv) {  
  49.     unsigned char *content, *out;  
  50.     xmlDocPtr doc;  
  51.     xmlNodePtr rootnode;  
  52.     char *encoding = "ISO-8859-1";  
  53.       
  54.     if (argc <= 1) {  
  55.         printf("Usage: %s content\n", argv[0]);  
  56.         return(0);  
  57.     }  
  58.   
  59.     content = (unsigned char*)argv[1];  
  60.     /* 转换成libxml2使用的UTF-8格式 */  
  61.     out = convert(content, encoding);  
  62.     doc = xmlNewDoc (BAD_CAST "1.0");  
  63.     rootnode = xmlNewDocNode(doc, NULL, (const xmlChar*)"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 plain copy
  1. <?xml version="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 plain copy
  1. #include <string.h>  
  2. #include <iconv.h>  
  3. #include <libxml/encoding.h>  
  4. #include <libxml/xmlwriter.h>  
  5. #include <libxml/xmlreader.h>  
  6.   
  7. /* 输入编码处理器：GBK到UTF-8 */  
  8. int gbk_input(unsigned char *out, int *outlen,   
  9.         const unsigned char *in, int *inlen){  
  10.   
  11.     char *outbuf = (char *) out;  
  12.     char *inbuf = (char *) in;  
  13.     iconv_t iconv_from; /* gbk到utf-8的转换描述符 */  
  14.     size_t len1, 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.         return rslt;  
  27.     }  
  28.     iconv_close(iconv_from); /* 释放描述符 */  
  29.     *outlen = ((unsigned char *) outbuf - out);  
  30.     *inlen = ((unsigned char *) inbuf - in);  
  31.     return *outlen;  
  32. }  
  33.   
  34. /* 输出编码处理器：UTF-8到GBK */  
  35. int gbk_output(unsigned char *out, int *outlen,   
  36.                 const unsigned char *in, int *inlen){  
  37.   
  38.     char *outbuf = (char *) out;  
  39.     char *inbuf = (char *) in;  
  40.     iconv_t iconv_to; /* utf-8到gbk的转换描述符 */  
  41.     size_t len1, 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.         return rslt;  
  54.     }  
  55.     iconv_close(iconv_to); /* 释放描述符 */  
  56.     *outlen = ((unsigned char *) outbuf - out);  
  57.     *inlen = ((unsigned char *) inbuf - in);  
  58.     return *outlen;  
  59. }  
  60.   
  61. /** 
  62.  * convertToUTF8From: 
  63.  * 把encoding编码的输入数据in转换成utf-8格式返回 
  64.  * 出错则返回NULL 
  65.  */  
  66. xmlChar *convertToUTF8From(const char *in, const char *encoding){  
  67.     xmlChar *out;  
  68.     int ret;  
  69.     int size;  
  70.     int out_size;  
  71.     int temp;  
  72.     xmlCharEncodingHandlerPtr handler;  
  73.     if (in == 0)  
  74.         return 0;  
  75.     /* 查找内建的编码处理器 */  
  76.     handler = xmlFindCharEncodingHandler(encoding);  
  77.     if (!handler) {  
  78.         printf("convertToUTF8From: no encoding handler found for '%s'\n",  
  79.                encoding ? encoding : "");  
  80.         return 0;  
  81.     }  
  82.     size = (int)strlen(in) + 1;  /* 输入数据长度 */  
  83.     out_size = size*2 - 1;  /* 输出数据长度 */  
  84.     /* 存放输出数据 */  
  85.     out = (unsigned char *) xmlMalloc((size_t) out_size);  
  86.     memset(out, 0, out_size);  
  87.   
  88.     if(out != NULL) {  
  89.         temp = size - 1;  
  90.         /* 对输入数据进行编码转换，成功后返回0 */  
  91.         ret = handler->input(out, &out_size, (const xmlChar *) in, &temp);  
  92.         if(ret || temp - size + 1) {  /* 转换不成功 */  
  93.             if(ret){  /* 转换失败 */  
  94.                 printf("convertToUTF8From: conversion wasn't successful.\n");  
  95.             }else{  /* 只转换了一部分数据 */  
  96.                 printf("convertToUTF8From: conversion wasn't successful. converted: %i octets.\n", temp);  
  97.             }  
  98.             xmlFree(out); /* 释放输出缓冲区 */  
  99.             out = 0;  
  100.         }else{  /* 转换成功，在输出末尾加上null终止符 */  
  101.             out = (unsigned char *) xmlRealloc(out, out_size + 1);  
  102.             out[out_size] = 0;  
  103.         }  
  104.     } else {  
  105.         printf("convertToUTF8From: no mem\n");  
  106.     }  
  107.     return out;  
  108. }  
  109.   
  110. /** 
  111.  * utf8ConvertTo: 
  112.  * 把utf-8的数据转换成encoding编码返回 
  113.  * 出错则返回NULL 
  114.  */  
  115. char *utf8ConvertTo(xmlChar *in, const char *encoding){  
  116.     char *out;  
  117.     int ret;  
  118.     int size;  
  119.     int out_size;  
  120.     int temp;  
  121.     xmlCharEncodingHandlerPtr handler;  
  122.   
  123.     if (in == 0)  
  124.         return 0;  
  125.   
  126.     handler = xmlFindCharEncodingHandler(encoding);  
  127.   
  128.     if (!handler) {  
  129.         printf("utf8ConvertTo: no encoding handler found for '%s'\n",  
  130.                encoding ? encoding : "");  
  131.         return 0;  
  132.     }  
  133.   
  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, (const xmlChar *) in, &temp);  
  142.         if(ret || temp - size + 1){  
  143.             if(ret){  
  144.                 printf("utf8ConvertTo: conversion wasn't successful.\n");  
  145.             }else{  
  146.                 printf("utf8ConvertTo: conversion wasn't successful. converted: %i octets.\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: no mem\n");  
  156.     }  
  157.   
  158.     return out;  
  159. }  
  160.   
  161. int main(int argc, char **argv){  
  162.     const char *content;  
  163.     xmlChar *out;  
  164.     xmlDocPtr doc;  
  165.     xmlNodePtr rootnode;  
  166.       
  167.     if (argc <= 1) {  
  168.         printf("Usage: %s content\n", argv[0]);  
  169.         return(0);  
  170.     }  
  171.     content = (const char*)argv[1];  
  172.   
  173.     /* 添加gbk编码支持 */  
  174.     xmlNewCharEncodingHandler("gbk", gbk_input, gbk_output);  
  175.     /* 添加gb2312编码支持：仍然可以使用GBK的输入输出处理器 */  
  176.     xmlNewCharEncodingHandler("gb2312", gbk_input, gbk_output);  
  177.   
  178.     /* 输入的GBK数据转换成libxml2使用的UTF-8格式 */  
  179.     out = convertToUTF8From(content, "gbk");  
  180.     /* 创建xml文档 */  
  181.     doc = xmlNewDoc(BAD_CAST "1.0");  
  182.     rootnode = xmlNewDocNode(doc, NULL, (const xmlChar*)"root", out);  
  183.     xmlDocSetRootElement(doc, rootnode);  
  184.     /* 以gb2312格式保存文档内容："-"表示输出到终端 */  
  185.     xmlSaveFormatFileEnc("-", doc, "gb2312", 1);  
  186.       
  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 plain copy
  1. #include <stdio.h>  
  2. #include <string.h>  
  3. #include <iconv.h>  
  4. #include <libxml/parser.h>  
  5. #include <libxml/tree.h>  
  6.   
  7. /* 代码转换:从一种编码转为另一种编码 */  
  8. int encoding_convert(const char *from_charset, const char *to_charset,   
  9.             char *inbuf, int inlen,   
  10.             char* outbuf, int outlen){  
  11.   
  12.     iconv_t cd;  
  13.     size_t len1, len2, rslt;  
  14.   
  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;    
  30.   
  31.     iconv_close(cd); /* 释放描述符 */  
  32.     return 0;    
  33.   
  34. }  
  35.   
  36. /* GB2312转换为UTF-8  
  37.  * 成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL 
  38.  */  
  39. char *gb2312_utf8(char *inbuf){  
  40.     int nOutLen = 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.     return szOut;  
  47. }  
  48.   
  49. /* UTF-8转换为GB2312 
  50.  * 成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL 
  51.  */  
  52. char *utf8_gb2312(char *inbuf){  
  53.     int nOutLen = 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.     return szOut;  
  60. }  
  61.   
  62. int main(int argc, char **argv){  
  63.     /* 定义文档节点和指针 */  
  64.     xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");  
  65.     xmlNodePtr root_node=xmlNewNode(NULL, BAD_CAST "root");  
  66.     /* 设置根节点 */  
  67.     xmlDocSetRootElement(doc, root_node);  
  68.   
  69.     /* 一个中文字符串转换为UTF-8字符串，然后写入 */  
  70.     char *szOut=gb2312_utf8("节点1的内容");  
  71.     /* 在根节点中直接创建节点 */  
  72.     xmlNewTextChild(root_node, NULL, BAD_CAST "newNode1", BAD_CAST "newNode1 content");  
  73.     xmlNewTextChild(root_node, NULL, BAD_CAST "newNode2", BAD_CAST "newNode2 content");  
  74.     xmlNewTextChild(root_node, NULL, BAD_CAST "newNode3", BAD_CAST "newNode3 content");  
  75.     xmlNewChild(root_node, NULL, BAD_CAST "node1",BAD_CAST szOut);  
  76.     xmlFree(szOut);  
  77.   
  78.     /* 创建一个节点，设置其内容和属性，然后加入根结点 */  
  79.     xmlNodePtr node = xmlNewNode(NULL,BAD_CAST "node2");  
  80.     xmlNodePtr content = xmlNewText(BAD_CAST "NODE CONTENT");  
  81.     xmlAddChild(root_node,node);  
  82.     xmlAddChild(node,content);  
  83.     szOut = gb2312_utf8("属性值");  
  84.     xmlNewProp(node,BAD_CAST "attribute",BAD_CAST szOut);  
  85.     xmlFree(szOut);  
  86.   
  87.     /* 创建一个中文节点 */  
  88.     szOut = gb2312_utf8("中文节点");  
  89.     xmlNewChild(root_node, NULL, BAD_CAST szOut,BAD_CAST "content of chinese node");  
  90.     xmlFree(szOut);  
  91.   
  92.     /* 存储xml文档 */  
  93.     int nRel = xmlSaveFormatFileEnc("CreatedXml_cn.xml",doc,"GB2312",1);  
  94.     if (nRel != -1){  
  95.         printf("一个xml文档被创建,写入%d个字节", nRel);  
  96.     }  
  97.   
  98.     xmlFreeDoc(doc);  
  99.     return 1;  
  100. }  
    这个例子中，当把中文数据写入到XML节点时，使用gb2312_utf8()直接转换成UTF-8格式，这种直接通过iconv转换的方式更高效。编译并运行程序，输出文档如下：
[html]  view plain copy
  1. <?xml version="1.0" encoding="GB2312"?>  
  2. <root>  
  3.     <newNode1>newNode1 content</newNode1>  
  4.     <newNode2>newNode2 content</newNode2>  
  5.     <newNode3>newNode3 content</newNode3>  
  6.     <node1>节点1的内容</node1>  
  7.     <node2 attribute="属性值">NODE CONTENT</node2>  
  8.     <中文节点>content of chinese node</中文节点>  
  9. </root>     
     6、一个真实的例子
    内容整理自 http://xmlsoft.org/example.html 。
    下面是一个真实的例子。应用程序数据的内容不使用DOM树，而是使用内部数据结构来保存。这是一个基于XML存储结构的数据库，它保存了与Gnome相关的任务。如下：
[html]  view plain copy
  1. <?xml version="1.0"?>  
  2. <gjob:Helping xmlns:gjob="http://www.gnome.org/some-location">  
  3.   <gjob:Jobs>  
  4.   
  5.     <gjob:Job>  
  6.       <gjob:Project ID="3"/>  
  7.       <gjob:Application>GBackup</gjob:Application>  
  8.       <gjob:Category>Development</gjob:Category>  
  9.   
  10.       <gjob:Update>  
  11.         <gjob:Status>Open</gjob:Status>  
  12.         <gjob:Modified>Mon, 07 Jun 1999 20:27:45 -0400 MET DST</gjob:Modified>  
  13.         <gjob:Salary>USD 0.00</gjob:Salary>  
  14.       </gjob:Update>  
  15.   
  16.       <gjob:Developers>  
  17.         <gjob:Developer>  
  18.         </gjob:Developer>  
  19.       </gjob:Developers>  
  20.   
  21.       <gjob:Contact>  
  22.         <gjob:Person>Nathan Clemons</gjob:Person>  
  23.         <gjob:Email>[email protected]</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>  
  35.   
  36.       <gjob:Requirements>  
  37.       The program should be released as free software, under the GPL.  
  38.       </gjob:Requirements>  
  39.   
  40.       <gjob:Skills>  
  41.       </gjob:Skills>  
  42.   
  43.       <gjob:Details>  
  44.       A GNOME based system that will allow a superuser to configure   
  45.       compressed and uncompressed files and/or file systems to be backed   
  46.       up with a supported media in the system.  This should be able to   
  47.       perform via find commands generating a list of files that are passed   
  48.       to tar, dd, cpio, cp, gzip, etc., to be directed to the tape machine   
  49.       or via operations performed on the filesystem itself. Email   
  50.       notification and GUI status display very important.  
  51.       </gjob:Details>  
  52.   
  53.     </gjob:Job>  
  54.   
  55.   </gjob:Jobs>  
  56. </gjob:Helping>  
    把XML文件加载到一个内部DOM树中只是调用几个函数的问题，而遍历整个树来收集数据，并生成内部结构则更困难，也更容易出错。
    对输入结构的定义法则是非常宽松的。属性的顺序无关紧要（XML规范清楚地说明了这一点），不要依赖于一个节点的子节点顺序通常是一个好的主意，除非这样做真的使事情变得更困难了。下面是解析person信息的一段代码：
[cpp]  view plain copy
  1. /* 
  2.  * 一个person记录 
  3.  */  
  4. typedef struct person {  
  5.     char *name;  
  6.     char *email;  
  7.     char *company;  
  8.     char *organisation;  
  9.     char *smail;  
  10.     char *webPage;  
  11.     char *phone;  
  12. } person, *personPtr;  
  13.   
  14. /* 
  15.  * 解析person的代码 
  16.  */  
  17. personPtr parsePerson(xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur) {  
  18.     personPtr ret = NULL;  
  19.   
  20. DEBUG("parsePerson\n");  
  21.     /* 
  22.      * 为结构分配内存 
  23.      */  
  24.     ret = (personPtr) malloc(sizeof(person));  
  25.     if (ret == NULL) {  
  26.         fprintf(stderr,"out of memory\n");  
  27.         return(NULL);  
  28.     }  
  29.     memset(ret, 0, sizeof(person));  
  30.   
  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.     }  
  40.   
  41.     return(ret);  
  42. }  
    下面是要注意的一些事项：
    （1）通常一个递归的解析风格是更方便的：XML数据天然地遵循重复式地构造，并且是高度结构化的。
    （2）两个参数是xmlDocPtr和xmlNsPtr类型，即指向XML文档和应用程序保留的命名空间的指针。文档信息非常广泛，为你的应用程序数据集定义一个命名空间并测试元素和属性是否属性这个空间是一个好的编程实践。这只需一个简单的相等测试（cur->ns == ns）。
    （3）为了查询文本和属性值，你可以使用函数xmlNodeListGetString()来获取所有文本，和由DOM输出生成的引用节点，并生成一个单一的文本字符串。
    下面是解析另外一个结构的代码片段：
[cpp]  view plain copy
  1. #include <libxml/tree.h>  
  2. /* 
  3.  * 一个Job的描述 
  4.  */  
  5. typedef struct job {  
  6.     char *projectID;  
  7.     char *application;  
  8.     char *category;  
  9.     personPtr contact;  
  10.     int nbDevelopers;  
  11.     personPtr developers[100]; /* using dynamic alloc is left as an exercise */  
  12. } job, *jobPtr;  
  13.   
  14. /* 
  15.  * 解析Job的代码 
  16.  */  
  17. jobPtr parseJob(xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur) {  
  18.     jobPtr ret = NULL;  
  19.   
  20. DEBUG("parseJob\n");  
  21.     /* 
  22.      * 为结构分配内存 
  23.      */  
  24.     ret = (jobPtr) malloc(sizeof(job));  
  25.     if (ret == NULL) {  
  26.         fprintf(stderr,"out of memory\n");  
  27.         return(NULL);  
  28.     }  
  29.     memset(ret, 0, sizeof(job));  
  30.   
  31.     /* 我们不关心顶层元素名是什么 */  
  32.     cur = cur->xmlChildrenNode;  
  33.     while (cur != NULL) {  
  34.           
  35.         if ((!strcmp(cur->name, "Project")) && (cur->ns == ns)) {  
  36.             ret->projectID = xmlGetProp(cur, "ID");  
  37.             if (ret->projectID == NULL) {  
  38.                 fprintf(stderr, "Project has no ID\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.     }  
  49.   
  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文档。

你可能感兴趣的:(libxml2 使用教程)

  • 教程 | Ventoy全攻略：2025最新安装与使用教程，打造万能多系统启动盘 The god of big data 教程神器？三叉戟？虚拟系统系统架构
    一、Ventoy简介与核心优势Ventoy是一款开源免费的多系统启动盘工具，支持Windows、Linux、macOS等操作系统及各类维护工具。其最大特点是无需反复格式化U盘，只需将ISO/WIM/IMG等镜像文件直接拷贝至U盘即可启动，且支持LegacyBIOS与UEFI双模式。相较于传统工具，Ventoy的优势包括：多系统兼容性：支持超1000种ISO镜像，涵盖主流操作系统及工具（如Windo
  • 怎么使用DeepSeek？DeepSeek使用教程 轻创思维 网络
    1.简介DeepSeek是一款基于人工智能技术的智能搜索引擎和信息检索工具。它能够通过自然语言处理技术理解用户的查询需求，并提供精准、全面的搜索结果。无论您是想查找信息、解答问题还是进行创意写作，DeepSeek都能为您提供高效的支持。2.主要功能智能搜索：支持自然语言输入，快速获取精准结果。多语言支持：支持中文、英文及其他多种语言的输入和输出。知识库覆盖：整合海量互联网信息，覆盖百科、新闻、学术
  • PyTorch使用教程(10)-torchinfo.summary网络结构可视化详细说明 深图智能 深度学习教程深度学习pythonpytorch人工智能
    1、基本介绍torchinfo是一个为PyTorch用户量身定做的开源工具，其核心功能之一是summary函数。这个函数旨在简化模型的开发与调试流程，让模型架构一目了然。通过torchinfo的summary函数，用户可以快速获取模型的详细结构和统计信息，如模型的层次结构、输入/输出维度、参数数量、多加操作(Mult-Adds)等关键信息。2、安装首先，你需要安装torchinfo库。可以通过pi
  • 浅谈十大源码交易平台，找源码不走弯路 17源码网 游戏源代码管理
    大家好啊，作为一名经历了无数代码风风雨雨的资深老码农，今天我就来跟你们聊聊十大源码交易平台。这可是我多年经验的结晶，希望你们能从中找到自己需要的宝贝。七爪网：七爪网，这名字很生动。七爪网提供各种类型的源码，包括游戏源码、分销商城源码、小程序源码等等，简直是码农的百宝箱。不管你是初学者还是经验丰富的老鸟，总能在这里找到适合的资源。而且，七爪网还提供详细的使用教程和技术支持，真是想得太周到了。86资源
  • 【NLP-04】tranformers库保姆级使用教程---以BERT模型为例 云天徽上 NLPbert人工智能深度学习自然语言处理机器学习numpy信息可视化
    安装要安装一个非常轻量级的Transformers库，您可以执行以下步骤：1、打开终端或命令提示符。2、运行以下命令来安装Transformers库：pipinstalltransformers这将使用pip工具从PythonPackageIndex（PyPI）下载并安装Transformers库。请确保您的计算机上已经安装了pip。然后，您可以在Python代码中导入Transformers库：
  • M1/M2/Intel芯片安装Parallels Desktop 19虚拟机安装使用教程（超详细保姆级教程） 小白教程 mac虚拟机操作系统macwindows
    文章目录概要1.下载安装工具包2.安装过程3.安装长期使用工具包（超级重要）4.最后点个赞，关注一下。（超级重要）概要今日，为大家带来最新版ParallelsDesktop19的详细安装与使用教程。在Mac设备上，想要使用win系统无疑ParallelsDesktop堪称最强虚拟机软件；让我们一块尽情体验他的强大吧！1.下载安装工具包下载方式1：官方正版ParallelsDesktop19安装包下
  • 编译安装php7.2 raoxiaoya PHPphp服务器开发语言
    编译安装php7.2centos-7.064groupaddwwwuseradd-gwwwwww1、先安装如下依赖包yuminstall-ygccgcc-c++makezlibzlib-develpcrepcre-devellibjpeglibjpeg-devellibpnglibpng-develfreetypefreetype-devellibxml2libxml2-develglibcgli
  • python aiohttp简易使用教程 Amos_x pythonpythonaiohttp异步
    0.前言本文翻译自aiohttp的官方文档，如有纰漏，欢迎指出。aiohttp分为服务器端和客户端，本文只介绍客户端。另外我已经对aiohttp和asyncio进行了封装，可以参考我的github地址：https://github.com/web-trump/ahttp由于上下文的缘故，请求代码必须在一个异步的函数中进行：asyncdeffn():pass1.aiohttp安装pip3instal
  • STM32MP2 系列 RIF 资源隔离框架使用教程 最后一个bug 主流单片机开发(MCU)linux应用程序开发linux内核设计与实现stm32嵌入式硬件单片机
    STM32MP2系列RIF资源隔离框架使用教程一、RIF是什么RIF就像是STM32MP2系列芯片的“安全卫士”，能把芯片里不同的运行区域隔离开，保护内部内存、外部内存和内部外设不被随意访问。在芯片这个“小世界”里，不同的程序和设备就像不同的“居民”，RIF确保每个“居民”只能在自己的“地盘”活动，不能随便闯入别人的区域捣乱。（一）关键术语CID（隔间标识符）：可以把CID想象成每个“居民”（总线
  • DocHub 开源项目安装与使用教程 羿漪沁Halbert
    DocHub开源项目安装与使用教程DocHubУправлениеархитектуройкаккодом项目地址:https://gitcode.com/gh_mirrors/doch/DocHub1.项目目录结构及介绍DocHub项目的目录结构如下：dochub/├──browserslistrc#浏览器兼容性配置文件├──dockerignore#Docker忽略文件├──editorcon
  • YIUI Unity UI框架安装与使用教程 翟培任Lame
    YIUIUnityUI框架安装与使用教程YIUIUnity3DUGUIFramework项目地址:https://gitcode.com/gh_mirrors/yi/YIUI1.项目目录结构及介绍YIUI项目的目录结构如下：YIUI/├──YIUIFramework/│├──Assets/││├──Scripts/││├──Resources/││├──Scenes/││├──Shaders/││
  • Pandas使用教程 - 多级索引 (MultiIndex) 闲人编程 Pandas使用教程pandasMultiIndex多级索引元组分组聚合python
    目录1.什么是MultiIndex？2.MultiIndex的创建2.1从多个数组或列表创建MultiIndex2.2从元组列表创建MultiIndex2.3使用DataFrame的set_index()创建MultiIndex3.MultiIndex的基本操作3.1索引与切片3.1.1访问特定级别的数据3.1.2使用xs()方法进行跨层次切片3.2重新排列和重设索引3.2.1swaplevel(
  • Node.js使用教程 m0_74824112 面试学习路线阿里巴巴node.jsvim编辑器
    Node.js使用教程Node.js是一个基于ChromeV8引擎的JavaScript运行环境，它让JavaScript运行在服务器端。以下是一个简单的Node.js使用教程：一、Node.js开发环境和编译1.1安装Node.js访问Node.js官网下载并安装适合您操作系统的Node.js版本。1.2创建一个Node.js项目在您的工作目录中，创建一个新的文件夹作为项目目录，例如命名为my_
  • Java 现代化日期时间api使用教程 java
    简介在Java中，处理日期和时间对于许多应用程序都是必不可少的。Java随着时间的推移而发展，随着Java8的引入，引入了java.time包，为日期和时间操作提供了更现代、更全面的API。旧版java.util.Date类（Java8之前）在Java8之前，Java使用java.util.Date类来表示日期和时间。然而，它存在许多设计问题，并且不易于使用（例如，易变性、日期和时间之间的混淆）。
  • JSON-Schema-Editor 使用教程 邱进斌Olivia
    JSON-Schema-Editor使用教程json-schema-editorJSONSchemaEditorisanintuitiveeditorforJSONschema.Itprovidesatreeviewtopresentthestructureofschema,andapropertyinspectortoeditthepropertiesofschemaelement.Develo
  • 视频实时换F！完全免费，直播特效、OBS美颜、AI卡通人物等，用 Snap Camera 就够了，附最新安装使用教程！简直无敌,结合使用RTranslator可离线使用的实时翻译、同声传译软件免费开源 代码讲故事 深耕技术之源美颜直播特效卡通翻译传译视频
    视频实时换lian！完全免费，直播特效、OBS美颜、AI卡通人物等，用SnapCamera就够了，附最新安装使用教程！简直无敌结合RTranslator可离线使用的实时翻译、同声传译软件免费开源。RTranslator可离线使用的实时翻译、同声传译软件！免费开源RTranslator是一款适用于Android的（几乎）开源、免费、离线实时翻译应用程序。连接到拥有该应用程序的人，连接蓝牙耳机，将手机
  • 一个简单的Backtrader使用示例教程 数字花园笔记 pandaspython数据分析
    Backtrader是一个用于构建、回测和部署交易策略的Python框架。以下是一个简单的Backtrader使用教程，可以帮助您开始使用Backtrader进行交易策略的开发和测试。安装Backtrader首先，您需要安装Backtrader库。您可以使用以下命令在命令行中安装：Copypipinstallbacktrader准备数据在使用Backtrader进行回测之前，您需要准备好历史市场数
  • 全网最全 Aspose.Words for Java 高级使用教程 一只蜗牛儿 java开发语言
    Aspose.WordsforJava是一款功能强大的文档处理库，允许开发者创建、修改、转换和打印文档。本文将详细介绍Aspose.WordsforJava的高级使用方法，并重点讲解如何在文档中添加水印。目录Aspose.WordsforJava简介安装Aspose.WordsforJava创建和操作文档添加水印文档转换高级功能示例代码总结1.Aspose.WordsforJava简介Aspose
  • Linux定时任务crontab使用教程 weixin_34290000 python操作系统
    2019独角兽企业重金招聘Python工程师标准>>>在日常的开发中，crontab（时程表）应该是最常用的指令之一，下面我们来看看百度百科的解释：crontab命令常见于Unix和类Unix的操作系统之中，用于设置周期性被执行的指令。该命令从标准输入设备读取指令，并将其存放于“crontab”文件中，以供之后读取和执行。该词来源于希腊语chronos(χρνο)，原意是时间。通常，crontab
  • ubuntu crontab使用教程 fhxd linux学习
    1.在terminal输入：crontab-e,第一次需要选择默认编辑器（选择/bin/nano即选项2），其它命令请用crontab--help2.如果第一步选择错误，需要重新选择编辑器使用sdoselect-editor3.在弹出的vim中按照规定格式配置任务即可。在这些字段里，除了“Command”是每次都必须指定的字段以外，其它字段皆为可选字段，可视需要决定。对于不指定的字段，要用“*”来
  • Crontab使用教程 IKun-bug linux运维服务器
    目录什么是Crontab验证cron是否已安装并可用检查服务状态：安装cronie（或crond）在CentOS、RHEL、Fedora：在Ubuntu/Debian：验证安装是否成功：Crontab基本语法示例Crontab的基本操作创建/编辑任务查看现有任务删除所有任务什么是Crontabcrontab是Linux下用于定时执行任务的重要工具，它通过简单的语法在指定时间周期内执行相关的命令或脚
  • DuckDB FDW 使用教程 邓娉靓Melinda
    DuckDBFDW使用教程项目地址:https://gitcode.com/gh_mirrors/du/duckdb_fdw项目介绍DuckDBFDW（ForeignDataWrapper）是一个用于PostgreSQL的外部数据包装器，它允许PostgreSQL数据库直接访问和查询DuckDB数据库中的数据。DuckDB是一个嵌入式SQL数据库，专为OLAP场景设计，具有高性能和低延迟的特点。通
  • DuckDB Postgres Scanner 扩展使用教程 沈如廷
    DuckDBPostgresScanner扩展使用教程postgres_scanner项目地址:https://gitcode.com/gh_mirrors/po/postgres_scanner1.项目介绍DuckDBPostgresScanner是一个开源项目，允许DuckDB直接从运行的Postgres数据库实例中读取和写入数据。通过这个扩展，用户可以直接查询Postgres数据库中的数据，
  • LTP/pyltp安装和使用教程 Cachel wood 自然语言处理nlpeasyui前端javascriptpyltpltp人工智能nlp
    文章目录LTP介绍分句分词加载外部词典个性化分词词性标注命名实体识别NER依存句法分析语义角色标注LTP介绍官网：https://ltp.ai/下载可以到官网的下载专区：https://ltp.ai/download.html语言技术平台（LanguageTechnologyPlatform，LTP）：是哈工大社会计算与信息检索研究中心历时十年研制的一整套开放中文自然语言处理系统。提供了一整套自底
  • DeepSeek关联Excel使用教程 CodeJourney. 数据库人工智能算法
    在数字化办公的浪潮中，将先进的人工智能技术与常用办公软件相结合，能为我们的工作效率带来质的飞跃。DeepSeek作为一款强大的人工智能模型，与Excel这一办公必备工具的关联，为数据处理、分析和可视化等工作开辟了全新的路径。本文将详细介绍DeepSeek关联Excel的多种方法、常见应用场景、高级应用技巧、实际操作注意事项以及常见问题的解决方法，帮助你充分挖掘二者结合的潜力。一、关联方法插件接入法
  • 【Milvus】向量数据库pymilvus使用教程 深度求索者 数据库milvusoracle
    以下是根据Milvus官方文档整理的详细PyMilvus使用教程，基于Milvus2.5.x版本：PyMilvus使用教程目录安装与环境准备连接Milvus服务数据模型基础概念创建集合（Collection）插入数据创建索引向量搜索删除操作完整示例注意事项安装与环境准备搭建Milvus服务基于Docker#记得提前安装Dockercurl-sfLhttps://raw.githubusercont
  • DeepSeek关联PPT使用教程 CodeJourney. 数据库人工智能算法
    在当今数字化办公和学习的快节奏环境中，制作高质量的PPT已经成为我们工作和学习中不可或缺的技能。无论是商务汇报、学术展示还是教学课件，一份出色的PPT都能让你的表达更加清晰、有力，吸引观众的注意力。然而，制作PPT往往需要投入大量的时间和精力，从构思内容框架到设计页面布局，每一个环节都需要精心打磨。幸运的是，随着人工智能技术的飞速发展，像DeepSeek这样强大的AI工具为我们提供了新的解决方案，
  • 高级记事本 Sublime Text 下载与使用教程：附百度网盘地址 爆爆凯 好用工具推荐sublimetext编辑器
    一、引言在编程和文本编辑领域，SublimeText被誉为一款功能强大的高级记事本。它以其轻量级、高效、多语言支持等特点，深受开发者和文本工作者的喜爱。本文将详细介绍SublimeText的下载方法、安装步骤、使用技巧，并提供百度网盘下载地址，同时对文章进行SEO优化，以提高其在搜索引擎中的可见度。二、SublimeText下载（一）、官网下载SublimeText的官方网站提供了最新版本的下载链
  • Snipaste 截图软件下载与使用教程：附百度网盘地址 爆爆凯 好用工具推荐java
    一、引言在数字化办公和学习的过程中，截图工具成为了我们日常操作中不可或缺的助手。Snipaste作为一款功能强大的截图软件，以其简洁的操作界面和丰富的功能特性，赢得了广大用户的青睐。本文将详细介绍Snipaste截图软件的下载方法、安装步骤、使用技巧，并提供百度网盘下载地址，同时对文章进行SEO优化，以提高其在搜索引擎中的可见度。二、Snipaste截图软件下载（一）、官网下载Snipaste的官
  • Jenkins 使用教程：从入门到精通 kld230 jenkinsgogit
    在软件开发的复杂流程中，持续集成与持续交付（CI/CD）是提升开发效率和保障软件质量的核心实践。Jenkins作为一款备受欢迎的开源自动化服务器，在CI/CD流程中发挥着举足轻重的作用。本文将深入、详细地介绍Jenkins的使用方法，帮助你迅速上手并熟练掌握其关键要点。一、Jenkins的安装1.环境准备Jenkins基于Java开发，因此安装前确保服务器已正确安装Java环境。通过在命令行输入j
  • 开发者关心的那些事 圣子足道 ios游戏编程apple支付
    我要在app里添加IAP，必须要注册自己的产品标识符（product identifiers）。产品标识符是什么？ 产品标识符（Product Identifiers）是一串字符串，它用来识别你在应用内贩卖的每件商品。App Store用产品标识符来检索产品信息，标识符只能包含大小写字母（A-Z）、数字（0-9）、下划线（-）、以及圆点(.)。你可以任意排列这些元素，但我们建议你创建标识符时使用
  • 负载均衡器技术Nginx和F5的优缺点对比 bijian1013 nginxF5
            对于数据流量过大的网络中，往往单一设备无法承担，需要多台设备进行数据分流，而负载均衡器就是用来将数据分流到多台设备的一个转发器。         目前有许多不同的负载均衡技术用以满足不同的应用需求，如软/硬件负载均衡、本地/全局负载均衡、更高
  • LeetCode[Math] - #9 Palindrome Number Cwind javaAlgorithm题解LeetCodeMath
    原题链接：#9 Palindrome Number   要求： 判断一个整数是否是回文数，不要使用额外的存储空间   难度：简单   分析： 题目限制不允许使用额外的存储空间应指不允许使用O(n)的内存空间，O(1)的内存用于存储中间结果是可以接受的。于是考虑将该整型数反转，然后与原数字进行比较。 注：没有看到有关负数是否可以是回文数的明确结论，例如
  • 画图板的基本实现 15700786134 画图板
     要实现画图板的基本功能，除了在qq登陆界面中用到的组件和方法外，还需要添加鼠标监听器，和接口实现。 首先，需要显示一个JFrame界面： public class DrameFrame extends JFrame {              //显示
  • linux的ps命令 被触发 linux
    Linux中的ps命令是Process Status的缩写。ps命令用来列出系统中当前运行的那些进程。ps命令列出的是当前那些进程的快照，就是执行ps命令的那个时刻的那些进程，如果想要动态的显示进程信息，就可以使用top命令。 要对进程进行监测和控制，首先必须要了解当前进程的情况，也就是需要查看当前进程，而 ps 命令就是最基本同时也是非常强大的进程查看命令。使用该命令可以确定有哪些进程正在运行
  • Android 音乐播放器 下一曲 连续跳几首歌 肆无忌惮_ android
    最近在写安卓音乐播放器的时候遇到个问题。在MediaPlayer播放结束时会回调 player.setOnCompletionListener(new OnCompletionListener() { @Override public void onCompletion(MediaPlayer mp) { mp.reset(); Log.i("H
  • java导出txt文件的例子 知了ing javaservlet
    代码很简单就一个servlet,如下： package com.eastcom.servlet; import java.io.BufferedOutputStream; import java.io.IOException; import java.net.URLEncoder; import java.sql.Connection; import java.sql.Resu
  • Scala stack试玩, 提高第三方依赖下载速度 矮蛋蛋 scalasbt
    原文地址： http://segmentfault.com/a/1190000002894524 sbt下载速度实在是惨不忍睹, 需要做些配置优化 下载typesafe离线包, 保存为ivy本地库 wget http://downloads.typesafe.com/typesafe-activator/1.3.4/typesafe-activator-1.3.4.zip 解压r
  • phantomjs安装(linux，附带环境变量设置) ，以及casperjs安装。 alleni123 linuxspider
    1. 首先从官网 http://phantomjs.org/下载phantomjs压缩包，解压缩到/root/phantomjs文件夹。 2. 安装依赖 sudo yum install fontconfig freetype libfreetype.so.6 libfontconfig.so.1 libstdc++.so.6 3. 配置环境变量 vi /etc/profil
  • JAVA IO FileInputStream和FileOutputStream，字节流的打包输出 百合不是茶 java核心思想JAVA IO操作字节流
    在程序设计语言中，数据的保存是基本，如果某程序语言不能保存数据那么该语言是不可能存在的，JAVA是当今最流行的面向对象设计语言之一，在保存数据中也有自己独特的一面，字节流和字符流 1，字节流是由字节构成的，字符流是由字符构成的 字节流和字符流都是继承的InputStream和OutPutStream ,java中两种最基本的就是字节流和字符流   类 FileInputStream
  • Spring基础实例（依赖注入和控制反转） bijian1013 spring
    前提条件：在http://www.springsource.org/download网站上下载Spring框架，并将spring.jar、log4j-1.2.15.jar、commons-logging.jar加载至工程1.武器接口 package com.bijian.spring.base3; public interface Weapon { void kil
  • HR看重的十大技能 bijian1013 提升能力HR成长
        一个人掌握何种技能取决于他的兴趣、能力和聪明程度，也取决于他所能支配的资源以及制定的事业目标，拥有过硬技能的人有更多的工作机会。但是，由于经济发展前景不确定，掌握对你的事业有所帮助的技能显得尤为重要。以下是最受雇主欢迎的十种技能。 　　一、解决问题的能力 　　每天，我们都要在生活和工作中解决一些综合性的问题。那些能够发现问题、解决问题并迅速作出有效决
  • 【Thrift一】Thrift编译安装 bit1129 thrift
    什么是Thrift The Apache Thrift software framework, for scalable cross-language services development, combines a software stack with a code generation engine to build services that work efficiently and s
  • 【Avro三】Hadoop MapReduce读写Avro文件 bit1129 mapreduce
    Avro是Doug Cutting(此人绝对是神一般的存在）牵头开发的。 开发之初就是围绕着完善Hadoop生态系统的数据处理而开展的（使用Avro作为Hadoop MapReduce需要处理数据序列化和反序列化的场景）,因此Hadoop MapReduce集成Avro也就是自然而然的事情。 这个例子是一个简单的Hadoop MapReduce读取Avro格式的源文件进行计数统计，然后将计算结果
  • nginx定制500，502，503，504页面 ronin47 nginx　错误显示
    server { listen 80; error_page 500/500.html; error_page 502/502.html; error_page 503/503.html; error_page 504/504.html; location /test {return502;}} 配置很简单，和配
  • java-1.二叉查找树转为双向链表 bylijinnan 二叉查找树
    import java.util.ArrayList; import java.util.List; public class BSTreeToLinkedList { /* 把二元查找树转变成排序的双向链表 题目： 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。 要求不能创建任何新的结点，只调整指针的指向。 10 / \ 6 14 / \
  • Netty源码学习-HTTP-tunnel bylijinnan javanetty
    Netty关于HTTP tunnel的说明： http://docs.jboss.org/netty/3.2/api/org/jboss/netty/channel/socket/http/package-summary.html#package_description 这个说明有点太简略了 一个完整的例子在这里： https://github.com/bylijinnan
  • JSONUtil.serialize(map)和JSON.toJSONString(map)的区别 coder_xpf jqueryjsonmapval()
     JSONUtil.serialize(map)和JSON.toJSONString(map)的区别   数据库查询出来的map有一个字段为空   通过System.out.println()输出 JSONUtil.serialize(map)： {"one":"1","two":"nul
  • Hibernate缓存总结 cuishikuan 开源sshjavawebhibernate缓存三大框架
    一、为什么要用Hibernate缓存？ Hibernate是一个持久层框架，经常访问物理数据库。 为了降低应用程序对物理数据源访问的频次，从而提高应用程序的运行性能。 缓存内的数据是对物理数据源中的数据的复制，应用程序在运行时从缓存读写数据，在特定的时刻或事件会同步缓存和物理数据源的数据。   二、Hibernate缓存原理是怎样的？ Hibernate缓存包括两大类：Hib
  • CentOs6 dalan_123 centos
    首先su - 切换到root下面1、首先要先安装GCC GCC-C++ Openssl等以来模块：yum -y install make gcc gcc-c++ kernel-devel m4 ncurses-devel openssl-devel2、再安装ncurses模块yum -y install ncurses-develyum install ncurses-devel3、下载Erang
  • 10款用 jquery 实现滚动条至页面底端自动加载数据效果 dcj3sjt126com JavaScript
      无限滚动自动翻页可以说是web2.0时代的一项堪称伟大的技术，它让我们在浏览页面的时候只需要把滚动条拉到网页底部就能自动显示下一页的结果，改变了一直以来只能通过点击下一页来翻页这种常规做法。 无限滚动自动翻页技术的鼻祖是微博的先驱：推特(twitter)，后来必应图片搜索、谷歌图片搜索、google reader、箱包批发网等纷纷抄袭了这一项技术，于是靠滚动浏览器滚动条
  • ImageButton去边框&Button或者ImageButton的背景透明 dcj3sjt126com imagebutton
    在ImageButton中载入图片后，很多人会觉得有图片周围的白边会影响到美观，其实解决这个问题有两种方法 一种方法是将ImageButton的背景改为所需要的图片。如：android:background="@drawable/XXX" 第二种方法就是将ImageButton背景改为透明，这个方法更常用 在XML里；    <ImageBut
  • JSP之c:foreach eksliang jspforearch
    原文出自：http://www.cnblogs.com/draem0507/archive/2012/09/24/2699745.html <c:forEach>标签用于通用数据循环，它有以下属性 属 性 描 述 是否必须 缺省值 items 进行循环的项目 否 无 begin 开始条件 否 0 end 结束条件 否 集合中的最后一个项目 step 步长 否 1
  • Android实现主动连接蓝牙耳机 gqdy365 android
    在Android程序中可以实现自动扫描蓝牙、配对蓝牙、建立数据通道。蓝牙分不同类型，这篇文字只讨论如何与蓝牙耳机连接。 大致可以分三步： 一、扫描蓝牙设备： 1、注册并监听广播： BluetoothAdapter.ACTION_DISCOVERY_STARTED BluetoothDevice.ACTION_FOUND BluetoothAdapter.ACTION_DIS
  • android学习轨迹之四：org.json.JSONException: No value for hyz301 json
    org.json.JSONException: No value for items  在JSON解析中会遇到一种错误，很常见的错误   06-21 12:19:08.714 2098-2127/com.jikexueyuan.secret I/System.out﹕ Result:{"status":1,"page":1,&
  • 干货分享：从零开始学编程 系列汇总 justjavac 编程
    程序员总爱重新发明轮子，于是做了要给轮子汇总。 从零开始写个编译器吧系列 (知乎专栏) 从零开始写一个简单的操作系统 (伯乐在线) 从零开始写JavaScript框架 (图灵社区) 从零开始写jQuery框架 (蓝色理想 ) 从零开始nodejs系列文章 (粉丝日志) 从零开始编写网络游戏 
  • jquery-autocomplete 使用手册 macroli jqueryAjax脚本
    jquery-autocomplete学习 一、用前必备 官方网站：http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/ 当前版本：1.1 需要JQuery版本：1.2.6 二、使用 <script src="./jquery-1.3.2.js" type="text/ja
  • PLSQL-Developer或者Navicat等工具连接远程oracle数据库的详细配置以及数据库编码的修改 超声波 oracleplsql
    　　在服务器上将Oracle安装好之后接下来要做的就是通过本地机器来远程连接服务器端的oracle数据库，常用的客户端连接工具就是PLSQL-Developer或者Navicat这些工具了。刚开始也是各种报错，什么TNS:no listener;TNS:lost connection;TNS:target hosts...花了一天的时间终于让PLSQL-Developer和Navicat等这些客户
  • 数据仓库数据模型之：极限存储--历史拉链表 superlxw1234 极限存储数据仓库数据模型拉链历史表
    在数据仓库的数据模型设计过程中，经常会遇到这样的需求： 1. 数据量比较大; 2. 表中的部分字段会被update,如用户的地址，产品的描述信息，订单的状态等等; 3. 需要查看某一个时间点或者时间段的历史快照信息，比如，查看某一个订单在历史某一个时间点的状态，    比如，查看某一个用户在过去某一段时间内，更新过几次等等; 4. 变化的比例和频率不是很大，比如，总共有10
  • 10点睛Spring MVC4.1-全局异常处理 wiselyman spring mvc
    10.1 全局异常处理 使用@ControllerAdvice注解来实现全局异常处理; 使用@ControllerAdvice的属性缩小处理范围 10.2 演示 演示控制器 package com.wisely.web; import org.springframework.stereotype.Controller; import org.spring
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他