Chinamming

libxml2剖析(3)：使用教程

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

示例文档story.xml如下：

[html] view plain copy print ?

<?xml version="1.0"?>
<story>
<storyinfo>
<author>John Fleck</author>
<datewritten>June 2, 2002</datewritten>
<keyword>example keyword</keyword>
</storyinfo>
<body>
<headline>This is the headline</headline>
<para>This is the body text.</para>
</body>
</story>

<?xml version="1.0"?>
<story>
  <storyinfo>
    <author>John Fleck</author>
    <datewritten>June 2, 2002</datewritten>
    <keyword>example keyword</keyword>
  </storyinfo>
  <body>
    <headline>This is the headline</headline>
    <para>This is the body text.</para>
  </body>
</story>

1、解析xml文档
解析文档时只需要文档名和一个函数调用，再加上错误处理。下面代码查找keyword节点并打印节点下的文本内容，如下：

[cpp] view plain copy print ?

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
/* 解析storyinfo节点，打印keyword节点的内容 */
void parseStory(xmlDocPtr doc, xmlNodePtr cur){
xmlChar* key;
cur=cur->xmlChildrenNode;
while(cur != NULL){
/* 找到keyword子节点 */
if(!xmlStrcmp(cur->name, (const xmlChar *)"keyword")){
key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
printf("keyword: %s\n", key);
xmlFree(key);
}
cur=cur->next; /* 下一个子节点 */
}
return;
}
/* 解析文档 */
static void parseDoc(char *docname){
/* 定义文档和节点指针 */
xmlDocPtr doc;
xmlNodePtr cur;
/* 进行解析，如果没成功，显示一个错误并停止 */
doc = xmlParseFile(docname);
if(doc == NULL){
fprintf(stderr, "Document not parse successfully. \n");
return;
}
/* 获取文档根节点，若无内容则释放文档树并返回 */
cur = xmlDocGetRootElement(doc);
if(cur == NULL){
fprintf(stderr, "empty document\n");
xmlFreeDoc(doc);
return;
}
/* 确定根节点名是否为story，不是则返回 */
if(xmlStrcmp(cur->name, (const xmlChar *)"story")){
fprintf(stderr, "document of the wrong type, root node != story");
xmlFreeDoc(doc);
return;
}
/* 遍历文档树 */
cur = cur->xmlChildrenNode;
while(cur != NULL){
/* 找到storyinfo子节点 */
if(!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo")){
parseStory(doc, cur); /* 解析storyinfo子节点 */
}
cur = cur->next; /* 下一个子节点 */
}
xmlFreeDoc(doc); /* 释放文档树 */
return;
}
int main(int argc, char **argv){
char *docname;
if(argc <= 1){
printf("Usage: %s docname\n", argv[0]);
return 0;
}
docname=argv[1];
parseDoc(docname);
return 1;
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

/* 解析storyinfo节点，打印keyword节点的内容 */
void parseStory(xmlDocPtr doc, xmlNodePtr cur){
	xmlChar* key;
	cur=cur->xmlChildrenNode;
	while(cur != NULL){
		/* 找到keyword子节点 */
		if(!xmlStrcmp(cur->name, (const xmlChar *)"keyword")){
			key = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
			printf("keyword: %s\n", key);
			xmlFree(key);
		}
		cur=cur->next; /* 下一个子节点 */
	}

	return;
}

/* 解析文档 */
static void parseDoc(char *docname){
	/* 定义文档和节点指针 */
	xmlDocPtr doc;
	xmlNodePtr cur;
	
	/* 进行解析，如果没成功，显示一个错误并停止 */
	doc = xmlParseFile(docname);
	if(doc == NULL){
		fprintf(stderr, "Document not parse successfully. \n");
		return;
	}

	/* 获取文档根节点，若无内容则释放文档树并返回 */
	cur = xmlDocGetRootElement(doc);
	if(cur == NULL){
		fprintf(stderr, "empty document\n");
		xmlFreeDoc(doc);
		return;
	}

	/* 确定根节点名是否为story，不是则返回 */
	if(xmlStrcmp(cur->name, (const xmlChar *)"story")){
		fprintf(stderr, "document of the wrong type, root node != story");
		xmlFreeDoc(doc);
		return;
	}

	/* 遍历文档树 */
	cur = cur->xmlChildrenNode;
	while(cur != NULL){
		/* 找到storyinfo子节点 */
		if(!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo")){
			parseStory(doc, cur); /* 解析storyinfo子节点 */
		}
		cur = cur->next; /* 下一个子节点 */
	}

	xmlFreeDoc(doc); /* 释放文档树 */
	return;
}

int main(int argc, char **argv){
	char *docname;
	if(argc <= 1){
		printf("Usage: %s docname\n", argv[0]);
		return 0;
	}
	docname=argv[1];
	parseDoc(docname);
	return 1;
}

    解析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 print ?

#include <libxml/parser.h>
#include <libxml/xpath.h>
/* 解析文档 */
xmlDocPtr getdoc(char *docname){
xmlDocPtr doc;
doc = xmlParseFile(docname);
if(doc == NULL){
fprintf(stderr, "Document not parsed successfully. \n");
return NULL;
}
return doc;
}
/* 查询节点集 */
xmlXPathObjectPtr getnodeset(xmlDocPtr doc, xmlChar *xpath){
xmlXPathContextPtr context;
xmlXPathObjectPtr result; /* 存储查询结果 */
/* 创建一个xpath上下文 */
context = xmlXPathNewContext(doc);
if(context == NULL){
printf("Error in xmlXPathNewContext\n");
return NULL;
}
/* 查询XPath表达式 */
result = xmlXPathEvalExpression(xpath, context);
xmlXPathFreeContext(context); /* 释放上下文指针 */
if(result == NULL){
printf("Error in xmlXPathEvalExpression\n");
return NULL;
}
/* 检查结果集是否为空 */
if(xmlXPathNodeSetIsEmpty(result->nodesetval)){
xmlXPathFreeObject(result); /* 如为这空就释放 */
printf("No result\n");
return NULL;
}
return result;
}
int main(int argc, char ** argv){
char *docname;
xmlDocPtr doc;
/* 查找所有keyword元素，而不管它们在文档中的位置 */
xmlChar *xpath=(xmlChar*)"//keyword";
xmlNodeSetPtr nodeset;
xmlXPathObjectPtr result;
int i;
xmlChar *keyword;
if(argc <= 1){
printf("Usage: %s docname\n", argv[0]);
return(0);
}
docname = argv[1];
doc = getdoc(docname);
result = getnodeset(doc, xpath);
if(result){
/* 得到keyword节点集 */
nodeset = result->nodesetval;
for(i=0; i < nodeset->nodeNr; i++){ /* 打印每个节点中的内容 */
keyword = xmlNodeListGetString(doc, nodeset->nodeTab[i]->xmlChildrenNode, 1);
printf("keyword: %s\n", keyword);
xmlFree(keyword);
}
xmlXPathFreeObject(result); /* 释放结果集 */
}
xmlFreeDoc(doc); /* 释放文档树 */
xmlCleanupParser(); /* 清除库内存 */
return(1);
}

#include <libxml/parser.h>
#include <libxml/xpath.h>

/* 解析文档 */
xmlDocPtr getdoc(char *docname){
	xmlDocPtr doc;
	doc = xmlParseFile(docname);
	if(doc == NULL){
		fprintf(stderr, "Document not parsed successfully. \n");
		return NULL;
	}

	return doc;
}

/* 查询节点集 */
xmlXPathObjectPtr getnodeset(xmlDocPtr doc, xmlChar *xpath){
	xmlXPathContextPtr context;
	xmlXPathObjectPtr result; /* 存储查询结果 */

	/* 创建一个xpath上下文 */
	context = xmlXPathNewContext(doc);
	if(context == NULL){
		printf("Error in xmlXPathNewContext\n");
		return NULL;
	}
	/* 查询XPath表达式 */
	result = xmlXPathEvalExpression(xpath, context);
	xmlXPathFreeContext(context); /* 释放上下文指针 */
	if(result == NULL){
		printf("Error in xmlXPathEvalExpression\n");
		return NULL;
	}
	/* 检查结果集是否为空 */
	if(xmlXPathNodeSetIsEmpty(result->nodesetval)){
		xmlXPathFreeObject(result); /* 如为这空就释放 */
		printf("No result\n");
		return NULL;
	}
	return result;
}

int main(int argc, char ** argv){
	char *docname;
	xmlDocPtr doc;
	/* 查找所有keyword元素，而不管它们在文档中的位置 */
	xmlChar *xpath=(xmlChar*)"//keyword";
	xmlNodeSetPtr nodeset;
	xmlXPathObjectPtr result;
	int i;
	xmlChar *keyword;

	if(argc <= 1){
		printf("Usage: %s docname\n", argv[0]);
		return(0);
	}

	docname = argv[1];
	doc = getdoc(docname);
	result = getnodeset(doc, xpath);
	if(result){
		/* 得到keyword节点集 */
		nodeset = result->nodesetval;
		for(i=0; i < nodeset->nodeNr; i++){ /* 打印每个节点中的内容 */
			keyword = xmlNodeListGetString(doc, nodeset->nodeTab[i]->xmlChildrenNode, 1);
			printf("keyword: %s\n", keyword);
			xmlFree(keyword);
		}
		xmlXPathFreeObject(result); /* 释放结果集 */
	}

	xmlFreeDoc(doc); /* 释放文档树 */
	xmlCleanupParser(); /* 清除库内存 */
	return(1);
}

    可以在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 print ?

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>
void
parseStory(xmlDocPtr doc, xmlNodePtr cur, const xmlChar* keyword) {
/* 在当前节点下插入一个keyword子节点 */
xmlNewTextChild(cur, NULL, (const xmlChar*)"keyword", keyword);
return;
}
xmlDocPtr
parseDoc(char *docname, char *keyword) {
xmlDocPtr doc;
xmlNodePtr cur;
doc = xmlParseFile(docname);
if (doc == NULL ) {
fprintf(stderr,"Document not parsed successfully. \n");
return (NULL);
}
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
fprintf(stderr,"empty document\n");
xmlFreeDoc(doc);
return (NULL);
}
if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {
fprintf(stderr,"document of the wrong type, root node != story");
xmlFreeDoc(doc);
return (NULL);
}
cur = cur->xmlChildrenNode;
while (cur != NULL) {
if ((!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo"))){
parseStory (doc, cur, (const xmlChar*)keyword);
}
cur = cur->next;
}
return(doc);
}
int
main(int argc, char **argv) {
char *docname;
char *keyword;
xmlDocPtr doc;
if (argc <= 2) {
printf("Usage: %s docname, keyword\n", argv[0]);
return(0);
}
docname = argv[1];
keyword = argv[2];
doc = parseDoc(docname, keyword);
if (doc != NULL) {
xmlSaveFormatFile(docname, doc, 0);
xmlFreeDoc(doc);
}
return (1);
}

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <libxml/xmlmemory.h>
#include <libxml/parser.h>

void
parseStory(xmlDocPtr doc, xmlNodePtr cur, const xmlChar* keyword) {
	/* 在当前节点下插入一个keyword子节点 */
	xmlNewTextChild(cur, NULL, (const xmlChar*)"keyword", keyword);
    return;
}

xmlDocPtr
parseDoc(char *docname, char *keyword) {

	xmlDocPtr doc;
	xmlNodePtr cur;

	doc = xmlParseFile(docname);
	
	if (doc == NULL ) {
		fprintf(stderr,"Document not parsed successfully. \n");
		return (NULL);
	}
	
	cur = xmlDocGetRootElement(doc);
	
	if (cur == NULL) {
		fprintf(stderr,"empty document\n");
		xmlFreeDoc(doc);
		return (NULL);
	}
	
	if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {
		fprintf(stderr,"document of the wrong type, root node != story");
		xmlFreeDoc(doc);
		return (NULL);
	}
	
	cur = cur->xmlChildrenNode;
	while (cur != NULL) {
		if ((!xmlStrcmp(cur->name, (const xmlChar *)"storyinfo"))){
			parseStory (doc, cur, (const xmlChar*)keyword);
		}
		 
	cur = cur->next;
	}
	return(doc);
}

int
main(int argc, char **argv) {

	char *docname;
	char *keyword;
	xmlDocPtr doc;

	if (argc <= 2) {
		printf("Usage: %s docname, keyword\n", argv[0]);
		return(0);
	}

	docname = argv[1];
	keyword = argv[2];
	doc = parseDoc(docname, keyword);
	if (doc != NULL) {
		xmlSaveFormatFile(docname, doc, 0);
		xmlFreeDoc(doc);
	}
	
	return (1);
}

这里xmlNewTextChild函数在当前节点指针上添加一个子元素。如果希望元素有名字空间，则可以在这里加上。添加完后，就要用xmlSaveFormatFile()把修改后的文档写入到文件。我们这里使用原来doc文档指针，因此会覆盖原来的文件。第三个参数如果设置为1，则输出的文档会自动缩进。
若要删除某个节点，可以使用以下代码：

[cpp] view plain copy print ?

if(!xmlStrcmp(cur->name, BAD_CAST "keyword")){
xmlNodePtr tempNode;
tempNode = cur->next;
xmlUnlinkNode(cur);
xmlFreeNode(cur);
cur = tempNode;
continue;
}

if(!xmlStrcmp(cur->name, BAD_CAST "keyword")){
	xmlNodePtr tempNode;
	tempNode = cur->next;
	xmlUnlinkNode(cur);
	xmlFreeNode(cur);
	cur = tempNode;
	continue;
}

注意libxml2并没有xmlDelNode或者xmlRemoveNode之类的函数。我们需要将当前节点从文档中断链（unlink），文档就不会再包含这个子节点。这样做需要使用一个临时变量来存储断链节点的后续节点，并记得要手动删除断链节点的内存。
若要给节点添加属性，可以这样：

[cpp] view plain copy print ?

xmlDocPtr
parseDoc(char *docname, char *uri) {
xmlDocPtr doc;
xmlNodePtr cur;
xmlNodePtr newnode;
xmlAttrPtr newattr;
doc = xmlParseFile(docname);
if (doc == NULL ) {
fprintf(stderr,"Document not parsed successfully. \n");
return (NULL);
}
cur = xmlDocGetRootElement(doc);
if (cur == NULL) {
fprintf(stderr,"empty document\n");
xmlFreeDoc(doc);
return (NULL);
}
if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {
fprintf(stderr,"document of the wrong type, root node != story");
xmlFreeDoc(doc);
return (NULL);
}
newnode = xmlNewTextChild(cur, NULL, "reference", NULL);
newattr = xmlNewProp(newnode, "uri", uri);
return(doc);
}

xmlDocPtr
parseDoc(char *docname, char *uri) {
	xmlDocPtr doc;
	xmlNodePtr cur;
	xmlNodePtr newnode;
	xmlAttrPtr newattr;

	doc = xmlParseFile(docname);	
	if (doc == NULL ) {
		fprintf(stderr,"Document not parsed successfully. \n");
		return (NULL);
	}
	
	cur = xmlDocGetRootElement(doc);	
	if (cur == NULL) {
		fprintf(stderr,"empty document\n");
		xmlFreeDoc(doc);
		return (NULL);
	}
	
	if (xmlStrcmp(cur->name, (const xmlChar *) "story")) {
		fprintf(stderr,"document of the wrong type, root node != story");
		xmlFreeDoc(doc);
		return (NULL);
	}
	
	newnode = xmlNewTextChild(cur, NULL, "reference", NULL);
	newattr = xmlNewProp(newnode, "uri", uri);
	return(doc);
}

我们用xmlAttrPtr声明一个属性指针。在找到story元素后，用xmlNewTextChild()新建一个reference子元素，用xmlNewProp()给这个子元素新建一个uri属性。文档修改完后要用xmlSaveFormatFile()写入到磁盘。
查询属性的过程类似。如下：

[cpp] view plain copy print ?

void
getReference(xmlDocPtr doc, xmlNodePtr cur) {
xmlChar *uri;
cur = cur->xmlChildrenNode;
while (cur != NULL) {
if ((!xmlStrcmp(cur->name, (const xmlChar *)"reference"))) {
uri = xmlGetProp(cur, "uri");
printf("uri: %s\n", uri);
xmlFree(uri);
}
cur = cur->next;
}
return;
}

void
getReference(xmlDocPtr doc, xmlNodePtr cur) {
	xmlChar *uri;
	cur = cur->xmlChildrenNode;
	while (cur != NULL) {
	    if ((!xmlStrcmp(cur->name, (const xmlChar *)"reference"))) {
		    uri = xmlGetProp(cur, "uri");
		    printf("uri: %s\n", uri);
		    xmlFree(uri);
	    }
	    cur = cur->next;
	}
	return;
}

    关键函数为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 print ?

#include <stdio.h>
#include <iostream>
#include <libxml/parser.h>
#include <libxml/tree.h>
using namespace std;
int main(int argc, char* argv[]){
//定义文档和节点指针
xmlDocPtr doc=xmlNewDoc(BAD_CAST"1.0");
xmlNodePtr root_node=xmlNewNode(NULL,BAD_CAST"root");
//设置根节点
xmlDocSetRootElement(doc,root_node);
//在根节点中直接创建节点
xmlNewTextChild(root_node, NULL, BAD_CAST"newNode1", BAD_CAST"newNode1 content");
xmlNewTextChild(root_node, NULL, BAD_CAST"newNode2", BAD_CAST"newNode2 content");
xmlNewTextChild(root_node, NULL, BAD_CAST"newNode3", BAD_CAST"newNode3 content");
//创建一个节点，设置其内容和属性，然后加入根结点
xmlNodePtr node=xmlNewNode(NULL, BAD_CAST"node2");
xmlNodePtr content=xmlNewText(BAD_CAST"NODE CONTENT");
xmlAddChild(root_node,node);
xmlAddChild(node,content);
xmlNewProp(node,BAD_CAST"attribute",BAD_CAST"yes");
//创建一个儿子和孙子节点
node=xmlNewNode(NULL,BAD_CAST"son");
xmlAddChild(root_node,node);
xmlNodePtr grandson=xmlNewNode(NULL,BAD_CAST"grandson");
xmlAddChild(node,grandson);
xmlAddChild(grandson,xmlNewText(BAD_CAST"This is a grandson node"));
//存储xml文档
int nRel=xmlSaveFile("CreatedXml.xml",doc);
if(nRel!=-1){
cout<<"一个xml文档被创建，写入"<<nRel<<"个字节"<<endl;
}
//释放文档内节点动态申请的内存
xmlFreeDoc(doc);
return 1;
}

#include <stdio.h>
#include <iostream>
#include <libxml/parser.h>
#include <libxml/tree.h>
using namespace std;

int main(int argc, char* argv[]){
	//定义文档和节点指针
	xmlDocPtr doc=xmlNewDoc(BAD_CAST"1.0");
	xmlNodePtr root_node=xmlNewNode(NULL,BAD_CAST"root");
	//设置根节点
	xmlDocSetRootElement(doc,root_node);
	//在根节点中直接创建节点
	xmlNewTextChild(root_node, NULL, BAD_CAST"newNode1", BAD_CAST"newNode1 content");
	xmlNewTextChild(root_node, NULL, BAD_CAST"newNode2", BAD_CAST"newNode2 content");
	xmlNewTextChild(root_node, NULL, BAD_CAST"newNode3", BAD_CAST"newNode3 content");
	//创建一个节点，设置其内容和属性，然后加入根结点
	xmlNodePtr node=xmlNewNode(NULL, BAD_CAST"node2");
	xmlNodePtr content=xmlNewText(BAD_CAST"NODE CONTENT");
	xmlAddChild(root_node,node);
	xmlAddChild(node,content);
	xmlNewProp(node,BAD_CAST"attribute",BAD_CAST"yes");
	//创建一个儿子和孙子节点
	node=xmlNewNode(NULL,BAD_CAST"son");
	xmlAddChild(root_node,node);
	xmlNodePtr grandson=xmlNewNode(NULL,BAD_CAST"grandson");
	xmlAddChild(node,grandson);
	xmlAddChild(grandson,xmlNewText(BAD_CAST"This is a grandson node"));
	//存储xml文档
	int nRel=xmlSaveFile("CreatedXml.xml",doc);
	if(nRel!=-1){
		cout<<"一个xml文档被创建，写入"<<nRel<<"个字节"<<endl;
	}
	//释放文档内节点动态申请的内存
	xmlFreeDoc(doc);
	return 1;
}

编译并运行这个程序，将创建CreatedXml.xml文档，内容如下：

[html] view plain copy print ?

<root>
<newNode1>newNode1 content</newNode1>
<newNode2>newNode2 content</newNode2>
<newNode3>newNode3 content</newNode3>
<node2 attribute="yes">NODE CONTENT</node2>
<son>
<grandson>This is a grandson node</grandson>
</son>
</root>

<root>
	<newNode1>newNode1 content</newNode1>
	<newNode2>newNode2 content</newNode2>
	<newNode3>newNode3 content</newNode3>
	<node2 attribute="yes">NODE CONTENT</node2>
	<son>
		<grandson>This is a grandson node</grandson>
	</son>
</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 print ?

#include <string.h>
#include <libxml/parser.h>
/* 对指定编码格式的外部数据，转换成libxml使用UTF-8格式 */
unsigned char*
convert(unsigned char *in, char *encoding){
unsigned char *out;
int ret,size,out_size,temp;
/* 定义一个编码处理器指针 */
xmlCharEncodingHandlerPtr handler;
size = (int)strlen((const char*)in)+1; /* 输入数据长度 */
out_size = size*2-1; /* 输出数据长度 */
out = (unsigned char*)malloc((size_t)out_size); /* 存放输出数据 */
if (out) {
/* 查找内建的编码处理器 */
handler = xmlFindCharEncodingHandler(encoding);
if(!handler) {
free(out);
out = NULL;
}
}
if(out) {
temp=size-1;
/* 对输入数据进行编码转换 */
ret = handler->input(out, &out_size, in, &temp);
if(ret || temp-size+1) { /* 转换不成功 */
if (ret) { /* 转换失败 */
printf("conversion wasn't successful.\n");
} else { /* 只转换了一部分数据 */
printf("conversion wasn't successful. converted: %i octets.\n",temp);
}
free(out);
out = NULL;
}else { /* 转换成功 */
out = (unsigned char*)realloc(out,out_size+1);
out[out_size]=0; /* 输出的末尾加上null终止符 */
}
} else {
printf("no mem\n");
}
return (out);
}
int
main(int argc, char **argv) {
unsigned char *content, *out;
xmlDocPtr doc;
xmlNodePtr rootnode;
char *encoding = "ISO-8859-1";
if (argc <= 1) {
printf("Usage: %s content\n", argv[0]);
return(0);
}
content = (unsigned char*)argv[1];
/* 转换成libxml2使用的UTF-8格式 */
out = convert(content, encoding);
doc = xmlNewDoc (BAD_CAST "1.0");
rootnode = xmlNewDocNode(doc, NULL, (const xmlChar*)"root", out);
xmlDocSetRootElement(doc, rootnode);
/* 以ISO-8859-1格式输出文档内容 */
xmlSaveFormatFileEnc("-", doc, encoding, 1);
return (1);
}

#include <string.h>
#include <libxml/parser.h>

/* 对指定编码格式的外部数据，转换成libxml使用UTF-8格式 */
unsigned char*
convert(unsigned char *in, char *encoding){
	unsigned char *out;
    int ret,size,out_size,temp;
	/* 定义一个编码处理器指针 */
    xmlCharEncodingHandlerPtr handler;

    size = (int)strlen((const char*)in)+1; /* 输入数据长度 */
    out_size = size*2-1; /* 输出数据长度 */
    out = (unsigned char*)malloc((size_t)out_size); /* 存放输出数据 */

    if (out) {
		/* 查找内建的编码处理器 */
        handler = xmlFindCharEncodingHandler(encoding);
        if(!handler) {
            free(out);
            out = NULL;
        }
    }
    if(out) {
        temp=size-1;
		/* 对输入数据进行编码转换 */
        ret = handler->input(out, &out_size, in, &temp);
        if(ret || temp-size+1) { /* 转换不成功 */
            if (ret) { /* 转换失败 */
                printf("conversion wasn't successful.\n");
            } else { /* 只转换了一部分数据 */
                printf("conversion wasn't successful. converted: %i octets.\n",temp);
            }
            free(out);
            out = NULL;
        }else { /* 转换成功 */
            out = (unsigned char*)realloc(out,out_size+1);
            out[out_size]=0; /* 输出的末尾加上null终止符 */
                        
        }
    } else {
        printf("no mem\n");
    }
    return (out);
}	

int
main(int argc, char **argv) {
	unsigned char *content, *out;
	xmlDocPtr doc;
	xmlNodePtr rootnode;
	char *encoding = "ISO-8859-1";
	
	if (argc <= 1) {
		printf("Usage: %s content\n", argv[0]);
		return(0);
	}

	content = (unsigned char*)argv[1];
	/* 转换成libxml2使用的UTF-8格式 */
	out = convert(content, encoding);
	doc = xmlNewDoc (BAD_CAST "1.0");
	rootnode = xmlNewDocNode(doc, NULL, (const xmlChar*)"root", out);
	xmlDocSetRootElement(doc, rootnode);
	/* 以ISO-8859-1格式输出文档内容 */
	xmlSaveFormatFileEnc("-", doc, encoding, 1);
	return (1);
}

编译运行这个程序，假设在命令行上提供的数据"zhou"是ISO-8859-1格式（我的系统中不是），则输出文档为：

[html] view plain copy print ?

<?xml version="1.0" encoding="ISO-8859-1"?>
<root>zhou</root>

<?xml version="1.0" encoding="ISO-8859-1"?>
<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 print ?

#include <string.h>
#include <iconv.h>
#include <libxml/encoding.h>
#include <libxml/xmlwriter.h>
#include <libxml/xmlreader.h>
/* 输入编码处理器：GBK到UTF-8 */
int gbk_input(unsigned char *out, int *outlen,
const unsigned char *in, int *inlen){
char *outbuf = (char *) out;
char *inbuf = (char *) in;
iconv_t iconv_from; /* gbk到utf-8的转换描述符 */
size_t len1, len2, rslt;
/* 注意一般不直接从int*到size_t*的转换
这在32位平台下是正常的，但到了64平台下size_t为64位，
那(size_t*)inlen将是一个未知的数据
*/
len1 = *inlen;
len2 = *outlen;
/* 分配一个从GBK到UTF-8的转换描述符 */
iconv_from = iconv_open("utf-8","gbk");
/* 根据转换描述符，对数据进行编码转换 */
rslt = iconv(iconv_from, &inbuf, &len1, &outbuf, &len2);
if(rslt < 0){
return rslt;
}
iconv_close(iconv_from); /* 释放描述符 */
*outlen = ((unsigned char *) outbuf - out);
*inlen = ((unsigned char *) inbuf - in);
return *outlen;
}
/* 输出编码处理器：UTF-8到GBK */
int gbk_output(unsigned char *out, int *outlen,
const unsigned char *in, int *inlen){
char *outbuf = (char *) out;
char *inbuf = (char *) in;
iconv_t iconv_to; /* utf-8到gbk的转换描述符 */
size_t len1, len2, rslt;
/* 注意一般不直接从int*到size_t*的转换
这在32位平台下是正常的，但到了64平台下size_t为64位，
那(size_t*)inlen将是一个未知的数据
*/
len1 = *inlen;
len2 = *outlen;
/* 分配一个从UTF-8到GBK的转换描述符 */
iconv_to=iconv_open("gbk","utf-8");
/* 根据转换描述符，对数据进行编码转换 */
rslt = iconv(iconv_to, &inbuf, &len1, &outbuf, &len2);
if(rslt < 0){
return rslt;
}
iconv_close(iconv_to); /* 释放描述符 */
*outlen = ((unsigned char *) outbuf - out);
*inlen = ((unsigned char *) inbuf - in);
return *outlen;
}
/**
* convertToUTF8From:
* 把encoding编码的输入数据in转换成utf-8格式返回
* 出错则返回NULL
*/
xmlChar *convertToUTF8From(const char *in, const char *encoding){
xmlChar *out;
int ret;
int size;
int out_size;
int temp;
xmlCharEncodingHandlerPtr handler;
if (in == 0)
return 0;
/* 查找内建的编码处理器 */
handler = xmlFindCharEncodingHandler(encoding);
if (!handler) {
printf("convertToUTF8From: no encoding handler found for '%s'\n",
encoding ? encoding : "");
return 0;
}
size = (int)strlen(in) + 1; /* 输入数据长度 */
out_size = size*2 - 1; /* 输出数据长度 */
/* 存放输出数据 */
out = (unsigned char *) xmlMalloc((size_t) out_size);
memset(out, 0, out_size);
if(out != NULL) {
temp = size - 1;
/* 对输入数据进行编码转换，成功后返回0 */
ret = handler->input(out, &out_size, (const xmlChar *) in, &temp);
if(ret || temp - size + 1) { /* 转换不成功 */
if(ret){ /* 转换失败 */
printf("convertToUTF8From: conversion wasn't successful.\n");
}else{ /* 只转换了一部分数据 */
printf("convertToUTF8From: conversion wasn't successful. converted: %i octets.\n", temp);
}
xmlFree(out); /* 释放输出缓冲区 */
out = 0;
}else{ /* 转换成功，在输出末尾加上null终止符 */
out = (unsigned char *) xmlRealloc(out, out_size + 1);
out[out_size] = 0;
}
} else {
printf("convertToUTF8From: no mem\n");
}
return out;
}
/**
* utf8ConvertTo:
* 把utf-8的数据转换成encoding编码返回
* 出错则返回NULL
*/
char *utf8ConvertTo(xmlChar *in, const char *encoding){
char *out;
int ret;
int size;
int out_size;
int temp;
xmlCharEncodingHandlerPtr handler;
if (in == 0)
return 0;
handler = xmlFindCharEncodingHandler(encoding);
if (!handler) {
printf("utf8ConvertTo: no encoding handler found for '%s'\n",
encoding ? encoding : "");
return 0;
}
size = (int) strlen((char*)in) + 1; /* 输入数据长度 */
out_size = size * 2 - 1; /* 输出数据长度 */
out = (char *) malloc((size_t) out_size); /* 存放输出数据 */
memset(out,0,out_size);
if(out != NULL) {
temp = size - 1;
/* 对输入数据进行编码转换，成功后返回0 */
ret = handler->output((xmlChar*)out, &out_size, (const xmlChar *) in, &temp);
if(ret || temp - size + 1){
if(ret){
printf("utf8ConvertTo: conversion wasn't successful.\n");
}else{
printf("utf8ConvertTo: conversion wasn't successful. converted: %i octets.\n", temp);
}
free(out);
out = 0;
}else{
out = (char *) realloc(out, out_size + 1);
out[out_size] = 0; /* 末尾加上null终止符 */
}
}else{
printf("utf8ConvertTo: no mem\n");
}
return out;
}
int main(int argc, char **argv){
const char *content;
xmlChar *out;
xmlDocPtr doc;
xmlNodePtr rootnode;
if (argc <= 1) {
printf("Usage: %s content\n", argv[0]);
return(0);
}
content = (const char*)argv[1];
/* 添加gbk编码支持 */
xmlNewCharEncodingHandler("gbk", gbk_input, gbk_output);
/* 添加gb2312编码支持：仍然可以使用GBK的输入输出处理器 */
xmlNewCharEncodingHandler("gb2312", gbk_input, gbk_output);
/* 输入的GBK数据转换成libxml2使用的UTF-8格式 */
out = convertToUTF8From(content, "gbk");
/* 创建xml文档 */
doc = xmlNewDoc(BAD_CAST "1.0");
rootnode = xmlNewDocNode(doc, NULL, (const xmlChar*)"root", out);
xmlDocSetRootElement(doc, rootnode);
/* 以gb2312格式保存文档内容："-"表示输出到终端 */
xmlSaveFormatFileEnc("-", doc, "gb2312", 1);
xmlCleanupCharEncodingHandlers()；/* 释放编码处理器资源 */
return (1);
}

#include <string.h>
#include <iconv.h>
#include <libxml/encoding.h>
#include <libxml/xmlwriter.h>
#include <libxml/xmlreader.h>

/* 输入编码处理器：GBK到UTF-8 */
int gbk_input(unsigned char *out, int *outlen, 
		const unsigned char *in, int *inlen){

	char *outbuf = (char *) out;
	char *inbuf = (char *) in;
	iconv_t iconv_from; /* gbk到utf-8的转换描述符 */
	size_t len1, len2, rslt;
	/* 注意一般不直接从int*到size_t*的转换
	   这在32位平台下是正常的，但到了64平台下size_t为64位，
	   那(size_t*)inlen将是一个未知的数据 
	*/
	len1 = *inlen;
	len2 = *outlen;
	/* 分配一个从GBK到UTF-8的转换描述符 */
	iconv_from = iconv_open("utf-8","gbk");
	/* 根据转换描述符，对数据进行编码转换 */
	rslt = iconv(iconv_from, &inbuf, &len1, &outbuf, &len2);
	if(rslt < 0){
		return rslt;
	}
	iconv_close(iconv_from); /* 释放描述符 */
	*outlen = ((unsigned char *) outbuf - out);
	*inlen = ((unsigned char *) inbuf - in);
	return *outlen;
}

/* 输出编码处理器：UTF-8到GBK */
int gbk_output(unsigned char *out, int *outlen, 
				const unsigned char *in, int *inlen){

	char *outbuf = (char *) out;
	char *inbuf = (char *) in;
	iconv_t iconv_to; /* utf-8到gbk的转换描述符 */
	size_t len1, len2, rslt;
	/* 注意一般不直接从int*到size_t*的转换
	   这在32位平台下是正常的，但到了64平台下size_t为64位，
	   那(size_t*)inlen将是一个未知的数据 
	*/
	len1 = *inlen;
	len2 = *outlen;
	/* 分配一个从UTF-8到GBK的转换描述符 */
	iconv_to=iconv_open("gbk","utf-8");
	/* 根据转换描述符，对数据进行编码转换 */
	rslt = iconv(iconv_to, &inbuf, &len1, &outbuf, &len2);
	if(rslt < 0){
		return rslt;
	}
	iconv_close(iconv_to); /* 释放描述符 */
	*outlen = ((unsigned char *) outbuf - out);
	*inlen = ((unsigned char *) inbuf - in);
	return *outlen;
}

/**
 * convertToUTF8From:
 * 把encoding编码的输入数据in转换成utf-8格式返回
 * 出错则返回NULL
 */
xmlChar *convertToUTF8From(const char *in, const char *encoding){
    xmlChar *out;
    int ret;
    int size;
    int out_size;
    int temp;
    xmlCharEncodingHandlerPtr handler;
    if (in == 0)
		return 0;
	/* 查找内建的编码处理器 */
    handler = xmlFindCharEncodingHandler(encoding);
    if (!handler) {
        printf("convertToUTF8From: no encoding handler found for '%s'\n",
               encoding ? encoding : "");
        return 0;
    }
    size = (int)strlen(in) + 1;  /* 输入数据长度 */
    out_size = size*2 - 1;  /* 输出数据长度 */
	/* 存放输出数据 */
    out = (unsigned char *) xmlMalloc((size_t) out_size);
	memset(out, 0, out_size);

    if(out != NULL) {
        temp = size - 1;
		/* 对输入数据进行编码转换，成功后返回0 */
        ret = handler->input(out, &out_size, (const xmlChar *) in, &temp);
        if(ret || temp - size + 1) {  /* 转换不成功 */
            if(ret){  /* 转换失败 */
                printf("convertToUTF8From: conversion wasn't successful.\n");
            }else{  /* 只转换了一部分数据 */
                printf("convertToUTF8From: conversion wasn't successful. converted: %i octets.\n", temp);
            }
            xmlFree(out); /* 释放输出缓冲区 */
            out = 0;
        }else{  /* 转换成功，在输出末尾加上null终止符 */
            out = (unsigned char *) xmlRealloc(out, out_size + 1);
            out[out_size] = 0;
        }
    } else {
        printf("convertToUTF8From: no mem\n");
    }
    return out;
}

/**
 * utf8ConvertTo:
 * 把utf-8的数据转换成encoding编码返回
 * 出错则返回NULL
 */
char *utf8ConvertTo(xmlChar *in, const char *encoding){
    char *out;
    int ret;
    int size;
    int out_size;
    int temp;
    xmlCharEncodingHandlerPtr handler;

    if (in == 0)
        return 0;

    handler = xmlFindCharEncodingHandler(encoding);

    if (!handler) {
        printf("utf8ConvertTo: no encoding handler found for '%s'\n",
               encoding ? encoding : "");
        return 0;
    }

    size = (int) strlen((char*)in) + 1;  /* 输入数据长度 */
    out_size = size * 2 - 1;  /* 输出数据长度 */
    out = (char *) malloc((size_t) out_size);  /* 存放输出数据 */
	memset(out,0,out_size);
    if(out != NULL) {
        temp = size - 1;
		/* 对输入数据进行编码转换，成功后返回0 */
        ret = handler->output((xmlChar*)out, &out_size, (const xmlChar *) in, &temp);
        if(ret || temp - size + 1){
            if(ret){
                printf("utf8ConvertTo: conversion wasn't successful.\n");
            }else{
                printf("utf8ConvertTo: conversion wasn't successful. converted: %i octets.\n", temp);
            }
            free(out);
            out = 0;
        }else{
            out = (char *) realloc(out, out_size + 1);
            out[out_size] = 0;  /* 末尾加上null终止符 */
        }
    }else{
        printf("utf8ConvertTo: no mem\n");
    }

    return out;
}

int main(int argc, char **argv){
	const char *content;
	xmlChar *out;
	xmlDocPtr doc;
	xmlNodePtr rootnode;
	
	if (argc <= 1) {
		printf("Usage: %s content\n", argv[0]);
		return(0);
	}
	content = (const char*)argv[1];

	/* 添加gbk编码支持 */
	xmlNewCharEncodingHandler("gbk", gbk_input, gbk_output);
	/* 添加gb2312编码支持：仍然可以使用GBK的输入输出处理器 */
	xmlNewCharEncodingHandler("gb2312", gbk_input, gbk_output);

	/* 输入的GBK数据转换成libxml2使用的UTF-8格式 */
	out = convertToUTF8From(content, "gbk");
	/* 创建xml文档 */
	doc = xmlNewDoc(BAD_CAST "1.0");
	rootnode = xmlNewDocNode(doc, NULL, (const xmlChar*)"root", out);
	xmlDocSetRootElement(doc, rootnode);
	/* 以gb2312格式保存文档内容："-"表示输出到终端 */
	xmlSaveFormatFileEnc("-", doc, "gb2312", 1);
	
	xmlCleanupCharEncodingHandlers()；/* 释放编码处理器资源 */
	return (1);
}

    这个例子在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 print ?

#include <stdio.h>
#include <string.h>
#include <iconv.h>
#include <libxml/parser.h>
#include <libxml/tree.h>
/* 代码转换:从一种编码转为另一种编码 */
int encoding_convert(const char *from_charset, const char *to_charset,
char *inbuf, int inlen,
char* outbuf, int outlen){
iconv_t cd;
size_t len1, len2, rslt;
/* 注意一般不直接从int*到size_t*的转换
这在32位平台下是正常的，但到了64平台下size_t为64位，
那(size_t*)inlen将是一个未知的数据
*/
len1 = inlen;
len2 = outlen;
/* 分配一个转换描述符 */
cd = iconv_open(to_charset,from_charset);
if(cd == 0)
return -1;
memset(outbuf,0,len2);
/* 执行编码转换 */
rslt=iconv(cd, &inbuf, &len1, &outbuf, &len2);
if(rslt== -1)
return -1;
iconv_close(cd); /* 释放描述符 */
return 0;
}
/* GB2312转换为UTF-8
* 成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL
*/
char *gb2312_utf8(char *inbuf){
int nOutLen = 2*strlen(inbuf)-1;
char *szOut=(char*)xmlMalloc(nOutLen);
if(-1 == encoding_convert("gb2312","uft-8",inbuf,strlen(inbuf),szOut,nOutLen)){
xmlFree(szOut);
szOut=NULL;
}
return szOut;
}
/* UTF-8转换为GB2312
* 成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL
*/
char *utf8_gb2312(char *inbuf){
int nOutLen = 2* strlen(inbuf)-1;
char *szOut=(char*)xmlMalloc(nOutLen);
if(-1 == encoding_convert("utf-8","gb2312",inbuf,strlen(inbuf),szOut,nOutLen)){
xmlFree(szOut);
szOut=NULL;
}
return szOut;
}
int main(int argc, char **argv){
/* 定义文档节点和指针 */
xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
xmlNodePtr root_node=xmlNewNode(NULL, BAD_CAST "root");
/* 设置根节点 */
xmlDocSetRootElement(doc, root_node);
/* 一个中文字符串转换为UTF-8字符串，然后写入 */
char *szOut=gb2312_utf8("节点1的内容");
/* 在根节点中直接创建节点 */
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode1", BAD_CAST "newNode1 content");
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode2", BAD_CAST "newNode2 content");
xmlNewTextChild(root_node, NULL, BAD_CAST "newNode3", BAD_CAST "newNode3 content");
xmlNewChild(root_node, NULL, BAD_CAST "node1",BAD_CAST szOut);
xmlFree(szOut);
/* 创建一个节点，设置其内容和属性，然后加入根结点 */
xmlNodePtr node = xmlNewNode(NULL,BAD_CAST "node2");
xmlNodePtr content = xmlNewText(BAD_CAST "NODE CONTENT");
xmlAddChild(root_node,node);
xmlAddChild(node,content);
szOut = gb2312_utf8("属性值");
xmlNewProp(node,BAD_CAST "attribute",BAD_CAST szOut);
xmlFree(szOut);
/* 创建一个中文节点 */
szOut = gb2312_utf8("中文节点");
xmlNewChild(root_node, NULL, BAD_CAST szOut,BAD_CAST "content of chinese node");
xmlFree(szOut);
/* 存储xml文档 */
int nRel = xmlSaveFormatFileEnc("CreatedXml_cn.xml",doc,"GB2312",1);
if (nRel != -1){
printf("一个xml文档被创建,写入%d个字节", nRel);
}
xmlFreeDoc(doc);
return 1;
}

#include <stdio.h>
#include <string.h>
#include <iconv.h>
#include <libxml/parser.h>
#include <libxml/tree.h>

/* 代码转换:从一种编码转为另一种编码 */
int encoding_convert(const char *from_charset, const char *to_charset, 
			char *inbuf, int inlen, 
			char* outbuf, int outlen){

    iconv_t cd;
	size_t len1, len2, rslt;

	/* 注意一般不直接从int*到size_t*的转换
	   这在32位平台下是正常的，但到了64平台下size_t为64位，
	   那(size_t*)inlen将是一个未知的数据 
	*/
	len1 = inlen;
	len2 = outlen;
	/* 分配一个转换描述符 */
    cd = iconv_open(to_charset,from_charset);
    if(cd == 0)
       return -1;
    memset(outbuf,0,len2); 
	/* 执行编码转换 */
    rslt=iconv(cd, &inbuf, &len1, &outbuf, &len2);
    if(rslt== -1)
		return -1;  

    iconv_close(cd); /* 释放描述符 */
    return 0;  

}

/* GB2312转换为UTF-8 
 * 成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL
 */
char *gb2312_utf8(char *inbuf){
	int nOutLen = 2*strlen(inbuf)-1;
	char *szOut=(char*)xmlMalloc(nOutLen);
	if(-1 == encoding_convert("gb2312","uft-8",inbuf,strlen(inbuf),szOut,nOutLen)){
		xmlFree(szOut);
		szOut=NULL;
	}
	return szOut;
}

/* UTF-8转换为GB2312
 * 成功则返回一个动态分配的char*变量，需要在使用完毕后手动free，失败返回NULL
 */
char *utf8_gb2312(char *inbuf){
	int nOutLen = 2* strlen(inbuf)-1;
	char *szOut=(char*)xmlMalloc(nOutLen);
	if(-1 == encoding_convert("utf-8","gb2312",inbuf,strlen(inbuf),szOut,nOutLen)){
		xmlFree(szOut);
		szOut=NULL;
	}
	return szOut;
}

int main(int argc, char **argv){
	/* 定义文档节点和指针 */
	xmlDocPtr doc = xmlNewDoc(BAD_CAST "1.0");
	xmlNodePtr root_node=xmlNewNode(NULL, BAD_CAST "root");
	/* 设置根节点 */
	xmlDocSetRootElement(doc, root_node);

	/* 一个中文字符串转换为UTF-8字符串，然后写入 */
	char *szOut=gb2312_utf8("节点1的内容");
	/* 在根节点中直接创建节点 */
	xmlNewTextChild(root_node, NULL, BAD_CAST "newNode1", BAD_CAST "newNode1 content");
	xmlNewTextChild(root_node, NULL, BAD_CAST "newNode2", BAD_CAST "newNode2 content");
    xmlNewTextChild(root_node, NULL, BAD_CAST "newNode3", BAD_CAST "newNode3 content");
	xmlNewChild(root_node, NULL, BAD_CAST "node1",BAD_CAST szOut);
	xmlFree(szOut);

	/* 创建一个节点，设置其内容和属性，然后加入根结点 */
    xmlNodePtr node = xmlNewNode(NULL,BAD_CAST "node2");
    xmlNodePtr content = xmlNewText(BAD_CAST "NODE CONTENT");
    xmlAddChild(root_node,node);
    xmlAddChild(node,content);
    szOut = gb2312_utf8("属性值");
    xmlNewProp(node,BAD_CAST "attribute",BAD_CAST szOut);
    xmlFree(szOut);

	/* 创建一个中文节点 */
    szOut = gb2312_utf8("中文节点");
    xmlNewChild(root_node, NULL, BAD_CAST szOut,BAD_CAST "content of chinese node");
    xmlFree(szOut);

    /* 存储xml文档 */
    int nRel = xmlSaveFormatFileEnc("CreatedXml_cn.xml",doc,"GB2312",1);
    if (nRel != -1){
		printf("一个xml文档被创建,写入%d个字节", nRel);
    }

    xmlFreeDoc(doc);
    return 1;
}

这个例子中，当把中文数据写入到XML节点时，使用gb2312_utf8()直接转换成UTF-8格式，这种直接通过iconv转换的方式更高效。编译并运行程序，输出文档如下：

[html] view plain copy print ?

<?xml version="1.0" encoding="GB2312"?>
<root>
<newNode1>newNode1 content</newNode1>
<newNode2>newNode2 content</newNode2>
<newNode3>newNode3 content</newNode3>
<node1>节点1的内容</node1>
<node2 attribute="属性值">NODE CONTENT</node2>
<中文节点>content of chinese node</中文节点>
</root>

<?xml version="1.0" encoding="GB2312"?>
<root>
	<newNode1>newNode1 content</newNode1>
	<newNode2>newNode2 content</newNode2>
	<newNode3>newNode3 content</newNode3>
	<node1>节点1的内容</node1>
	<node2 attribute="属性值">NODE CONTENT</node2>
	<中文节点>content of chinese node</中文节点>
</root>

    6、一个真实的例子
   内容整理自 http://xmlsoft.org/example.html。
   下面是一个真实的例子。应用程序数据的内容不使用DOM树，而是使用内部数据结构来保存。这是一个基于XML存储结构的数据库，它保存了与Gnome相关的任务。如下：

[html] view plain copy print ?

<?xml version="1.0"?>
<gjob:Helping xmlns:gjob="http://www.gnome.org/some-location">
<gjob:Jobs>
<gjob:Job>
<gjob:Project ID="3"/>
<gjob:Application>GBackup</gjob:Application>
<gjob:Category>Development</gjob:Category>
<gjob:Update>
<gjob:Status>Open</gjob:Status>
<gjob:Modified>Mon, 07 Jun 1999 20:27:45 -0400 MET DST</gjob:Modified>
<gjob:Salary>USD 0.00</gjob:Salary>
</gjob:Update>
<gjob:Developers>
<gjob:Developer>
</gjob:Developer>
</gjob:Developers>
<gjob:Contact>
<gjob:Person>Nathan Clemons</gjob:Person>
<gjob:Email>[email protected]</gjob:Email>
<gjob:Company>
</gjob:Company>
<gjob:Organisation>
</gjob:Organisation>
<gjob:Webpage>
</gjob:Webpage>
<gjob:Snailmail>
</gjob:Snailmail>
<gjob:Phone>
</gjob:Phone>
</gjob:Contact>
<gjob:Requirements>
The program should be released as free software, under the GPL.
</gjob:Requirements>
<gjob:Skills>
</gjob:Skills>
<gjob:Details>
A GNOME based system that will allow a superuser to configure
compressed and uncompressed files and/or file systems to be backed
up with a supported media in the system. This should be able to
perform via find commands generating a list of files that are passed
to tar, dd, cpio, cp, gzip, etc., to be directed to the tape machine
or via operations performed on the filesystem itself. Email
notification and GUI status display very important.
</gjob:Details>
</gjob:Job>
</gjob:Jobs>
</gjob:Helping>

<?xml version="1.0"?>
<gjob:Helping xmlns:gjob="http://www.gnome.org/some-location">
  <gjob:Jobs>

    <gjob:Job>
      <gjob:Project ID="3"/>
      <gjob:Application>GBackup</gjob:Application>
      <gjob:Category>Development</gjob:Category>

      <gjob:Update>
        <gjob:Status>Open</gjob:Status>
        <gjob:Modified>Mon, 07 Jun 1999 20:27:45 -0400 MET DST</gjob:Modified>
        <gjob:Salary>USD 0.00</gjob:Salary>
      </gjob:Update>

      <gjob:Developers>
        <gjob:Developer>
        </gjob:Developer>
      </gjob:Developers>

      <gjob:Contact>
        <gjob:Person>Nathan Clemons</gjob:Person>
        <gjob:Email>[email protected]</gjob:Email>
        <gjob:Company>
        </gjob:Company>
        <gjob:Organisation>
        </gjob:Organisation>
        <gjob:Webpage>
        </gjob:Webpage>
        <gjob:Snailmail>
        </gjob:Snailmail>
        <gjob:Phone>
        </gjob:Phone>
      </gjob:Contact>

      <gjob:Requirements>
      The program should be released as free software, under the GPL.
      </gjob:Requirements>

      <gjob:Skills>
      </gjob:Skills>

      <gjob:Details>
      A GNOME based system that will allow a superuser to configure 
      compressed and uncompressed files and/or file systems to be backed 
      up with a supported media in the system.  This should be able to 
      perform via find commands generating a list of files that are passed 
      to tar, dd, cpio, cp, gzip, etc., to be directed to the tape machine 
      or via operations performed on the filesystem itself. Email 
      notification and GUI status display very important.
      </gjob:Details>

    </gjob:Job>

  </gjob:Jobs>
</gjob:Helping>

把XML文件加载到一个内部DOM树中只是调用几个函数的问题，而遍历整个树来收集数据，并生成内部结构则更困难，也更容易出错。
对输入结构的定义法则是非常宽松的。属性的顺序无关紧要（XML规范清楚地说明了这一点），不要依赖于一个节点的子节点顺序通常是一个好的主意，除非这样做真的使事情变得更困难了。下面是解析person信息的一段代码：

[cpp] view plain copy print ?

/*
* 一个person记录
*/
typedef struct person {
char *name;
char *email;
char *company;
char *organisation;
char *smail;
char *webPage;
char *phone;
} person, *personPtr;
/*
* 解析person的代码
*/
personPtr parsePerson(xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur) {
personPtr ret = NULL;
DEBUG("parsePerson\n");
/*
* 为结构分配内存
*/
ret = (personPtr) malloc(sizeof(person));
if (ret == NULL) {
fprintf(stderr,"out of memory\n");
return(NULL);
}
memset(ret, 0, sizeof(person));
/* 我们不关心顶层的元素名是什么 */
cur = cur->xmlChildrenNode;
while (cur != NULL) {
if ((!strcmp(cur->name, "Person")) && (cur->ns == ns))
ret->name = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
if ((!strcmp(cur->name, "Email")) && (cur->ns == ns))
ret->email = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
cur = cur->next;
}
return(ret);
}

/*
 * 一个person记录
 */
typedef struct person {
    char *name;
    char *email;
    char *company;
    char *organisation;
    char *smail;
    char *webPage;
    char *phone;
} person, *personPtr;

/*
 * 解析person的代码
 */
personPtr parsePerson(xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur) {
    personPtr ret = NULL;

DEBUG("parsePerson\n");
    /*
     * 为结构分配内存
     */
    ret = (personPtr) malloc(sizeof(person));
    if (ret == NULL) {
        fprintf(stderr,"out of memory\n");
        return(NULL);
    }
    memset(ret, 0, sizeof(person));

    /* 我们不关心顶层的元素名是什么 */
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        if ((!strcmp(cur->name, "Person")) && (cur->ns == ns))
            ret->name = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
        if ((!strcmp(cur->name, "Email")) && (cur->ns == ns))
            ret->email = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
        cur = cur->next;
    }

    return(ret);
}

    下面是要注意的一些事项：
   （1）通常一个递归的解析风格是更方便的：XML数据天然地遵循重复式地构造，并且是高度结构化的。
   （2）两个参数是xmlDocPtr和xmlNsPtr类型，即指向XML文档和应用程序保留的命名空间的指针。文档信息非常广泛，为你的应用程序数据集定义一个命名空间并测试元素和属性是否属性这个空间是一个好的编程实践。这只需一个简单的相等测试（cur->ns == ns）。
   （3）为了查询文本和属性值，你可以使用函数xmlNodeListGetString()来获取所有文本，和由DOM输出生成的引用节点，并生成一个单一的文本字符串。
   下面是解析另外一个结构的代码片段：

[cpp] view plain copy print ?

#include <libxml/tree.h>
/*
* 一个Job的描述
*/
typedef struct job {
char *projectID;
char *application;
char *category;
personPtr contact;
int nbDevelopers;
personPtr developers[100]; /* using dynamic alloc is left as an exercise */
} job, *jobPtr;
/*
* 解析Job的代码
*/
jobPtr parseJob(xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur) {
jobPtr ret = NULL;
DEBUG("parseJob\n");
/*
* 为结构分配内存
*/
ret = (jobPtr) malloc(sizeof(job));
if (ret == NULL) {
fprintf(stderr,"out of memory\n");
return(NULL);
}
memset(ret, 0, sizeof(job));
/* 我们不关心顶层元素名是什么 */
cur = cur->xmlChildrenNode;
while (cur != NULL) {
if ((!strcmp(cur->name, "Project")) && (cur->ns == ns)) {
ret->projectID = xmlGetProp(cur, "ID");
if (ret->projectID == NULL) {
fprintf(stderr, "Project has no ID\n");
}
}
if ((!strcmp(cur->name, "Application")) && (cur->ns == ns))
ret->application = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
if ((!strcmp(cur->name, "Category")) && (cur->ns == ns))
ret->category = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
if ((!strcmp(cur->name, "Contact")) && (cur->ns == ns))
ret->contact = parsePerson(doc, ns, cur);
cur = cur->next;
}
return(ret);
}

#include <libxml/tree.h>
/*
 * 一个Job的描述
 */
typedef struct job {
    char *projectID;
    char *application;
    char *category;
    personPtr contact;
    int nbDevelopers;
    personPtr developers[100]; /* using dynamic alloc is left as an exercise */
} job, *jobPtr;

/*
 * 解析Job的代码
 */
jobPtr parseJob(xmlDocPtr doc, xmlNsPtr ns, xmlNodePtr cur) {
    jobPtr ret = NULL;

DEBUG("parseJob\n");
    /*
     * 为结构分配内存
     */
    ret = (jobPtr) malloc(sizeof(job));
    if (ret == NULL) {
        fprintf(stderr,"out of memory\n");
        return(NULL);
    }
    memset(ret, 0, sizeof(job));

    /* 我们不关心顶层元素名是什么 */
    cur = cur->xmlChildrenNode;
    while (cur != NULL) {
        
        if ((!strcmp(cur->name, "Project")) && (cur->ns == ns)) {
            ret->projectID = xmlGetProp(cur, "ID");
            if (ret->projectID == NULL) {
                fprintf(stderr, "Project has no ID\n");
            }
        }
        if ((!strcmp(cur->name, "Application")) && (cur->ns == ns))
            ret->application = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
        if ((!strcmp(cur->name, "Category")) && (cur->ns == ns))
            ret->category = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1);
        if ((!strcmp(cur->name, "Contact")) && (cur->ns == ns))
            ret->contact = parsePerson(doc, ns, cur);
        cur = cur->next;
    }

    return(ret);
}

一旦你会使用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剖析(3)：使用教程)

斤斤计较的婚姻到底有多难？白心之岂必有为
很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
情绪觉察日记第37天露露_e800
今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说造命者说
底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
谢谢你们，爱你们！鹿游儿
昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
2021年12月19日，春蕾教育集团团建活动感受——黄晓丹黄错错加油
感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
《策划经理回忆录之二》路基雅虎
话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
Long类型前后端数据不一致 igotyback 前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
swagger访问路径 igotyback swagger
Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
30天风格练习-DAY2 黄希夷
Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
ArcGIS栅格计算器常见公式（赋值、0和空值的转换、补充栅格空值）研学随笔 arcgis 经验分享
我们在使用ArcGIS时通常经常用到栅格计算器，今天主要给大家介绍我日常中经常用到的几个公式，供大家参考学习。将特定值（-9999）赋值为0，例如-9999.Con("raster"==-9999,0,"raster")2.给空值赋予特定的值（如0）Con(IsNull("raster"),0,"raster")3.将特定的栅格值(如1)赋值为空值，其他保留原值SetNull("raster"==
高级编程--XML+socket练习题 masa010 java 开发语言
1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
开心蒋泳频
从无比抗拒来上课到接受，感动，收获～看着波哥成长，晶晶幸福笑容满面。感觉自己做的事情很有意义，很开心！还有3个感召目标就是还有三个有缘人，哈哈。明天感召去明日计划：8：30-11：00小公益11：00-21点上班，感召图片发自App图片发自App图片发自App
2018-07-23-催眠日作业-#不一样的31天#-66小鹿小鹿_33
预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
本周第二次约练 2cfbdfe28a51
中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
回溯 Leetcode 332 重新安排行程 mmaerd Leetcode刷题学习记录 leetcode 算法职场和发展
重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
今日联对0306 诗图佳得
自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.1、试对肖老师联：烟销皓月临江浒，夜笼寒沙梦晚舟。耀哥求正2、试对萧老师联:烟销浩月临江浒，雾散乾坤解汉城。秀霞习作请各位老师校正3、自对联：烟销皓月临江浒，水漫金山荡塔裙。一一肖士平2020.3.6.4、试对肖老师垫场联：烟销皓月临江浒，雾锁寒林缈葉丛。小智求正[抱拳]5、试对肖老师联：烟销皓月临江浒；风卷乱云入峰巅。一一五品6
每日一题——第八十九题互联网打工人no1 C语言程序设计每日一练 c语言
题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
每日一题——第八十四题互联网打工人no1 C语言程序设计每日一练 c语言
题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
《小满细雨轻湿尘》快乐的人ZZM
图片发自App《小满细雨轻湿尘》文/快乐的人zzm小满细雨轻湿尘石榴花开落纷纷落红不是无情物坠入泥土育养根2018-5-23
WPF中的ComboBox控件几种数据绑定的方式互联网打工人no1 wpf c#
一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
Python中os.environ基本介绍及使用方法鹤冲天Pro #Python python 服务器开发语言
文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
怎么起诉借钱不还的人？怎样起诉欠款不还的人？影子爱学习
怎么起诉借钱不还的人？怎样起诉欠款不还的人？如果遇到难以解决的法律问题，我们可以匹配专业律师。例如：婚姻家庭（离婚纠纷）、刑事辩护、合同纠纷、债权债务、房产（继承）纠纷、交通事故、劳动争议、人身损害、公司相关法律事务（法律顾问）等咨询推荐手机/微信:15633770876【全国案件皆可】借钱不还起诉对方需要哪些资料起诉欠钱不还的，一般需要的材料包括以下这些：借据、收据、欠条、付款凭证等证据，以及向
2019-12-22-22:30 涓涓1016
今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
linux sdl windows.h,Windows下的SDL安装奔跑吧linux内核 linux sdl windows.h
首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
相信相信的力量孙丽_cdb3
孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
感赏日志133 马姐读书
图片发自App感赏自己今天买个扫地机，以后可以解放出来多看点书，让这个智能小机器人替我工作了。感赏孩子最近进步很大，每天按时上学，认真听课，认真背书，主动认真完成老师布置的作业。感赏自己明白自己容易受到某人的影响，心情不好，每当此刻我就会舒缓，感赏，让自己尽快抽离，想好的一面。感赏儿子今天在我提醒他事情时，告诉我谢谢妈妈对我的提醒我明白了，而不是说我啰嗦，管事情，孩子更懂事了，懂得感恩了。投射父母
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
Maven Array_06 eclipse jdk maven
Maven Maven是基于项目对象模型(POM)，信息来管理项目的构建，报告和文档的软件项目管理工具。 Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法，许多 Apache Jakarta 项目发文时使用 Maven，而且公司
ibatis的queyrForList和queryForMap区别 bijian1013 java ibatis
一.说明 iBatis的返回值参数类型也有种：resultMap与resultClass，这两种类型的选择可以用两句话说明之： 1.当结果集列名和类的属性名完全相对应的时候，则可直接用resultClass直接指定查询结果类
LeetCode[位运算] - #191 计算汉明权重 Cwind java 位运算 LeetCode Algorithm 题解
原题链接：#191 Number of 1 Bits 要求：写一个函数，以一个无符号整数为参数，返回其汉明权重。例如，‘11’的二进制表示为'00000000000000000000000000001011', 故函数应当返回3。汉明权重：指一个字符串中非零字符的个数；对于二进制串，即其中‘1’的个数。难度：简单分析：将十进制参数转换为二进制，然后计算其中1的个数即可。 “
浅谈java类与对象 15700786134 java
java是一门面向对象的编程语言，类与对象是其最基本的概念。所谓对象，就是一个个具体的物体，一个人，一台电脑，都是对象。而类，就是对象的一种抽象，是多个对象具有的共性的一种集合，其中包含了属性与方法，就是属于该类的对象所具有的共性。当一个类创建了对象，这个对象就拥有了该类全部的属性，方法。相比于结构化的编程思路，面向对象更适用于人的思维
linux下双网卡同一个IP 被触发 linux
转自： http://q2482696735.blog.163.com/blog/static/250606077201569029441/ 由于需要一台机器有两个网卡，开始时设置在同一个网段的IP，发现数据总是从一个网卡发出，而另一个网卡上没有数据流动。网上找了下，发现相同的问题不少：一、关于双网卡设置同一网段IP然后连接交换机的时候出现的奇怪现象。当时没有怎么思考、以为是生成树
安卓按主页键隐藏程序之后无法再次打开肆无忌惮_ 安卓
遇到一个奇怪的问题，当SplashActivity跳转到MainActivity之后，按主页键，再去打开程序，程序没法再打开（闪一下），结束任务再开也是这样，只能卸载了再重装。而且每次在Log里都打印了这句话"进入主程序"。后来发现是必须跳转之后再finish掉SplashActivity 本来代码： // 销毁这个Activity fin
通过cookie保存并读取用户登录信息实例知了ing JavaScript html
通过cookie的getCookies()方法可获取所有cookie对象的集合；通过getName()方法可以获取指定的名称的cookie；通过getValue()方法获取到cookie对象的值。另外，将一个cookie对象发送到客户端，使用response对象的addCookie()方法。下面通过cookie保存并读取用户登录信息的例子加深一下理解。（1）创建index.jsp文件。在改
JAVA 对象池矮蛋蛋 java ObjectPool
原文地址： http://www.blogjava.net/baoyaer/articles/218460.html Jakarta对象池 ☆为什么使用对象池恰当地使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。Jakarta Commons Pool组件提供了一整套用于实现对象池化
ArrayList根据条件+for循环批量删除的方法 alleni123 java
场景如下： ArrayList<Obj> list Obj-> createTime, sid. 现在要根据obj的createTime来进行定期清理。（释放内存） ------------------------- 首先想到的方法就是 for(Obj o:list){ if(o.createTime-currentT>xxx){
阿里巴巴“耕地宝”大战各种宝百合不是茶平台战略
“耕地保”平台是阿里巴巴和安徽农民共同推出的一个 “首个互联网定制私人农场”，“耕地宝”由阿里巴巴投入一亿，主要是用来进行农业方面，将农民手中的散地集中起来不仅加大农民集体在土地上面的话语权，还增加了土地的流通与利用率，提高了土地的产量，有利于大规模的产业化的高科技农业的发展，阿里在农业上的探索将会引起新一轮的产业调整，但是集体化之后农民的个体的话语权将更少，国家应出台相应的法律法规保护
Spring注入有继承关系的类（1） bijian1013 java spring
一个类一个类的注入 1.AClass类 package com.bijian.spring.test2; public class AClass { String a; String b; public String getA() { return a; } public void setA(Strin
30岁转型期你能否成为成功人士 bijian1013 成功
很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
[Velocity三]基于Servlet+Velocity的web应用 bit1129 velocity
什么是VelocityViewServlet 使用org.apache.velocity.tools.view.VelocityViewServlet可以将Velocity集成到基于Servlet的web应用中，以Servlet+Velocity的方式实现web应用 Servlet + Velocity的一般步骤 1.自定义Servlet，实现VelocityViewServl
【Kafka十二】关于Kafka是一个Commit Log Service bit1129 service
Kafka is a distributed, partitioned, replicated commit log service.这里的commit log如何理解？ A message is considered "committed" when all in sync replicas for that partition have applied i
NGINX + LUA实现复杂的控制 ronin47 lua nginx 控制
安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
java-14.输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字 bylijinnan java
public class TwoElementEqualSum { /** * 第 14 题：题目：输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。要求时间复杂度是 O(n) 。如果有多对数字的和等于输入的数字，输出任意一对即可。例如输入数组 1 、 2 、 4 、 7 、 11 、 15 和数字 15 。由于
Netty源码学习-HttpChunkAggregator-HttpRequestEncoder-HttpResponseDecoder bylijinnan java netty
今天看Netty如何实现一个Http Server org.jboss.netty.example.http.file.HttpStaticFileServerPipelineFactory： pipeline.addLast("decoder", new HttpRequestDecoder()); pipeline.addLast(&quo
java敏感词过虑-基于多叉树原理 cngolon 违禁词过虑替换违禁词敏感词过虑多叉树
基于多叉树的敏感词、关键词过滤的工具包，用于java中的敏感词过滤 1、工具包自带敏感词词库，第一次调用时读入词库，故第一次调用时间可能较长，在类加载后普通pc机上html过滤5000字在80毫秒左右，纯文本35毫秒左右。 2、如需自定义词库，将jar包考入WEB-INF工程的lib目录，在WEB-INF/classes目录下建一个 utf-8的words.dict文本文件，
多线程知识 cuishikuan 多线程
T1，T2，T3三个线程工作顺序，按照T1，T2，T3依次进行 public class T1 implements Runnable{ @Override
spring整合activemq dalan_123 java spring jms
整合spring和activemq需要搞清楚如下的东东1、ConnectionFactory分： a、spring管理连接到activemq服务器的管理ConnectionFactory也即是所谓产生到jms服务器的链接 b、真正产生到JMS服务器链接的ConnectionFactory还得
MySQL时间字段究竟使用INT还是DateTime？ dcj3sjt126com mysql
环境：Windows XPPHP Version 5.2.9MySQL Server 5.1 第一步、创建一个表date_test（非定长、int时间） CREATE TABLE `test`.`date_test` (`id` INT NOT NULL AUTO_INCREMENT ,`start_time` INT NOT NULL ,`some_content`
Parcel: unable to marshal value dcj3sjt126com marshal
在两个activity直接传递List<xxInfo>时，出现Parcel: unable to marshal value异常。在MainActivity页面（MainActivity页面向NextActivity页面传递一个List<xxInfo>）： Intent intent = new Intent(this, Next
linux进程的查看上（ps） eksliang linux ps linux ps -l linux ps aux
ps:将某个时间点的进程运行情况选取下来转载请出自出处：http://eksliang.iteye.com/admin/blogs/2119469 http://eksliang.iteye.com ps 这个命令的man page 不是很好查阅，因为很多不同的Unix都使用这儿ps来查阅进程的状态，为了要符合不同版本的需求，所以这个
为什么第三方应用能早于System的app启动 gqdy365 System
Android应用的启动顺序网上有一大堆资料可以查阅了，这里就不细述了，这里不阐述ROM启动还有bootloader，软件启动的大致流程应该是启动kernel -> 运行servicemanager 把一些native的服务用命令启动起来（包括wifi, power, rild, surfaceflinger, mediaserver等等）-> 启动Dalivk中的第一个进程Zygot
App Framework发送JSONP请求(3) hw1287789687 jsonp 跨域请求发送jsonp ajax请求越狱请求
App Framework 中如何发送JSONP请求呢? 使用jsonp,详情请参考:http://json-p.org/ 如何发送Ajax请求呢? (1)登录 /*** * 会员登录 * @param username * @param password */ var user_login=function(username,password){ // aler
发福利，整理了一份关于“资源汇总”的汇总 justjavac 资源
觉得有用的话，可以去github关注：https://github.com/justjavac/awesome-awesomeness-zh_CN 通用 free-programming-books-zh_CN 免费的计算机编程类中文书籍精彩博客集合 hacke2/hacke2.github.io#2 ResumeSample 程序员简历
用 Java 技术创建 RESTful Web 服务 macroli java 编程 Web REST
转载：http://www.ibm.com/developerworks/cn/web/wa-jaxrs/ JAX-RS (JSR-311) 【 Java API for RESTful Web Services 】是一种 Java™ API，可使 Java Restful 服务的开发变得迅速而轻松。这个 API 提供了一种基于注释的模型来描述分布式资源。注释被用来提供资源的位
CentOS6.5-x86_64位下oracle11g的安装详细步骤及注意事项超声波 oracle linux
前言：这两天项目要上线了，由我负责往服务器部署整个项目，因此首先要往服务器安装oracle，服务器本身是CentOS6.5的64位系统，安装的数据库版本是11g，在整个的安装过程中碰到很多的坑，不过最后还是通过各种途径解决并成功装上了。转别写篇博客来记录完整的安装过程以及在整个过程中的注意事项。希望对以后那些刚刚接触的菜鸟们能起到一定的帮助作用。安装过程中可能遇到的问题（注
HttpClient 4.3 设置keeplive 和 timeout 的方法 supben httpclient
ConnectionKeepAliveStrategy kaStrategy = new DefaultConnectionKeepAliveStrategy() { @Override public long getKeepAliveDuration(HttpResponse response, HttpContext context) { long keepAlive
Spring 4.2新特性-@Import注解的升级 wiselyman spring 4
3.1 @Import @Import注解在4.2之前只支持导入配置类在4.2,@Import注解支持导入普通的java类,并将其声明成一个bean 3.2 示例演示java类 package com.wisely.spring4_2.imp; public class DemoService { public void doSomethin