sqlite引入的fts5扩展功能，会创建table_content/table_data等数据表，其中_data中是索引数据，可以尝试解析还原出很多有趣的内容。

至于数据结构后面有心情了再补充，直接贴代码。

此代码为C++类。

#pragma once

#include <string>
#include <vector>
#include <map>

#define _fts5GetVarint32(a,b) Fts5GetVarint32((const unsigned char*)a,(uint32_t*)&b)
#define _fts5GetVarint(a,b)    Fts5GetVarint((const unsigned char*)a,b)

#define _fts5FastGetVarint32(a, iOff, nVal) {      \
  nVal = (a)[iOff++];                             \
  if( nVal & 0x80 ){                              \
    iOff--;                                       \
    iOff += _fts5GetVarint32(&(a)[iOff], nVal);    \
  }                                               \
}


class FTS5DataHandler
{
public:
	FTS5DataHandler() = default;

#define FTS5_DATA_ID_B     16     /* Max seg id number 65535 */
#define FTS5_DATA_DLI_B     1     /* Doclist-index flag (1 bit) */
#define FTS5_DATA_HEIGHT_B  5     /* Max dlidx tree height of 32 */
#define FTS5_DATA_PAGE_B   31     /* Max page number of 2147483648 */

	static void fts5DecodeRowid(
		int64_t iRowid,                     /* Rowid from %_data table */
		int* piSegid,                   /* OUT: Segment id */
		int* pbDlidx,                   /* OUT: Dlidx flag */
		int* piHeight,                  /* OUT: Height */
		int* piPgno                     /* OUT: Page number */
	) {
		*piPgno = (int)(iRowid & (((int64_t)1 << FTS5_DATA_PAGE_B) - 1));
		iRowid >>= FTS5_DATA_PAGE_B;

		*piHeight = (int)(iRowid & (((int64_t)1 << FTS5_DATA_HEIGHT_B) - 1));
		iRowid >>= FTS5_DATA_HEIGHT_B;

		*pbDlidx = (int)(iRowid & 0x0001);
		iRowid >>= FTS5_DATA_DLI_B;

		*piSegid = (int)(iRowid & (((int64_t)1 << FTS5_DATA_ID_B) - 1));
	}

	static std::pair<std::string, bool> ParserFts5BlockOverData(const std::string& block)
	{
		int nDataLen = (int)block.length();
		if (nDataLen < 4)
			return {};

		const char* pData = block.c_str();

		int iRowidOff = fts5GetU16((const unsigned char*)&pData[0]);
		int iPgidx = fts5GetU16((const unsigned char*)&pData[2]); //词条数据总长度
		if (iPgidx > nDataLen)
			return {};
		if (iPgidx == nDataLen)
			return { block.substr(4, iPgidx - 4), true };

		int iOverdataLen = 0;
		_fts5GetVarint32(&pData[iPgidx], iOverdataLen);

		if (iOverdataLen <= 4)
			return {};
		if (iOverdataLen >= nDataLen)
			return {};

		return { block.substr(4, iOverdataLen - 4), false };
	}

	void ParserFts5BlockData(const std::string& block, const std::vector<std::string>& overdatas)
	{
		if (block.length() < 4)
			return;

		const char* pData = block.data();
		int nDataSize = (int)block.length();

		int iRowidOff = fts5GetU16((const unsigned char*)&pData[0]); //上一条数据的pos list的over data len + 4
		int iPgidx = fts5GetU16((const unsigned char*)&pData[2]); //词条数据总长度
		if (iPgidx >= nDataSize)
			return;

		int iTermOff = 0;
		int iPgidxOff = iPgidx;
		iPgidxOff += _fts5GetVarint32(&pData[iPgidxOff], iTermOff); //上一条数据的doclist的over data

		assert(iTermOff);
		std::string last_block;
		int iLastTermLen = 0;
		std::vector<int> overdataLens;

		//解析词条数据
		bool bFirst = true;
		std::string word;
		while (true)
		{
			int nTermLen;
			if (iPgidxOff < nDataSize)
			{
				iPgidxOff += _fts5GetVarint32(&pData[iPgidxOff], nTermLen);
			}
			else if (iTermOff < iPgidx)
			{
				//末尾块
				nTermLen = iPgidx - iTermOff;
				if (!overdatas.empty())
				{
					std::string overdata;
					for (const auto& data : overdatas)
					{
						overdata.append(data);
						overdataLens.emplace_back((int)data.length());
					}

					last_block = block.substr(iTermOff, nTermLen);
					last_block.append(overdata);

					//修正变量
					iLastTermLen = nTermLen; //用于重置overdata的rowid索引
					nTermLen += (int)overdata.length();
					iPgidx = nTermLen;
					iTermOff = 0;
					pData = last_block.data();
				}
			}
			else
			{
				//数据解析到头了
				break;
			}

			if (iTermOff + nTermLen > iPgidx)
				break;
			int iTermEnd = iTermOff + nTermLen;
			//fmtlog("term len:{}, offset:0x{:x}", nTermLen, iTermOff);

			//读取词条keep
			int iWordKeep = 0;
			if (!bFirst)
			{
				_fts5FastGetVarint32(pData, iTermOff, iWordKeep);
				if (iWordKeep <= 0)
					break;
				iWordKeep--;
			}

			//读取词条长度
			int nWordLen;
			_fts5FastGetVarint32(pData, iTermOff, nWordLen);
			if (nWordLen <= 0)
				break;
			if (iTermOff + nWordLen >= iPgidx)
				break;

			//读取词条
			if (bFirst && nWordLen > 1)
			{
				//跳过一个字节
				if (nWordLen > 1)
					word.assign(&pData[iTermOff + 1], nWordLen - 1);
				else
					word.assign(&pData[iTermOff], nWordLen); //理论上不应该到这里

				bFirst = false;
			}
			else
			{
				if (iWordKeep)
				{
					if (iWordKeep > (int)word.length())
						break;

					word.assign(word, 0, iWordKeep);
					word.append(&pData[iTermOff], nWordLen);
				}
				else
				{
					word.assign(&pData[iTermOff], nWordLen);
				}
			}
			iTermOff += nWordLen;
			//fmtlog("word:{}({}), keep:{}", Utf82GBK(word), String2Hex(word), iWordKeep);
			// 		if (word == "j")
			// 			int b = 0;

			//解析docList
			int nRowID = 0;
			while (iTermOff < iTermEnd)
			{
				if (iLastTermLen && iTermOff >= iLastTermLen)
				{
					//重置rowid
					nRowID = 0;

					if (!overdataLens.empty())
					{
						iLastTermLen += overdataLens[0];
						overdataLens.erase(overdataLens.begin());
					}
					else
					{
						iLastTermLen = 0;
					}
				}

				//读取rowid(docid)
				int nRowidTmp = 0;
				iTermOff += _fts5GetVarint32(&pData[iTermOff], nRowidTmp);
				//增量
				nRowID += nRowidTmp;
				//fmtlog("	rowid:{}", nRowID);

				//读取pos list len
				int nPosListSize = 0;
				iTermOff += _fts5GetVarint32(&pData[iTermOff], nPosListSize);
				if (nPosListSize < 0)
					break;
				nPosListSize /= 2;
				//fmtlog("	pos list size:{}", nPosListSize);
				if (iTermOff + nPosListSize > iTermEnd)
					break;

				if (nPosListSize == 0)
					continue;

				//读取pos list
				auto poslist = fts5DecodePosList(&pData[iTermOff], nPosListSize);
				if (m_rowidsFilter.empty() || !m_rowidsFilter.HasKey(nRowID))
				{
					//printf("word:%s(%s), keep:%d \n", Utf82GBK(word).c_str(), String2Hex(word).c_str(), iWordKeep);
					//printf("	rowid:%d \n", nRowID);
					//printf("	pos list size:%d \n", nPosListSize);
					//fmtlog("	pos list:{}", poslist);

					for (const auto& posinfo : poslist)
					{
						for (const auto& pos : posinfo.second)
						{
							m_result[nRowID][posinfo.first].emplace(pos, word);
							//auto ret = m_result[nRowID][posinfo.first].emplace(pos, word);
// 							if (!ret.second)
// 								printf("break;\n");
						}
					}
				}
				iTermOff += nPosListSize;
			}
		}
	}

	inline void SetRowidFilter(int nRowid)
	{
		m_rowidsFilter.emplace(nRowid);
	}

	inline void ClearRowidFilter()
	{
		m_rowidsFilter.clear();
	}

	std::map<int, std::map<int, std::string>> GetResult()
	{
		//整理词语转为真正的句子
		//std::map<int, std::map<int, std::vector<std::pair<std::string, std::vector<int>>>>> m_result;
		//		rowid		  colid     content
		std::map<int, std::map<int, std::string>> ret;
		for (auto& kv : m_result)
		{
			int nRowid = kv.first;
			for (auto& rowinfo : kv.second)
			{
				int nColid = rowinfo.first;

				//合并字符串
				std::string content;
				std::for_each(rowinfo.second.begin(), rowinfo.second.end(), [&content](const std::pair<int, std::string> &p) {
					content.append(p.second);
				});

				ret[nRowid][nColid] = content;
				//ret[nRowid][nColid] = Utf82GBK(content);
			}
		}

#ifdef _DEBUG
		//fmtlog("ret:{}", ret);
#endif // _DEBUG

		return ret;
	}

private:

	FKeySet<int> m_rowidsFilter;

	//结果集
	//		rowid		  colid			index     word
	std::map<int, std::map<int, std::map<int, std::string, std::less<>>>> m_result;

	//列id-pos list
	//				col         pos list
	static std::map<int, std::vector<int>> fts5DecodePosList(const char* pData, int nPosListSize)
	{
		std::map<int, std::vector<int>> ret;
		int nPos = 0;
		int nDocOff = 0;
		int nColID = 0;
		int nPosID = 0;
		while (nDocOff < nPosListSize)
		{
			int nPos;
			_fts5FastGetVarint32(pData, nDocOff, nPos);
			if (nPos <= 0)
				break;

			if (nPos == 1)
			{
				//列切换
				int nColOff;
				_fts5FastGetVarint32(pData, nDocOff, nColOff);
				if (nColOff <= 0)
					break;
				nColID += nColOff;
				nPosID = 0;
				continue;
			}

			nPosID += nPos - 2;
			ret[nColID].emplace_back(nPosID);
		}

		return ret;
	}


#define SLOT_2_0     0x001fc07f
#define SLOT_4_2_0   0xf01fc07f

	static uint16_t fts5GetU16(const unsigned char* aIn) 
	{
		return ((uint16_t)aIn[0] << 8) + aIn[1];
	}


	static uint8_t Fts5GetVarint(const unsigned char* p, uint64_t* v) {
		uint32_t a, b, s;

		a = *p;
		/* a: p0 (unmasked) */
		if (!(a & 0x80))
		{
			*v = a;
			return 1;
		}

		p++;
		b = *p;
		/* b: p1 (unmasked) */
		if (!(b & 0x80))
		{
			a &= 0x7f;
			a = a << 7;
			a |= b;
			*v = a;
			return 2;
		}

		/* Verify that constants are precomputed correctly */
		assert(SLOT_2_0 == ((0x7f << 14) | (0x7f)));
		assert(SLOT_4_2_0 == ((0xfU << 28) | (0x7f << 14) | (0x7f)));

		p++;
		a = a << 14;
		a |= *p;
		/* a: p0<<14 | p2 (unmasked) */
		if (!(a & 0x80))
		{
			a &= SLOT_2_0;
			b &= 0x7f;
			b = b << 7;
			a |= b;
			*v = a;
			return 3;
		}

		/* CSE1 from below */
		a &= SLOT_2_0;
		p++;
		b = b << 14;
		b |= *p;
		/* b: p1<<14 | p3 (unmasked) */
		if (!(b & 0x80))
		{
			b &= SLOT_2_0;
			/* moved CSE1 up */
			/* a &= (0x7f<<14)|(0x7f); */
			a = a << 7;
			a |= b;
			*v = a;
			return 4;
		}

		/* a: p0<<14 | p2 (masked) */
		/* b: p1<<14 | p3 (unmasked) */
		/* 1:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
		/* moved CSE1 up */
		/* a &= (0x7f<<14)|(0x7f); */
		b &= SLOT_2_0;
		s = a;
		/* s: p0<<14 | p2 (masked) */

		p++;
		a = a << 14;
		a |= *p;
		/* a: p0<<28 | p2<<14 | p4 (unmasked) */
		if (!(a & 0x80))
		{
			/* we can skip these cause they were (effectively) done above in calc'ing s */
			/* a &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
			/* b &= (0x7f<<14)|(0x7f); */
			b = b << 7;
			a |= b;
			s = s >> 18;
			*v = ((uint64_t)s) << 32 | a;
			return 5;
		}

		/* 2:save off p0<<21 | p1<<14 | p2<<7 | p3 (masked) */
		s = s << 7;
		s |= b;
		/* s: p0<<21 | p1<<14 | p2<<7 | p3 (masked) */

		p++;
		b = b << 14;
		b |= *p;
		/* b: p1<<28 | p3<<14 | p5 (unmasked) */
		if (!(b & 0x80))
		{
			/* we can skip this cause it was (effectively) done above in calc'ing s */
			/* b &= (0x7f<<28)|(0x7f<<14)|(0x7f); */
			a &= SLOT_2_0;
			a = a << 7;
			a |= b;
			s = s >> 18;
			*v = ((uint64_t)s) << 32 | a;
			return 6;
		}

		p++;
		a = a << 14;
		a |= *p;
		/* a: p2<<28 | p4<<14 | p6 (unmasked) */
		if (!(a & 0x80))
		{
			a &= SLOT_4_2_0;
			b &= SLOT_2_0;
			b = b << 7;
			a |= b;
			s = s >> 11;
			*v = ((uint64_t)s) << 32 | a;
			return 7;
		}

		/* CSE2 from below */
		a &= SLOT_2_0;
		p++;
		b = b << 14;
		b |= *p;
		/* b: p3<<28 | p5<<14 | p7 (unmasked) */
		if (!(b & 0x80))
		{
			b &= SLOT_4_2_0;
			/* moved CSE2 up */
			/* a &= (0x7f<<14)|(0x7f); */
			a = a << 7;
			a |= b;
			s = s >> 4;
			*v = ((uint64_t)s) << 32 | a;
			return 8;
		}

		p++;
		a = a << 15;
		a |= *p;
		/* a: p4<<29 | p6<<15 | p8 (unmasked) */

		/* moved CSE2 up */
		/* a &= (0x7f<<29)|(0x7f<<15)|(0xff); */
		b &= SLOT_2_0;
		b = b << 8;
		a |= b;

		s = s << 4;
		b = p[-4];
		b &= 0x7f;
		b = b >> 3;
		s |= b;

		*v = ((uint64_t)s) << 32 | a;

		return 9;
	}

	static int Fts5GetVarint32(const unsigned char* p, uint32_t* v) {
		uint32_t a, b;

		/* The 1-byte case. Overwhelmingly the most common. */
		a = *p;
		/* a: p0 (unmasked) */
		if (!(a & 0x80))
		{
			/* Values between 0 and 127 */
			*v = a;
			return 1;
		}

		/* The 2-byte case */
		p++;
		b = *p;
		/* b: p1 (unmasked) */
		if (!(b & 0x80))
		{
			/* Values between 128 and 16383 */
			a &= 0x7f;
			a = a << 7;
			*v = a | b;
			return 2;
		}

		/* The 3-byte case */
		p++;
		a = a << 14;
		a |= *p;
		/* a: p0<<14 | p2 (unmasked) */
		if (!(a & 0x80))
		{
			/* Values between 16384 and 2097151 */
			a &= (0x7f << 14) | (0x7f);
			b &= 0x7f;
			b = b << 7;
			*v = a | b;
			return 3;
		}

		/* A 32-bit varint is used to store size information in btrees.
		** Objects are rarely larger than 2MiB limit of a 3-byte varint.
		** A 3-byte varint is sufficient, for example, to record the size
		** of a 1048569-byte BLOB or string.
		**
		** We only unroll the first 1-, 2-, and 3- byte cases.  The very
		** rare larger cases can be handled by the slower 64-bit varint
		** routine.
		*/
		{
			uint64_t v64;
			uint8_t n;
			p -= 2;
			n = Fts5GetVarint(p, &v64);
			*v = ((uint32_t)v64) & 0x7FFFFFFF;
			assert(n > 3 && n <= 9);
			return n;
		}
	}
};

java可以将任意对象序列化为一段内存流，也可以反序列化回对象。

此代码用于dump序列化内容流，是用了Jsoncpp作为父类。

主要参考了https://github.com/NickstaDB/SerializationDumper这个项目。

#pragma once

#include <string>
#include <vector>
#include <cassert>
#include "FStream.h"

#include "json/json.h"

// #ifdef _DEBUG
// #pragma comment(lib, "jsoncpp/lib_json_mtd.lib")
// #else
// #pragma comment(lib, "jsoncpp/lib_json_mt.lib")
// #endif // _DEBUG

/*
Java序列化内容（以0xACED开头）解析工具，转为jsoncpp的Json::Value
参考链接： https://github.com/NickstaDB/SerializationDumper

用法：
JavaSerializationHandler jsonSerialize;
jsonSerialize.OpenSerializationBuffer(buf);
jsonSerialize.OpenSerializationFile(filepath);
dumpjson(jsonSerialize); //直接就是Json::Value的子类，可以直接按照json使用

说明：
如果对象是Object，那么会该Object的json节点会出现几个元素(使用前还是要校验一下存在与否):
	"_desc" : 类的描述信息，包括类名、字段描述、父类信息等等
	"_data" : 类的数据
	"_block": 类的附加块数据，一些内置的java类型例如hashmap或者list等等会使用该字段，这里的数据一般需要二次整理，不要直接使用
	"_array": 如果是Array类型数据例如java.util.ArrayList等，会出现该字段，类型是数组，数组的元素由_block字段中整理并保存到该字段下
	"_hashmap":如果是java.util.HashMap类型数据会出现该字段，由_block字段中的数据整理并保存到该字段下
	"_enum" : 暂时还没碰到过这个类型的数据样本，围观。。。
	
实例：
	末尾部分。
*/


class JavaSerializationHandler : public Json::Value
{
	/*******************
	 * Read a content element from the data stream.
	 *
	 * Could be any of:
	 *	TC_OBJECT			(0x73)
	 *	TC_CLASS			(0x76)
	 *	TC_ARRAY			(0x75)
	 *	TC_STRING			(0x74)
	 *	TC_LONGSTRING		(0x7c)
	 *	TC_ENUM				(0x7e)
	 *	TC_CLASSDESC		(0x72)
	 *	TC_PROXYCLASSDESC	(0x7d)
	 *	TC_REFERENCE		(0x71)
	 *	TC_NULL				(0x70)
	 *	TC_EXCEPTION		(0x7b)
	 *	TC_RESET			(0x79)
	 *	TC_BLOCKDATA		(0x77)
	 *	TC_BLOCKDATALONG	(0x7a)
	 ******************/

	enum classElementType
	{
		TC_NULL = 0x70,
		TC_REFERENCE = 0x71,
		TC_CLASSDESC = 0x72,
		TC_OBJECT = 0x73,
		TC_STRING = 0x74,
		TC_ARRAY = 0x75,
		TC_CLASS = 0x76,
		TC_BLOCKDATA = 0x77,
		TC_ENDBLOCKDATA = 0x78,
		TC_RESET = 0x79,
		TC_BLOCKDATALONG = 0x7a,
		TC_EXCEPTION = 0x7b,
		TC_LONGSTRING = 0x7c,
		TC_ENUM = 0x7e,
		TC_PROXYCLASSDESC = 0x7d
	};

	enum classDescFlags
	{
		SC_WRITE_METHOD = 0x01,
		SC_SERIALIZABLE = 0x02,
		SC_EXTERNALIZABLE = 0x04,
		SC_BLOCK_DATA = 0x08
	};

	struct OBJECT_REF_DATA
	{
		uint32_t ref;
		uint8_t type;
		Json::Value data;
	};


#ifndef _bswap_16
	/* Swap bytes in 16 bit value.  */
#define _bswap_16(x) \
	     ((unsigned short int) ((((x) >> 8) & 0xff) | (((x) & 0xff) << 8)))
#endif

#ifndef _bswap_32
/* Swap bytes in 32 bit value.  */
#define _bswap_32(x) \
	     ((((x) & 0xff000000) >> 24) | (((x) & 0x00ff0000) >>  8) |		      \
	      (((x) & 0x0000ff00) <<  8) | (((x) & 0x000000ff) << 24))
#endif

#ifndef _bswap_64
/* Swap bytes in 64 bit value.  */
# define _bswap_64(x) \
	     ((((x) & 0xff00000000000000ull) >> 56)				      \
	      | (((x) & 0x00ff000000000000ull) >> 40)				      \
	      | (((x) & 0x0000ff0000000000ull) >> 24)				      \
	      | (((x) & 0x000000ff00000000ull) >> 8)				      \
	      | (((x) & 0x00000000ff000000ull) << 8)				      \
	      | (((x) & 0x0000000000ff0000ull) << 24)				      \
	      | (((x) & 0x000000000000ff00ull) << 40)				      \
	      | (((x) & 0x00000000000000ffull) << 56))
#endif

	
public:
	JavaSerializationHandler() : m_refIndex(0x7e0000) {};
	~JavaSerializationHandler() {};

	template<typename _T>
	bool OpenSerializationFile(const _T& filepath)
	{
		FFileStream infile(filepath);
		m_bufstream = &infile;

		bool ret = false;
#ifdef _DEBUG
		ret = JavaSerializationParser(*this);
#else
		try
		{
			ret = JavaSerializationParser(*this);
		}
		catch (...) {}
#endif // _DEBUG

		return ret;
	}

	bool OpenSerializationBuffer(const std::string &buf)
	{
		FBufferStream stream(buf);
		m_bufstream = &stream;
		
		bool ret = false;
#ifdef _DEBUG
		ret = JavaSerializationParser(*this);
#else
		try
		{
			ret = JavaSerializationParser(*this);
		}
		catch (...) {}
#endif // _DEBUG

		return ret;
	}
	
private:
	FStream* m_bufstream;
	std::vector<OBJECT_REF_DATA> m_objectRefs;
	uint32_t m_refIndex;
	

	const char* getTypeString(uint8_t type)
	{
		//获取enum类型的字符串
		switch (type)
		{
		case TC_NULL:
			return "TC_NULL";
		case TC_REFERENCE:
			return "TC_REFERENCE";
		case TC_CLASSDESC:
			return "TC_CLASSDESC";
		case TC_OBJECT:
			return "TC_OBJECT";
		case TC_STRING:
			return "TC_STRING";
		case TC_ARRAY:
			return "TC_ARRAY";
		case TC_CLASS:
			return "TC_CLASS";
		case TC_BLOCKDATA:
			return "TC_BLOCKDATA";
		case TC_ENDBLOCKDATA:
			return "TC_ENDBLOCKDATA";
		case TC_RESET:
			return "TC_RESET";
		case TC_BLOCKDATALONG:
			return "TC_BLOCKDATALONG";
		case TC_EXCEPTION:
			return "TC_EXCEPTION";
		case TC_LONGSTRING:
			return "TC_LONGSTRING";
		case TC_ENUM:
			return "TC_ENUM";
		}

		return "UNKNOWN";
	}

	Json::Value getObjectByRef(uint32_t ref)
	{
		for (auto& obj : m_objectRefs)
		{
			if (obj.ref == ref)
			{
#ifdef _DEBUG
//				if (obj.type == TC_STRING || obj.type == TC_LONGSTRING)
//					printf("get ref:0x%x, string:%s \n", ref, obj.data.asCString());
//				else
//					printf("get ref:0x%x, type:%s(%x) \n", ref, getTypeString(obj.type), obj.type);
#endif // _DEBUG

				return obj.data;
				break;
			}
		}

		return {};
	}

	uint32_t setObjectRef(uint8_t type, const Json::Value& val)
	{
		m_objectRefs.emplace_back(OBJECT_REF_DATA{ m_refIndex , type, val });
#ifdef _DEBUG
// 		if (type == TC_STRING || type == TC_LONGSTRING)
// 			printf("new ref:0x%x, string:%s \n", m_refIndex, val.asCString());
// 		else
// 			printf("new ref:0x%x, type:%s(%x) \n", m_refIndex, getTypeString(type), type);
#endif // _DEBUG
		return m_refIndex++;
	}

	void updateObjectRef(uint32_t ref, uint8_t type, const Json::Value& val)
	{
		for (auto& obj : m_objectRefs)
		{
			if (obj.ref == ref)
			{
				obj.type = type;
				obj.data = val;
				break;
			}
		}
	}

	std::string tohex(const std::string& data)
	{
		std::string strRet;
		if (data.empty())
			return strRet;

		strRet.reserve(data.length() * 2);
		const char* hex = "0123456789abcdef";
		for (char ch : data)
		{
			strRet.push_back(hex[(unsigned char)ch >> 4]);
			strRet.push_back(hex[(unsigned char)ch & 0xf]);
		}

		return strRet;
	}


	bool readReference(uint32_t& ref)
	{
		if (!m_bufstream->read_data(ref))
			return false;

		ref = _bswap_32(ref);
		return true;
	}

	bool readUtf(std::string& ret)
	{
		uint16_t len;
		if (!m_bufstream->read_data(len))
			return false;
		len = _bswap_16(len);

		if (len && !m_bufstream->read_buffer(ret, len))
			return false;

		return true;
	}

	bool readLongUtf(std::string& ret)
	{
		uint64_t len;
		if (!m_bufstream->read_data(len))
			return false;
		len = _bswap_64(len);

		if (!m_bufstream->read_buffer(ret, (size_t)len))
			return false;

		return true;
	}

	bool readNewString(Json::Value& val)
	{
		uint8_t type;
		if (!m_bufstream->read_data(type))
			return false;

		if (type == TC_STRING || type == TC_LONGSTRING || type == TC_REFERENCE)
			return readContentElement(type, val);

		//剩下的类型都不对
		return false;
	}

	bool readNewArray(Json::Value& jsonarray)
	{
		Json::Value jsonDesc;
		//Read the class data description to enable array elements to be read
		if (!readClassDesc(jsonDesc))
			return false;

		if (!jsonDesc.isObject() || !jsonDesc["classname"].isString())
			return false;

		std::string str = jsonDesc["classname"].asString();
		if (str.length() < 2 || str[0] != '[')
			return false;
		uint8_t type = str[1];

		jsonarray["_desc"] = jsonDesc;

		//索引值+1
		int refindex = setObjectRef(TC_ARRAY, jsonarray);

		//array size
		uint32_t arraysize;
		if (!m_bufstream->read_data(arraysize))
			return false;

		for (uint32_t i = 0; i < arraysize; i++)
		{
			if (!readFieldValue(type, jsonarray["_array"][i]))
				return false;
		}

		//更新值
		updateObjectRef(refindex, TC_ARRAY, jsonarray);

		return true;
	}

	bool readFieldValue(int type, Json::Value& jsonvalue)
	{
		switch (type)
		{
		case 'B':		//byte 1
			uint8_t val;
			if (!m_bufstream->read_data(val))
				return false;
			jsonvalue = val;
			break;

		case 'C':		//char java里面的char占用2字节
		case 'S':		//short
		{
			uint16_t val;
			if (!m_bufstream->read_data(val))
				return false;
			jsonvalue = _bswap_16(val);
			break;
		}
		case 'D':		//double
		{
			uint64_t val;
			if (!m_bufstream->read_data(val))
				return false;
			val = _bswap_64(val);
			jsonvalue = *(double*)&val;
			break;
		}
		case 'F':		//float
		{
			uint32_t val;
			if (!m_bufstream->read_data(val))
				return false;
			val = _bswap_32(val);
			jsonvalue = *(float*)&val;
			break;
		}
		case 'I':		//int
		{
			uint32_t val;
			if (!m_bufstream->read_data(val))
				return false;
			jsonvalue = (int32_t)_bswap_32(val);
			break;
		}
		case 'J':		//long
		{
			uint64_t val;
			if (!m_bufstream->read_data(val))
				return false;
			jsonvalue = (int64_t)_bswap_64(val);
			break;
		}
		case 'Z':		//boolean
		{
			uint8_t val;
			if (!m_bufstream->read_data(val))
				return false;
			if (val)
				jsonvalue = true;
			else
				jsonvalue = false;
			break;
		}
		case '[':		//array
		case 'L':		//object
			if (!readContentElement(jsonvalue))
				return false;
			break;

		default:		//Unknown field type
			printf("unknown filed type: %c\n", type);
			return false;
		}

		return true;
	}

	bool readClassAnnotation(Json::Value& jsonret)
	{
		//classAnnotation
		int index = 0;
		while (true)
		{
			uint8_t type;
			if (!m_bufstream->read_data(type))
				return false;

			if (type == TC_ENDBLOCKDATA)
				break;

			if (!readContentElement(type, jsonret[index]))
				return false;

			index++;
		}

		return true;
	}

	bool readNewClassDesc(Json::Value& jsonret)
	{
		//由于desc很长很长，先占个坑把ref的index占了
		uint32_t refindex = setObjectRef(TC_CLASSDESC, jsonret);

		//className
		std::string className;
		if (!readUtf(className))
			return false;
		if (className.empty())
		{
			printf("Error: class name is empty.\n");
			return false;
		}
		jsonret["classname"] = className;

		//serialVersionUID 固定8字节
		std::string serialVersionUID;
		if (!m_bufstream->read_buffer(serialVersionUID, 8))
			return false;
		jsonret["uid"] = tohex(serialVersionUID);

		//classDescFlags
		uint8_t classflags;
		if (!m_bufstream->read_data(classflags))
			return false;
		////Validate classDescFlags
		if ((classflags & 0x02) == 0x02)
		{
			if ((classflags & 0x04) == 0x04)
			{
				printf("Error: Illegal classDescFlags, SC_SERIALIZABLE is not compatible with SC_EXTERNALIZABLE. \n");
				return false;
			}
			if ((classflags & 0x08) == 0x08)
			{
				printf("Error: Illegal classDescFlags, SC_SERIALIZABLE is not compatible with SC_BLOCK_DATA. \n");
				return false;
			}
		}
		else if ((classflags & 0x04) == 0x04)
		{
			if ((classflags & 0x01) == 0x01)
			{
				printf("Error: Illegal classDescFlags, SC_EXTERNALIZABLE is not compatible with SC_WRITE_METHOD.\n");
				return false;
			}
		}
		else if (classflags != 0x00)
		{
			printf("Error: Illegal classDescFlags, must include either SC_SERIALIZABLE or SC_EXTERNALIZABLE. \n");
			return false;
		}
		jsonret["flags"] = classflags;

		//read fields
		uint16_t fieldcount;
		if (!m_bufstream->read_data(fieldcount))
			return false;
		fieldcount = _bswap_16(fieldcount);
		jsonret["fields"].resize(0);
		for (uint16_t i = 0; i < fieldcount; i++)
		{
			uint8_t fieldtype;
			if (!m_bufstream->read_data(fieldtype))
				return false;
			jsonret["fields"][i]["type"] = fieldtype;

			std::string fieldname;
			if (!readUtf(fieldname))
				return false;
			if (fieldname.empty())
			{
				printf("Error: field name is empty.\n");
				//return false;
			}
			jsonret["fields"][i]["name"] = fieldname;

			if (fieldtype == '[' || fieldtype == 'L')
			{
				if (!readNewString(jsonret["fields"][i]["classname"]))
					return false;
			}
		}

		//ClassAnnotation
		if (!readClassAnnotation(jsonret["annotation"]))
			return false;

		//SuperClassDesc ???
		if (!readClassDesc(jsonret["superclass"]))
			return false;

		//更新refs
		updateObjectRef(refindex, TC_CLASSDESC, jsonret);

		return true;
	}

	bool readNewProxyClassDesc(Json::Value& jsonret)
	{
		//由于desc很长很长，先占个坑把ref的index占了
		uint32_t refindex = setObjectRef(TC_PROXYCLASSDESC, jsonret);

		uint32_t count;
		if (!m_bufstream->read_data(count))
			return false;
		count = _bswap_32(count);

		//proxyInterfaceNames
		for (uint32_t i = 0; i < count; i++)
		{
			std::string classname;
			if (!readUtf(classname))
				return false;
			jsonret["proxyclass"][i] = classname;
		}

		//ClassAnnotation
		if (!readClassAnnotation(jsonret["annotation"]))
			return false;

		//SuperClassDesc ???
		if (!readClassDesc(jsonret["superclass"]))
			return false;

		//更新refs
		updateObjectRef(refindex, TC_PROXYCLASSDESC, jsonret);

		return true;
	}

	//读取class的描述信息
	bool readClassDesc(Json::Value& jsonClassDesc)
	{
		uint8_t t;
		if (!m_bufstream->read_data(t))
			return false;

		if (t == TC_CLASSDESC || t == TC_PROXYCLASSDESC || t == TC_REFERENCE || t == TC_NULL)
			return readContentElement(t, jsonClassDesc);

		return false;
	}

	bool readClassData(const Json::Value& classDesc, Json::Value& jsonret)
	{
		//通过遍历递归的手法  让superclass排到读取的前面去
		if (classDesc["superclass"].isObject() && classDesc["superclass"]["classname"].isString())
		{
			//递归走起
			if (!readClassData(classDesc["superclass"], jsonret["_super"]))
				return false;
		}

		//搞自己的吧
		//仅支持标准TC_CLASSDESC  TC_PROXYCLASSDESC暂无数据没办法测试研究。。。
		assert(classDesc["classname"].isString());
		assert(classDesc["fields"].isArray());
		assert(classDesc["flags"].isInt());
		if (!classDesc["classname"].isString())
		{
			printf("Error:no class name.\n");
			return false;
		}
		if (!classDesc["fields"].isArray())
		{
			printf("Error:no fields.\n");
			return false;
		}
		if (!classDesc["flags"].isInt())
		{
			printf("Error:no flags.\n");
			return false;
		}

		int flags = classDesc["flags"].asInt();
		jsonret["_desc"] = classDesc;

		if (flags & SC_SERIALIZABLE)
		{
			//读取字段数据
			size_t fieldscount = classDesc["fields"].size();
			for (size_t i = 0; i < fieldscount; i++)
			{
				const Json::Value& jsonField = classDesc["fields"][i];
				if (!readFieldValue(jsonField["type"].asInt(), jsonret["_data"][jsonField["name"].asString()]))
					return false;
			}
		}

		bool hasBlockData = false;
		if ((flags & SC_SERIALIZABLE) && (flags & SC_WRITE_METHOD))
			hasBlockData = true;
		if (flags & SC_EXTERNALIZABLE)
		{
			if (flags & SC_BLOCK_DATA)
			{
				hasBlockData = true;
			}
			else
			{
				printf("Unable to parse externalContents for protocol version 1.\n");
				return false;
			}
		}

		if (hasBlockData)
		{
			if (!readClassAnnotation(jsonret["_block"]))
				return false;
		}

		//额外处理几种类型的显示
		//"java.util.HashMap"
		if (classDesc["classname"].asString() == "java.util.HashMap" && jsonret["_block"].isArray())
		{
			jsonret["_hashmap"].resize(0);

			//hashmap 在block里面第0个疑似是hashmap的size()，直接无视，解析内容
			//内容是size；key-value；key-value；key-value；
			size_t blockcount = jsonret["_block"].size();
			if (blockcount % 2) //第一块是size  后面是kv对
			{
				size_t kvcount = blockcount / 2;
				//printf("Hashmap size: %d\n", kvcount);

				for (size_t i = 0; i < kvcount; i++)
				{
					//key
					Json::Value key;
					const Json::Value& keytmp = jsonret["_block"][i * 2 + 1];
					if (keytmp.isObject() && keytmp["_data"].isObject() && !keytmp["_data"]["value"].isNull())
						key = keytmp["_data"]["value"];
					else
						key = keytmp;

					//value
					const Json::Value& valuetmp = jsonret["_block"][i * 2 + 2];
					if (valuetmp.isObject() && valuetmp["_data"].isObject() && !valuetmp["_data"]["value"].isNull())
						jsonret["_hashmap"][i][key.asString()] = valuetmp["_data"]["value"];
					else
						jsonret["_hashmap"][i][key.asString()] = valuetmp;

#ifdef _DEBUG
					//printf("key:%s, value:%s\n", Json2String(key).c_str(), Json2String(jsonret["_hashmap"][i][key.asString()]).c_str());
#endif // _DEBUG
				}
			}
		}

		//java.util.ArrayList
		if (classDesc["classname"].asString() == "java.util.ArrayList" && jsonret["_block"].isArray())
		{
			jsonret["_array"].resize(0);

			//_data里面有一个"size": 1表示的就是size
			//blockdata里面第一个元素应该也是长度，直接无视，读取所有blockdata
			size_t blockcount = jsonret["_block"].size();
			if (blockcount > 1)
			{
				blockcount--; //将第一个元素去掉
				for (size_t i = 0; i < blockcount; i++)
				{
					Json::Value& datatmp = jsonret["_block"][i + 1];
					if (datatmp.isObject() && !datatmp["_data"].isNull())
						jsonret["_array"][i] = datatmp["_data"];
					else
						jsonret["_array"][i] = datatmp;
				}
			}
		}

		//其他的类型待补充
		//...

		return true;
	}

	bool readNewObject(Json::Value& jsonret)
	{
		//printf("TC_OBJECT\n");

		//读取类描述
		Json::Value classDesc;
		if (!readClassDesc(classDesc))
			return false;

		//这中间要让索引值加1
		uint32_t refindex = setObjectRef(TC_OBJECT, jsonret);

		//读取值
		if (!readClassData(classDesc, jsonret))
			return false;

		//更新值
		updateObjectRef(refindex, TC_OBJECT, jsonret);

		return true;
	}

	bool readNewClass(Json::Value& jsonret)
	{
		//printf("TC_CLASS\n");

		Json::Value classDesc;
		if (!readClassDesc(classDesc))
			return false;

		assert(classDesc["classname"].isString());
		if (!classDesc["classname"].isString())
		{
			//printf("Error:no class name.\n");
			return false;
		}

		jsonret["_desc"] = classDesc;

		//增加引用 不知道还能干啥
		m_refIndex++;

		return true;
	}


	bool readNewEnum(Json::Value& jsonret)
	{
		//printf("TC_ENUM\n");

		Json::Value classDesc;
		if (!readClassDesc(classDesc))
			return false;

		assert(classDesc["classname"].isString());
		if (!classDesc["classname"].isString())
		{
			printf("Error:no class name.\n");
			return false;
		}

		//先增加引用
		int refindex = setObjectRef(TC_ENUM, jsonret);

		jsonret["_desc"] = classDesc;

		//enumConstantName ???
		if (!readNewString(jsonret["_enum"]))
			return false;

		//更新引用的值
		updateObjectRef(refindex, TC_ENUM, jsonret);

		return true;
	}

	bool readBlockData(Json::Value& jsonret)
	{
		//printf("TC_BLOCKDATA\n");

		uint8_t len;
		if (!m_bufstream->read_data(len))
			return false;

		if (len)
		{
			std::string block;
			if (!m_bufstream->read_buffer(block, len))
				return false;
			jsonret = tohex(block);
		}
		else
		{
			jsonret = "";
		}

		return true;
	}

	bool readBlockDataLong(Json::Value& jsonret)
	{
		//printf("TC_BLOCKDATALONG\n");

		uint32_t len;
		if (!m_bufstream->read_data(len))
			return false;

		len = _bswap_32(len);
		if (len)
		{
			std::string block;
			if (!m_bufstream->read_buffer(block, len))
				return false;
			jsonret = tohex(block);
		}
		else
		{
			jsonret = "";
		}

		return true;
	}

	bool readContentElement(uint8_t type, Json::Value& jsonret)
	{
		switch (type)
		{
		case TC_OBJECT:
			if (!readNewObject(jsonret))
				return false;
			break;
		case TC_CLASS:
			if (!readNewClass(jsonret))
				return false;
			break;
		case TC_ARRAY:
			if (!readNewArray(jsonret))
				return false;
			break;
		case TC_STRING:
		{
			std::string val;
			if (!readUtf(val))
				return false;
			jsonret = val;

			setObjectRef(TC_STRING, jsonret);
			break;
		}
		case TC_LONGSTRING:
		{
			std::string val;
			if (!readLongUtf(val))
				return false;
			jsonret = val;

			setObjectRef(TC_STRING, jsonret);
			break;
		}
		case TC_ENUM:
			if (!readNewEnum(jsonret))
				return false;
			break;
		case TC_CLASSDESC:
			if (!readNewClassDesc(jsonret))
				return false;
			break;
		case TC_PROXYCLASSDESC:
			if (!readNewProxyClassDesc(jsonret))
				return false;
			break;
		case TC_REFERENCE:
			uint32_t ref;
			if (!readReference(ref))
				return false;
			jsonret = getObjectByRef(ref);
			break;
		case TC_NULL:
			jsonret = NULL;
			break;
			// 	case TC_EXCEPTION:
			// 		printf("TC_EXCEPTION\n");
			// 		break;
			// 	case TC_RESET:
			// 		printf("TC_RESET\n");
			// 		break;
		case TC_BLOCKDATA:
			if (!readBlockData(jsonret))
				return false;
			break;
		case TC_BLOCKDATALONG:
			if (!readBlockDataLong(jsonret))
				return false;
			break;

		default:
			printf("Unknown type - %x\n", type);
			break;
		}

		return true;
	}
	bool readContentElement(Json::Value& jsonret)
	{
		uint8_t t;
		if (!m_bufstream->read_data(t))
			return false;

		return readContentElement(t, jsonret);
	}

	bool JavaSerializationParser(Json::Value& jsonret)
	{
		uint8_t b1, b2;

		//读取文件头
		if (!m_bufstream->read_data(b1))
			return false;
		if (b1 != 0xac)
		{
			switch (b1) {
			case 0x50:
				printf("RMI Call - 0x50 \n");
				break;
			case 0x51:
				printf("RMI ReturnData - 0x51 \n");
				break;
			case 0x52:
				printf("RMI Ping - 0x52 \n");
				break;
			case 0x53:
				printf("RMI PingAck - 0x53 \n");
				break;
			case 0x54:
				printf("RMI DgcAck - 0x54 \n");
				break;
			default:
				printf("Unknown RMI packet type - 0x%x \n" + b1);
				break;
			}

			//不是0xac开头的 再读取一次
			if (!m_bufstream->read_data(b1))
				return false;
		}
		if (!m_bufstream->read_data(b2))
			return false;
		//校验文件头
		printf("STREAM_MAGIC - %x %x\n", b1, b2);
		if (b1 != 0xac || b2 != 0xed)
		{
			printf("Invalid STREAM_MAGIC, should be ac ed \n");
			return false;
		}

		//校验版本
		if (!m_bufstream->read_data(b1))
			return false;
		if (!m_bufstream->read_data(b2))
			return false;
		printf("STREAM_VERSION - %x %x\n", b1, b2);
		if (b1 != 0x00 || b2 != 0x05)
		{
			printf("Invalid STREAM_VERSION, should be 00 05 \n");
			return false;
		}

		//解析内容了
		int index = 0;
		while (true)
		{
			Json::Value value;
			if (!readContentElement(value))
			{
				if (!value.isNull())
				{
					if (index == 0)
						jsonret = value;
					else
						jsonret[index] = value;

					return false;
				}
			}

			if (m_bufstream->eof())
				break;

			//后面还有
			jsonret[index] = value;
			index++;
		}

		return true;
	}
};



/*
//实例1 普通的对象 使用_data
{
	"_data":
	{
		"B_points": 0,
		"account_desc": "E会员",
		"account_level": 5,
		"android_url": "",
		"auth_token": "GgMBu55DmpL8hm7HNRsg",
		"avatar": "https://ugc.bthhotels.com/avatar/images/default_avatar.png!a160",
		"balance": 0,
		"birth": "1995/01/12",
		"btn_text": "",
		"can_update_avatar": false,
		"carbon_points": 0,
		"card_balance": "0",
		"card_code": "",
		"code": "100000138749707",
		"ctf_code": "412702199601028052",
		"ctf_type": "ID",
		"desc": "",
		"down_days_left": 0,
		"down_expire_date": "2023-04-08",
		"email": "",
		"gift_switch": true,
		"growth_value": 0,
		"keep_level_growth_value": 0,
		"keep_level_score": "",
		"level_up_growth_value": 1000,
		"lvl_exp_text": "",
		"name": "张三",
		"new_balance": "0",
		"new_red_packet": "0",
		"next_account_desc": "银会员",
		"next_level_nights": 3,
		"nights": 0,
		"phone": "136****7271",
		"points": 0,
		"red_packet": 0,
		"score_speed_times": 1.0,
		"tags": "[\"SL01\",\"E06\"]",
		"title": "",
		"user_markers": "[]"
	},
	"_desc":
	{
		"annotation": null,
		"classname": "com.ziipin.homeinn.model.UserInfo",
		"fields": [
		{
			"name": "B_points",
			"type": 73
		},
		{
			"name": "account_level",
			"type": 73
		},
		{
			"name": "balance",
			"type": 73
		},
		{
			"name": "can_update_avatar",
			"type": 90
		},
		{
			"name": "carbon_points",
			"type": 73
		},
		{
			"name": "down_days_left",
			"type": 73
		},
		{
			"name": "gift_switch",
			"type": 90
		},
		{
			"name": "growth_value",
			"type": 73
		},
		{
			"name": "keep_level_growth_value",
			"type": 73
		},
		{
			"name": "level_up_growth_value",
			"type": 73
		},
		{
			"name": "next_level_nights",
			"type": 73
		},
		{
			"name": "nights",
			"type": 73
		},
		{
			"name": "points",
			"type": 73
		},
		{
			"name": "red_packet",
			"type": 73
		},
		{
			"name": "score_speed_times",
			"type": 70
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "account_desc",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "android_url",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "auth_token",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "avatar",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "birth",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "btn_text",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "card_balance",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "card_code",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "code",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "ctf_code",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "ctf_type",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "desc",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "down_expire_date",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "email",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "keep_level_score",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "lvl_exp_text",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "name",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "new_balance",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "new_red_packet",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "next_account_desc",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "phone",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "tags",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "title",
			"type": 76
		},
		{
			"classname": "Ljava/lang/String;",
			"name": "user_markers",
			"type": 76
		}],
		"flags": 2,
		"superclass": 0,
		"uid": "fb74abdfc6ffaf03"
	}
}



实例2：hashmap类的解析，看_hashmap字段
{
	"_block": [
		"0000000800000005",
		{
			"_data": {
				"value": 98305
			},
			"_desc": {
				"annotation": null,
				"classname": "java.lang.Integer",
				"fields": [
					{
						"name": "value",
						"type": 73
					}
				],
				"flags": 2,
				"superclass": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				},
				"uid": "12e2a0a4f7818738"
			},
			"_super": {
				"_desc": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				}
			}
		},
		{
			"_data": {
				"value": true
			},
			"_desc": {
				"annotation": null,
				"classname": "java.lang.Boolean",
				"fields": [
					{
						"name": "value",
						"type": 90
					}
				],
				"flags": 2,
				"superclass": 0,
				"uid": "cd207280d59cfaee"
			}
		},
		{
			"_data": {
				"value": 256
			},
			"_desc": {
				"annotation": null,
				"classname": "java.lang.Integer",
				"fields": [
					{
						"name": "value",
						"type": 73
					}
				],
				"flags": 2,
				"superclass": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				},
				"uid": "12e2a0a4f7818738"
			},
			"_super": {
				"_desc": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				}
			}
		},
		"A86880902494769",
		{
			"_data": {
				"value": 259
			},
			"_desc": {
				"annotation": null,
				"classname": "java.lang.Integer",
				"fields": [
					{
						"name": "value",
						"type": 73
					}
				],
				"flags": 2,
				"superclass": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				},
				"uid": "12e2a0a4f7818738"
			},
			"_super": {
				"_desc": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				}
			}
		},
		"OPPOOPPO R7sPlus: fp asimd evtstrm aes pmull sha1 sha2 crc32: AArch64 Processor rev 4 (aarch64): 8: Qualcomm Technologies, Inc MSM8939: null",
		{
			"_data": {
				"value": 94209
			},
			"_desc": {
				"annotation": null,
				"classname": "java.lang.Integer",
				"fields": [
					{
						"name": "value",
						"type": 73
					}
				],
				"flags": 2,
				"superclass": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				},
				"uid": "12e2a0a4f7818738"
			},
			"_super": {
				"_desc": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				}
			}
		},
		{
			"_data": {
				"value": 0
			},
			"_desc": {
				"annotation": null,
				"classname": "java.lang.Integer",
				"fields": [
					{
						"name": "value",
						"type": 73
					}
				],
				"flags": 2,
				"superclass": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				},
				"uid": "12e2a0a4f7818738"
			},
			"_super": {
				"_desc": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				}
			}
		},
		{
			"_data": {
				"value": 258
			},
			"_desc": {
				"annotation": null,
				"classname": "java.lang.Integer",
				"fields": [
					{
						"name": "value",
						"type": 73
					}
				],
				"flags": 2,
				"superclass": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				},
				"uid": "12e2a0a4f7818738"
			},
			"_super": {
				"_desc": {
					"annotation": null,
					"classname": "java.lang.Number",
					"fields": [],
					"flags": 2,
					"superclass": 0,
					"uid": "86ac951d0b94e08b"
				}
			}
		},
		"868809024947694"
	],
	"_data": {
		"loadFactor": 0.75
	},
	"_desc": {
		"annotation": null,
		"classname": "java.util.HashMap",
		"fields": [
			{
				"name": "loadFactor",
				"type": 70
			}
		],
		"flags": 3,
		"superclass": 0,
		"uid": "0507dac1c31660d1"
	},
	"_hashmap": [
		{
			"98305": true
		},
		{
			"256": "A86880902494769"
		},
		{
			"259": "OPPOOPPO R7sPlus: fp asimd evtstrm aes pmull sha1 sha2 crc32: AArch64 Processor rev 4 (aarch64): 8: Qualcomm Technologies, Inc MSM8939: null"
		},
		{
			"94209": 0
		},
		{
			"258": "868809024947694"
		}
	]
}


*/

zlib封装C++类

#pragma once

#include <string>
#include <memory>

#include <zlib.h>

/*
	to (de-)compress deflate format, use wbits = -zlib.MAX_WBITS
	to (de-)compress zlib format, use wbits = zlib.MAX_WBITS,
			gzlib header:
				0x78 0x01 - No Compression/low
				0x78 0x9C - Default Compression
				0x78 0xDA - Best Compression
	to (de-)compress gzip format, use wbits = zlib.MAX_WBITS | 16
			gzip header:0x1F 0x8B
*/
class ZlibHandler
{
public:
	ZlibHandler() : 
		m_nCacheSize (1024 * 1024),
		m_nErrCode(Z_OK),
		m_mode(0)
	{
		m_pCacheBuf = new char[m_nCacheSize];
		m_bFreeCacheBuf = true;
	}
	//使用外部缓冲区
	ZlibHandler(char *cachebuf, size_t cachesize) :
		m_pCacheBuf(cachebuf),
		m_nCacheSize(cachesize),
		m_bFreeCacheBuf(false),
		m_nErrCode(Z_OK),
		m_mode(0) {}
	~ZlibHandler() 
	{
		if (m_mode == 1)
			deflateEnd(&m_zlibStream);
		else if (m_mode == 2)
			inflateEnd(&m_zlibStream);

		m_mode = 0;

		if (m_bFreeCacheBuf)
			delete[] m_pCacheBuf;
	}

	/*
	* 初始化压缩方法
	* 不能同时初始化压缩和解压两个控制器
	* 参数：
		windowBits = MAX_WBITS + 16 //默认是gzip，如果需要是zlib传入MAX_WBITS即可
	*/
	bool InitCompress(int windowBits = MAX_WBITS + 16, int level = Z_DEFAULT_COMPRESSION,
		int method = Z_DEFLATED, int memLevel = 8, int strategy = Z_DEFAULT_STRATEGY)
	{
		if (m_mode != 0)
			return false;

		if (deflateInit2(&m_zlibStream, level, method, windowBits, memLevel, strategy) != Z_OK)
			return false;

		m_windowbits = windowBits;
		m_mode = 1;
		return true;
	}
	/*
	* 销毁压缩控制器
	* 一般情况下不需要主动调用，除非是上一次压缩数据结束了需要再次压缩新数据，先End再次Init（不推荐）
	*/
	void CompressEnd()
	{
		if (m_mode == 1)
		{
			deflateEnd(&m_zlibStream);
			m_mode = 0;
		}
	}
	/*
	* 压缩数据块，可以多次调用
	* 结束的时候，需要调用CompressBlockFinish处理尾部数据
	*/
	inline std::string CompressBlock(const std::string& src)
	{
		return CompressBlock(src.c_str(), src.size());
	}
	/*
	* 压缩数据块，可以多次调用
	* 结束的时候，需要调用CompressBlockFinish处理尾部数据
	*/
	std::string CompressBlock(const void* src, size_t srcLen)
	{
		if (src == NULL || srcLen == 0)
			return {};

		m_zlibStream.next_in = (Bytef*)src;
		m_zlibStream.avail_in = (uint32_t)srcLen;

		std::string ret;
		do {
			m_zlibStream.avail_out = (uint32_t)m_nCacheSize;
			m_zlibStream.next_out = (Bytef*)m_pCacheBuf;
			m_nErrCode = deflate(&m_zlibStream, Z_NO_FLUSH);
			if (m_nErrCode != Z_OK)
				break;
			
			ret.append(m_pCacheBuf, m_nCacheSize - m_zlibStream.avail_out);
		} while (m_zlibStream.avail_out == 0);

		return ret;
	}
	/*
	* 完成压缩数据块
	* 调用CompressBlock压缩数据完毕后，需要调用此方法，返回值也是内容的一部分
	*/
	std::string CompressBlockFinish()
	{
		if (m_nErrCode != Z_OK)
			return {};
		
		std::string ret;
		do {
			m_zlibStream.avail_out = (uint32_t)m_nCacheSize;
			m_zlibStream.next_out = (Bytef*)m_pCacheBuf;
			m_nErrCode = deflate(&m_zlibStream, Z_FINISH);
			if (m_nErrCode != Z_STREAM_END && m_nErrCode != Z_OK)
				break;

			ret.append(m_pCacheBuf, m_nCacheSize - m_zlibStream.avail_out);
		} while (m_zlibStream.avail_out == 0);
		
		return ret;
	}
	/*
	* 压缩数据，一次性传入所有数据，返回压缩后的数据，不需要调用CompressBlockFinish
	*/
	std::string Compress(const std::string& src)
	{
		return Compress(src.c_str(), src.size());
	}
	/*
	* 压缩数据，一次性传入所有数据，返回压缩后的数据，不需要调用CompressBlockFinish
	*/
	std::string Compress(const void* src, size_t srcLen)
	{
		if (src == NULL || srcLen == 0)
			return {};

		std::string ret = CompressBlock(src, srcLen);
		ret += CompressBlockFinish();
		return ret;
	}
	
	
	/*
	* 初始化解压控制器
	* 不能同时初始化压缩和解压两个控制器
	*	windowBits：默认是MAX_WBITS + 32，能自动检测zlib和gzip两种格式。如果是deflate格式，需要传入-MAX_WBITS
	*/
	bool InitDecompress(int windowBits = MAX_WBITS + 32)
	{
		if (m_mode != 0)
			return false;

		if (inflateInit2(&m_zlibStream, windowBits) != Z_OK)
			return false;

		m_windowbits = windowBits;
		m_mode = 2;
		return true;
	}
	/*
	* 销毁解压控制器
	* 一般情况下不需要主动调用，除非是上一次操作结束了需要再次解压新数据，先End再次Init（不推荐）
	*/
	void DecompressEnd()
	{
		if (m_mode == 2)
		{
			inflateEnd(&m_zlibStream);
			m_mode = 0;
		}
	}
	/*
	* 解压数据块，可以多次调用
	*/
	inline std::string Decompress(const std::string& src)
	{
		return Decompress(src.c_str(), src.size());
	}
	/*
	* 解压数据块，可以多次调用
	*/
	std::string Decompress(const void* src, size_t srcLen)
	{
		if (src == NULL || srcLen == 0)
			return {};

		m_zlibStream.next_in = (Bytef*)src;
		m_zlibStream.avail_in = (uint32_t)srcLen;

		std::string ret;
		do {
			m_zlibStream.avail_out = (uint32_t)m_nCacheSize;
			m_zlibStream.next_out = (Bytef*)m_pCacheBuf;

			m_nErrCode = inflate(&m_zlibStream, Z_NO_FLUSH);
			if (m_nErrCode != Z_STREAM_END && m_nErrCode != Z_OK)
				break;

			ret.append(m_pCacheBuf, m_nCacheSize - m_zlibStream.avail_out);
		} while (m_zlibStream.avail_out == 0);

		return ret;
	}

private:
	z_stream m_zlibStream{};
	char *m_pCacheBuf{};
	size_t m_nCacheSize;
	bool m_bFreeCacheBuf{};
	int m_nErrCode{};
	int m_windowbits{};
	int m_mode; //1-加密；2-解密
};

/*
void zlibhandlertest()
{
	std::string str = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
	for (int i = 0; i < 1024 * 1024; i++)
	{
		str.append(std::to_string(i));
	}
	char* pstr = strdup(str.c_str());
	char* pstr2 = strdup(str.c_str());

	ZlibHandler z1;
	z1.InitCompress(-MAX_WBITS);
	std::string compress1 = z1.Compress(str.c_str(), str.length());
	ZlibHandler z2;
	z2.InitCompress(-MAX_WBITS);
	std::string compress2_1 = z2.CompressBlock(pstr, str.length());
	free(pstr);
	std::string compress2_2 = z2.CompressBlock(pstr2, str.length());
	free(pstr2);
	std::string compress2_3 = z2.CompressBlockFinish();

	ZlibHandler de1;
	de1.InitDecompress(-MAX_WBITS);
	std::string decompress1 = de1.Decompress(compress1.c_str(), compress1.length());
	if (decompress1 == str)
		printf("check ok!\n");
	ZlibHandler de2;
	de2.InitDecompress(-MAX_WBITS);
	std::string decompress2 = de2.Decompress(compress2_1 + compress2_2 + compress2_3);
	if (decompress2 == str + str)
		printf("check ok!\n");

	ZlibHandler de3;
	de3.InitDecompress(-MAX_WBITS);
	std::string decompress3 = de3.Decompress(compress2_1);
	decompress3 += de3.Decompress(compress2_2);
	decompress3 += de3.Decompress(compress2_3);
	if (decompress3 == str + str)
		printf("check ok!\n");
}
*/

ECDH算法封装，基于openssl。

#pragma once

#include <string>

#include <openssl/ec.h>
#include <openssl/ecdh.h>
#include <openssl/evp.h>


class ECDHEncoder
{
private:
	EC_KEY* m_ecKey{ nullptr };
	EC_KEY* m_ecPeerPubKey{ nullptr };

public:
	ECDHEncoder() {};
	~ECDHEncoder() {
		if (m_ecKey)
			EC_KEY_free(m_ecKey);
		if (m_ecPeerPubKey)
			EC_KEY_free(m_ecPeerPubKey);
	};

	bool GenerateKey(int nid)
	{
		m_ecKey = EC_KEY_new_by_curve_name(nid);
		if (m_ecKey == nullptr)
			return false;

		if (1 != EC_KEY_generate_key(m_ecKey))
		{
			EC_KEY_free(m_ecKey);
			m_ecKey = nullptr;
			return false;
		}

		return true;
	}

	std::string GetMyEncodedPoint(point_conversion_form_t type = POINT_CONVERSION_UNCOMPRESSED)
	{
		const EC_GROUP* group = EC_KEY_get0_group(m_ecKey);
		const EC_POINT* pubKey = EC_KEY_get0_public_key(m_ecKey);

		size_t field_len = EC_GROUP_get_degree(group);
		size_t byte_len = (field_len + 7) / 8;

		unsigned char* point_data = (unsigned char*)malloc(byte_len * 2 + 1);
		if (!point_data)
			return {};

		size_t point_data_len = EC_POINT_point2oct(group, pubKey, type, point_data, byte_len * 2 + 1, nullptr);
		if (0 == point_data_len)
		{
			free(point_data);
			return {};
		}

		std::string strPointData((char*)point_data, point_data_len);
		free(point_data);

		return strPointData;
	}

	std::string GetMyPublicKey()
	{
		BIO* out = BIO_new(BIO_s_mem());
		i2d_EC_PUBKEY_bio(out, m_ecKey);

		char* p;
		long length = BIO_get_mem_data(out, &p);
		std::string strECPubKey(p, length);
		BIO_free_all(out);

		return strECPubKey;
	}

	bool SetPeerPublicKey(const std::string& strPeerPublicKey)
	{
		if (m_ecPeerPubKey)
		{
			EC_KEY_free(m_ecPeerPubKey);
			m_ecPeerPubKey = nullptr;
		}

		const unsigned char* szBuf = (unsigned char*)strPeerPublicKey.c_str();
		m_ecPeerPubKey = d2i_EC_PUBKEY(nullptr, &szBuf, (long)strPeerPublicKey.size());
		if (m_ecPeerPubKey == nullptr)
			return false;

		return true;
	}

	bool SetPeerEncodedPoint(const std::string& strPointData)
	{
		if (m_ecPeerPubKey)
		{
			EC_KEY_free(m_ecPeerPubKey);
			m_ecPeerPubKey = nullptr;
		}

		const EC_GROUP* group = EC_KEY_get0_group(m_ecKey);
		EC_POINT* peerPubKey = EC_POINT_new(group);
		if (peerPubKey == nullptr)
			return false;

		const unsigned char* p = (const unsigned char*)strPointData.c_str();
		if (0 == EC_POINT_oct2point(group, peerPubKey, p, strPointData.size(), nullptr))
		{
			EC_POINT_free(peerPubKey);
			return false;
		}

		m_ecPeerPubKey = EC_KEY_new_by_curve_name(EC_GROUP_get_curve_name(group));
		if (m_ecPeerPubKey == nullptr)
		{
			EC_POINT_free(peerPubKey);
			return false;
		}

		if (1 != EC_KEY_set_public_key(m_ecPeerPubKey, peerPubKey))
		{
			EC_POINT_free(peerPubKey);
			EC_KEY_free(m_ecPeerPubKey);
			m_ecPeerPubKey = nullptr;
			return false;
		}

		EC_POINT_free(peerPubKey);

		return true;
	}

	std::string ComputeSecretKey()
	{
		if (m_ecPeerPubKey == nullptr)
			return {};

		int field_size = EC_GROUP_get_degree(EC_KEY_get0_group(m_ecKey));
		size_t secret_len = (field_size + 7) / 8;
		unsigned char* secret = new unsigned char[secret_len];
		if (secret == nullptr)
			return {};

		secret_len = ECDH_compute_key(secret, secret_len, EC_KEY_get0_public_key(m_ecPeerPubKey), m_ecKey, nullptr);
		if (secret_len == 0)
		{
			delete[] secret;
			return {};
		}
		std::string strSecretKey((const char*)secret, secret_len);
		delete[] secret;

		return strSecretKey;
	}
};

openssl使用rsa加解密，C++封装，支持设置公钥、私钥，公钥加解密，私钥加解密。

使用方法很简单:

CRSAEncoder mRSAEncoderPC;
//设置公钥
mRSAEncoderPC.SetPublicKey("-----BEGIN PUBLIC KEY-----\nMIGfMA0GCSqGSIb3DQE..........XApYoMnPE3g4xU4NceOBTFZtR5fp+w/MswIDAQAB\n-----END PUBLIC KEY-----");
//公钥解密
std::string strTest = mRSAEncoderPC.PublicDecrypt("......");
//公钥加密
strTest = mRSAEncoderPC.PublicEncrypt("......");




//另外一种
unsigned char d[] = {
	0x38, 0x60, 0x63, 0x56, 0xBC, 0x54, 0x52, 0xBC, 0xA6, 0xB6, 0xDB, 0x47, 0x49, 0x08, 0xE5, 0xB8,
	0x0B, 0xAA, 0x44, 0xEC, 0x49, 0x2B, 0x35, 0x5F, 0xBB, 0x1A, 0xB2, 0x29, 0x2D, 0x0F, 0x2D, 0xE2,
	0x93, 0x70, 0x4D, 0x8F, 0x6F, 0x01, 0x64, 0xE4, 0xC9, 0x0C, 0x03, 0x4C, 0x02, 0x08, 0xE6, 0xB7,
	0xAF, 0xBB, 0x8A, 0x0A, 0xFF, 0x84, 0xB4, 0xBA, 0x9E, 0x4B, 0x1A, 0xB2, 0x0A, 0x75, 0xDA, 0xFD,
	0x0E, 0xBE, 0x73, 0xCA, 0x5C, 0xFC, 0xA2, 0x4D, 0xCF, 0x56, 0xA8, 0xAD, 0x9D, 0xC3, 0x60, 0x86,
	0xF5, 0xA8, 0xA0, 0xD0, 0xCD, 0x7E, 0x21, 0x8A, 0xCE, 0x4C, 0xCD, 0x03, 0xDE, 0x76, 0xF6, 0xA5,
	0x95, 0xA9, 0x77, 0x77, 0xFF, 0xF9, 0xBA, 0x3B, 0x0F, 0xD9, 0xFF, 0x50, 0x63, 0x6E, 0xDD, 0x49,
	0xFA, 0x31, 0x7D, 0xE0, 0xC5, 0x81, 0xC5, 0x75, 0x79, 0xCE, 0x1C, 0x78, 0x1A, 0x94, 0xD6, 0x7A,
	0xA1, 0xFD, 0x24, 0x9F, 0x11, 0x3A, 0x1D, 0xED, 0xF4, 0x5C, 0x9E, 0x03, 0x7B, 0x8D, 0xFF, 0xB7,
	0x04, 0xC4, 0x86, 0x24, 0x3D, 0xD2, 0x9F, 0xAB, 0xB6, 0x2B, 0x09, 0x55, 0x97, 0x66, 0x7B, 0xAA,
	0xF5, 0x0E, 0x25, 0xA0, 0x82, 0x4B, 0x02, 0x70, 0x84, 0xCB, 0x5F, 0xA1, 0x55, 0xBB, 0x63, 0x56,
	0xC3, 0x76, 0xB8, 0xFB, 0x5D, 0x38, 0x62, 0xF0, 0x10, 0xD6, 0x03, 0x0C, 0x6A, 0xC3, 0x53, 0xE9,
	0x55, 0xA2, 0x9D, 0x2B, 0x79, 0x05, 0x21, 0xFF, 0x70, 0x8A, 0x2F, 0xE3, 0x4C, 0xF7, 0x3D, 0x90,
	0x95, 0xB9, 0x3C, 0x53, 0x61, 0xC7, 0xB8, 0x72, 0x91, 0xB5, 0x3D, 0x7F, 0x57, 0x8D, 0x4C, 0xCB,
	0xF3, 0x93, 0x2C, 0x14, 0x13, 0xF6, 0x50, 0xDD, 0x3F, 0x70, 0xDE, 0x7E, 0x26, 0x34, 0xF4, 0xCA,
	0x69, 0xBF, 0xAF, 0x10, 0xE8, 0xD3, 0xDD, 0xEA, 0x95, 0x22, 0x22, 0xA3, 0x06, 0x73, 0x0E, 0xC1
};


unsigned char n[] = {
	0xCA, 0x76, 0x88, 0xB4, 0xCA, 0x54, 0x3D, 0x75, 0x00, 0x50, 0xD4, 0x87, 0x59, 0x1F, 0x9D, 0xB4,
	0x2E, 0xE2, 0xF4, 0xB7, 0x11, 0xA0, 0x55, 0xE4, 0xC3, 0x96, 0x30, 0x73, 0x94, 0xC6, 0x10, 0x19,
	0xD4, 0x94, 0xC4, 0xC8, 0x8D, 0xFA, 0x05, 0xC8, 0x39, 0x22, 0x46, 0x8F, 0xDD, 0x0D, 0xF7, 0xF4,
	0xC1, 0x77, 0x31, 0xB5, 0x96, 0xA4, 0xF2, 0x57, 0x53, 0x5D, 0x91, 0x55, 0x76, 0x36, 0xC2, 0x1B,
	0x44, 0x5A, 0x35, 0x67, 0x13, 0x6A, 0x39, 0xB0, 0xA6, 0xD4, 0x5B, 0xCD, 0xDE, 0x99, 0x4D, 0xCA,
	0x78, 0x9B, 0xBF, 0x52, 0x79, 0xD5, 0x6C, 0xCD, 0x33, 0xA9, 0x04, 0x09, 0x15, 0x3C, 0x7D, 0xB3,
	0x36, 0xD2, 0xA2, 0x7E, 0xAA, 0xA2, 0x81, 0x52, 0x9C, 0xEF, 0x15, 0x98, 0x42, 0x17, 0x19, 0xB9,
	0xB6, 0x2D, 0x24, 0xC5, 0x82, 0x08, 0xE1, 0x1D, 0x0A, 0xC0, 0xF9, 0xAD, 0x22, 0xE6, 0xB8, 0xDC,
	0xDA, 0x8B, 0xCE, 0x06, 0x71, 0x9D, 0x64, 0x14, 0xEF, 0xD3, 0x26, 0x7F, 0x76, 0xB2, 0x87, 0xF3,
	0x0D, 0x75, 0x5C, 0x57, 0x02, 0xBE, 0xA4, 0x18, 0xFB, 0x76, 0xED, 0xEF, 0xCA, 0x60, 0x83, 0xBE,
	0xE3, 0xC0, 0x42, 0x70, 0x56, 0x05, 0xDB, 0x5D, 0xCA, 0xF5, 0xE6, 0xF6, 0xA2, 0x91, 0xFD, 0x53,
	0x03, 0xA9, 0x86, 0x39, 0x0B, 0xB8, 0xC4, 0x25, 0x1D, 0x31, 0x55, 0x05, 0xFC, 0x8A, 0xB4, 0x3E,
	0x01, 0x58, 0x3C, 0x6D, 0x2D, 0x5D, 0xE1, 0x0D, 0xE1, 0x7A, 0x0E, 0xD9, 0x6D, 0x08, 0x8D, 0xDE,
	0xDD, 0x93, 0xA3, 0x2E, 0xA4, 0xE2, 0xC7, 0xAE, 0xC7, 0xC5, 0x83, 0xC4, 0xE1, 0x4D, 0xFC, 0x67,
	0x92, 0x75, 0x99, 0xF4, 0x3A, 0x5F, 0x98, 0xE7, 0x21, 0xD9, 0x15, 0x14, 0xFC, 0x45, 0x34, 0x04,
	0x6D, 0xD1, 0x6E, 0xF7, 0x2D, 0x96, 0xB3, 0xD3, 0xAE, 0x43, 0xC3, 0x4D, 0x26, 0x23, 0x5E, 0x7F
};

unsigned char e[] = { 0x01, 0x00, 0x01 };

CRSAEncoder mRSAEncoder;
//设置私钥
mRSAEncoder.SetPrivateKey(n, sizeof(n), e, sizeof(e), d, sizeof(d));
//设置私钥另外一个姿势也可以的
//mRSAEncoder.SetPrivateKey("-----BEGIN PRIVATE KEY-----\nMIICeAIBA..............DANBQltd+11\n-----END PRIVATE KEY-----");
//私钥加密
FString strEnBuf = mRSAEncoder.PrivateEncrypt("......");
//私钥解密
strEnBuf = mRSAEncoder.PrivateDecrypt("......");

RSAEncoder.h（header only）:

#pragma once

#include <string>
#include <memory>

#include <openssl/rsa.h>
#include <openssl/pem.h>
#include <openssl/err.h>

class CRSAEncoder
{
public:

	CRSAEncoder(void)
	{
		m_pRSAPrivate = NULL;
		m_pRSAPublic = NULL;

		m_nPaddingType = RSA_PKCS1_PADDING;
		m_nPaddingLen = RSA_PKCS1_PADDING_SIZE;
	}

	~CRSAEncoder(void)
	{
		if (m_pRSAPrivate)
			RSA_free(m_pRSAPrivate);
		if (m_pRSAPublic)
			RSA_free(m_pRSAPublic);
	}

	//设置padding类型，缺省为RSA_PKCS1_PADDING
	void SetPaddingType(int nPadding)
	{
		m_nPaddingType = nPadding;
	}

	//设置padding长度，缺省为RSA_PKCS1_PADDING_SIZE
	void SetPaddingLength(int nPaddingLen)
	{
		m_nPaddingLen = nPaddingLen;
	}

	//设置公钥，-----BEGIN PUBLIC KEY-----...-----END PUBLIC KEY-----
	bool SetPublicKey(const char* szKeyData)
	{
		if (m_pRSAPublic)
		{
			RSA_free(m_pRSAPublic);
			m_pRSAPublic = NULL;
		}

		BIO* pKEY = NULL;
		try
		{
			pKEY = _GetBIOFromKeyString(szKeyData);
			if (pKEY == NULL)
				throw ERR_get_error();

			m_pRSAPublic = PEM_read_bio_RSA_PUBKEY(pKEY, NULL, NULL, NULL);

			BIO_free_all(pKEY);

			if (m_pRSAPublic == NULL)
				throw ERR_get_error();
		}
		catch (unsigned long e)
		{
			printf("rsa set public key err %d.\n", e);
			return false;
		}

		return true;
	}
	//设置公钥，n,e，n和e为原始内存数据
	void SetPublicKey(const void* n, int nlen, const void* e, int elen)
	{
		if (m_pRSAPublic)
			RSA_free(m_pRSAPublic);

		m_pRSAPublic = RSA_new();
		BIGNUM* bn = BN_new();
		BIGNUM* be = BN_new();
		BN_bin2bn((const unsigned char*)n, nlen, bn);
		BN_bin2bn((const unsigned char*)e, elen, be);
		RSA_set0_key(m_pRSAPublic, bn, be, NULL);
	}
	void SetPublicKey(const std::string& n, const std::string& e)
	{
		SetPublicKey(n.c_str(), (int)n.length(), e.c_str(), (int)e.length());
	}
	//设置私钥，-----BEGIN PRIVATE KEY-----...-----END PRIVATE KEY-----
	bool SetPrivateKey(const char* szKeyData)
	{
		if (m_pRSAPrivate)
		{
			RSA_free(m_pRSAPrivate);
			m_pRSAPrivate = NULL;
		}

		BIO* pKEY = NULL;
		try
		{
			pKEY = _GetBIOFromKeyString(szKeyData);
			if (pKEY == NULL)
				throw ERR_get_error();

			m_pRSAPrivate = PEM_read_bio_RSAPrivateKey(pKEY, NULL, NULL, NULL);

			BIO_free_all(pKEY);

			if (m_pRSAPrivate == NULL)
				throw ERR_get_error();
		}
		catch (unsigned long e)
		{
			printf("rsa set private key err %d.\n", e);
			return false;
		}

		return true;
	}
	//设置私钥，n,e,d
	void SetPrivateKey(const void* n, int nlen, const void* e, int elen, const void* d, int dlen)
	{
		if (m_pRSAPrivate)
			RSA_free(m_pRSAPrivate);

		m_pRSAPrivate = RSA_new();
		BIGNUM* bn = BN_new();
		BIGNUM* be = BN_new();
		BIGNUM* bd = BN_new();
		BN_bin2bn((const unsigned char*)n, nlen, bn);
		BN_bin2bn((const unsigned char*)e, elen, be);
		BN_bin2bn((const unsigned char*)d, dlen, bd);
		RSA_set0_key(m_pRSAPrivate, bn, be, bd);
	}
	void SetPrivateKey(const std::string& n, const std::string& e, const std::string& d)
	{
		SetPrivateKey(n.c_str(), (int)n.length(), e.c_str(), (int)e.length(), d.c_str(), (int)d.length());
	}

	
	//私钥加密
	std::string PrivateEncrypt(const void* data, int data_len)
	{
		std::string strRet;
		if (m_pRSAPrivate == NULL)
		{
			printf("private key is empyt.\n");
			return strRet;
		}

		int nRsaLen = 0;
		int nBlockLen = 0;
		int nBlockCount = 0;
		int nPartResult = 0;
		try
		{
			nRsaLen = RSA_size(m_pRSAPrivate);
			if (nRsaLen <= 0)
				throw ERR_get_error();
			nBlockLen = nRsaLen - m_nPaddingLen;

			nBlockCount = data_len / nBlockLen;
			if (data_len % nBlockLen)
				nBlockCount++;

			//分块加密
			std::unique_ptr <unsigned char[]> buff(new unsigned char[nRsaLen]);
			for (int i = 0; i < nBlockCount; i++)
			{
				int nDatalen = (std::min)(nBlockLen, data_len - (i * nBlockLen));
				nPartResult = RSA_private_encrypt(nDatalen, (unsigned char*)data + (i * nBlockLen), buff.get(), m_pRSAPrivate, m_nPaddingType);
				if (nPartResult < 0)
					throw ERR_get_error();

				strRet.append((char*)buff.get(), nPartResult);
			}
		}
		catch (unsigned long e)
		{
			printf("rsa private encrypt err %d.\n", e);
			strRet.clear();
		}

		return strRet;
	}
	std::string PrivateEncrypt(const std::string& strData)
	{
		return PrivateEncrypt(strData.c_str(), (int)strData.length());
	}

	//公钥加密
	std::string PublicEncrypt(const void* data, int data_len)
	{
		std::string strRet;
		if (m_pRSAPublic == NULL)
		{
			printf("public key is empyt.\n");
			return strRet;
		}

		int nRsaLen = 0;
		int nBlockLen = 0;
		int nBlockCount = 0;
		int nPartResult = 0;
		try
		{
			nRsaLen = RSA_size(m_pRSAPublic);
			if (nRsaLen <= 0)
				throw ERR_get_error();
			nBlockLen = nRsaLen - m_nPaddingLen;

			nBlockCount = data_len / nBlockLen;
			if (data_len % nBlockLen)
				nBlockCount++;

			//分块加密
			std::unique_ptr <unsigned char[]> buff(new unsigned char[nRsaLen]);
			for (int i = 0; i < nBlockCount; i++)
			{
				int nDatalen = (std::min)(nBlockLen, data_len - (i * nBlockLen));
				nPartResult = RSA_public_encrypt(nDatalen, (unsigned char*)data + (i * nBlockLen), buff.get(), m_pRSAPublic, m_nPaddingType);
				if (nPartResult < 0)
					throw ERR_get_error();

				strRet.append((char*)buff.get(), nPartResult);
			}
		}
		catch (unsigned long e)
		{
			printf("rsa public encrypt err %d.\n", e);
			strRet.clear();
		}

		return strRet;
	}
	std::string PublicEncrypt(const std::string& strData)
	{
		return PublicEncrypt(strData.c_str(), (int)strData.length());
	}


	//私钥解密
	std::string PrivateDecrypt(const void* data, int data_len)
	{
		std::string strRet;
		if (m_pRSAPrivate == NULL)
		{
			printf("private key is empyt.\n");
			return strRet;
		}

		int nRsaLen = 0;
		int nBlockCount = 0;
		int nPartResult = 0;
		try
		{
			nRsaLen = RSA_size(m_pRSAPrivate);
			if (nRsaLen <= 0)
				throw ERR_get_error();

			if (data_len % nRsaLen)
				throw 0;
			nBlockCount = data_len / nRsaLen;


			//分块解密
			std::unique_ptr <unsigned char[]> buff(new unsigned char[nRsaLen]);
			for (int i = 0; i < nBlockCount; i++)
			{
				//
				nPartResult = RSA_private_decrypt(nRsaLen, (unsigned char*)data + (i * nRsaLen), buff.get(), m_pRSAPrivate, m_nPaddingType);
				if (nPartResult < 0)
					throw ERR_get_error();

				strRet.append((char*)buff.get(), nPartResult);
			}
		}
		catch (unsigned long e)
		{
			char errbuf[256];
			printf("rsa private decrypt err %s(%d).\n", ERR_error_string(e, errbuf), e);
			strRet.clear();
		}

		return strRet;
	}
	std::string PrivateDecrypt(const std::string& strData)
	{
		return PrivateDecrypt(strData.c_str(), (int)strData.length());
	}

	//公钥解密
	std::string PublicDecrypt(const void* data, int data_len)
	{
		std::string strRet;
		if (m_pRSAPublic == NULL)
		{
			printf("public key is empyt.\n");
			return strRet;
		}

		int nRsaLen = 0;
		int nBlockCount = 0;
		int nPartResult = 0;
		try
		{
			nRsaLen = RSA_size(m_pRSAPublic);
			if (nRsaLen <= 0)
				throw ERR_get_error();

			if (data_len % nRsaLen)
				throw 0;
			nBlockCount = data_len / nRsaLen;


			//分块解密
			std::unique_ptr <unsigned char[]> buff(new unsigned char[nRsaLen]);
			for (int i = 0; i < nBlockCount; i++)
			{
				//
				nPartResult = RSA_public_decrypt(nRsaLen, (unsigned char*)data + (i * nRsaLen), buff.get(), m_pRSAPublic, m_nPaddingType);
				if (nPartResult < 0)
					throw ERR_get_error();

				strRet.append((char*)buff.get(), nPartResult);
			}
		}
		catch (unsigned long e)
		{
			printf("rsa public decrypt err %d.\n", e);
			strRet.clear();
		}

		return strRet;
	}
	std::string PublicDecrypt(const std::string& strData)
	{
		return PublicDecrypt(strData.c_str(), (int)strData.length());
	}

protected:
	RSA *m_pRSAPrivate;
	RSA *m_pRSAPublic;
	int m_nPaddingType;
	int m_nPaddingLen;

	BIO* _GetBIOFromKeyString(const std::string strKey)
	{
		BIO* pKEY = NULL;
		try
		{
			pKEY = BIO_new(BIO_s_mem());
			if (pKEY == NULL)
				throw ERR_get_error();

			int nResult = BIO_write(pKEY, strKey.c_str(), (int)strKey.length());
			if (nResult <= 0)
				throw ERR_get_error();
		}
		catch (unsigned long e)
		{
			printf("rsa bio key err %d.\n", e);
			if (pKEY)
				BIO_free_all(pKEY);

			return NULL;
		}

		return pKEY;
	}
};

！

苹果配置中大量用到了plist，使用开源的C语言的库libplist可以读取解析，但是纯C的写起来非常蛋疼。

于是用C++封装了一下(c++ wrapper)，但是plist的本质还是xml，读取起来还是略有繁琐，于是转为json结构，就可以直接使用了（依赖jsoncpp库）。

plist内部是有PLIST_UID、PLIST_DICT、PLIST_ARRAY等复杂的结构，支持xml和binary(bplist)两种格式，支持uid自动解析处理关联，支持NS.objects、NS.keys、NSDictionary、NSArray、NSMutableDictionary、NSMutableArray等结构自动处理，使用起来就非常方便了。

header only引用：plistObject.h

#pragma once

#include <json/json.h>
#include <plist/plist.h>

#include "base64.h"

//屏蔽掉调试输出
//#define _bplist_printf(a,...) printf(a, ##__VA_ARGS__)
#define _bplist_printf(a,...) 

//#define plist_to_bin_free(p) plist_mem_free(p)
//#define plist_to_xml_free(p) plist_mem_free(p)

class CPlistObject : public Json::Value
{
public:
	template <class T>
	static Json::Value Plist2Json(const T& filepath, bool bConvertDataPlist = false)
	{
		CPlistObject plist(bConvertDataPlist);
		if (plist.OpenPlistFile(filepath))
			return std::move(plist);

		return {};
	}
	static Json::Value PlistBuf2Json(const std::string& buf, bool bConvertDataPlist = false)
	{
		CPlistObject plist(bConvertDataPlist);
		if (plist.OpenPlistBuf(buf))
			return std::move(plist);

		return {};
	}

	CPlistObject(bool bConvertDataPlist = false)
	{
		m_plistMain = nullptr;
		m_pObjectArray = nullptr;
		m_bConvertDataPlist = bConvertDataPlist;
	}

	~CPlistObject()
	{
		Close();
	}

	void Close()
	{
		if (m_plistMain)
		{
			plist_free(m_plistMain);
			m_plistMain = nullptr;
		}

		this->clear();
	}

	//打开plist内存缓冲区
	bool OpenPlistBuf(const void* lpBuffer, size_t nBufLen)
	{
		Close();

		if (memcmp(lpBuffer, "bplist00", 8) == 0)
			plist_from_bin((const char*)lpBuffer, (uint32_t)nBufLen, &m_plistMain);
		else //if (memcmp(lpBuffer, "<?xml", 5) == 0)
			plist_from_xml((const char*)lpBuffer, (uint32_t)nBufLen, &m_plistMain);

		if (!m_plistMain)
			return false;

		if (!_ConvertPlistObject(*this))
			return false;

		return true;
	}
	bool OpenPlistBuf(const std::string& buf)
	{
		return OpenPlistBuf(buf.c_str(), buf.length());
	}
	//打开plist文件
	template <class T>
	bool OpenPlistFile(const T& filepath)
	{
		Close();

		std::ifstream ifs(filepath, std::ios::binary);
		if (!ifs.is_open())
			return false;

		unsigned char header[4] = { 0 };
		ifs.read((char*)header, 3);
		//兼容win utf8 bom 0xEFBBBF
		if (header[0] == 0xEF && header[1] == 0xBB && header[2] == 0xBF)
		{
			//貌似不需要处理啥
		}
		else
		{
			//指针回到开头
			ifs.seekg(0, std::ios::beg);
		}

		//读取文件内容
		std::ostringstream sstr;
		sstr << ifs.rdbuf();
		std::string buf = sstr.str();

		//读文件失败了
		if (buf.empty())
			return false;

		return OpenPlistBuf(buf.c_str(), buf.length());
	}

	//转换plist为json
// 	bool ConvertPlistObject(bool bConvertDataPlist = false) 
// 	{
// 		if (bConvertDataPlist)
// 		return _ConvertPlistObject(m_jsonValues);
// 	}


private:

	bool _ConvertPlistObject(Json::Value& jsonObject)
	{
		m_pObjectArray = plist_dict_get_item(m_plistMain, "$objects");
		plist_t pTop = plist_dict_get_item(m_plistMain, "$top");
		if (m_pObjectArray && plist_get_node_type(m_pObjectArray) == PLIST_ARRAY ||
			pTop && plist_get_node_type(pTop) == PLIST_DICT)
		{
			//modify by fenlog 2026.02.23 直接将$top指向的数据作为json的根节点了，如果数据是array那么这么附加会出问题
			//这两个数据不重要，直接无视了
// 			plist_t pVersionNode = plist_dict_get_item(m_plistMain, "$version");
// 			if (pVersionNode)
// 				SetValue(pVersionNode, jsonObject["$version"]);
// 			plist_t pArchiverNode = plist_dict_get_item(m_plistMain, "$archiver");
// 			if (pArchiverNode)
// 				SetValue(pArchiverNode, jsonObject["$archiver"]);

			//获取root节点
			plist_t pRoot = plist_dict_get_item(pTop, "root");
			if (pRoot)
			{
				int nRootType = plist_get_node_type(pRoot);
				//几乎所有的plist文件都是通过uid引用的
				if (nRootType == PLIST_UID)
				{
					plist_t pRootObj = GetNodeByUidDict(pRoot);
					if (pRootObj)
					{
						ConvertDict(pRootObj, jsonObject);
						return (!jsonObject.isNull());
					}
				}
				else if (nRootType == PLIST_DICT)
				{
					ConvertDict(pRoot, jsonObject);
					return (!jsonObject.isNull());
				}
			}
			else
			{
				//有些没有root节点 直接是字典
				ConvertDict(pTop, jsonObject);

				return (!jsonObject.isNull());
			}
		}

		int nType = plist_get_node_type(m_plistMain);
		if (nType == PLIST_DICT)
		{
			EnumDictKeyValueDefault(m_plistMain, jsonObject);
		}
		else if (nType == PLIST_ARRAY)
		{
			EnumArray(m_plistMain, jsonObject);
		}
		else
		{
			SetValue(m_plistMain, jsonObject);
		}

		return (!jsonObject.isNull());
	}

	plist_t GetNodeByUidDict(plist_t pDict) const
	{
		if (!pDict)
			return nullptr;

		plist_type nType = plist_get_node_type(pDict);
		//如果类型不是UID的 直接就返回原元素指针
		if (nType != PLIST_UID)
			return pDict;

		plist_t pRet = nullptr;

		uint64_t val = 0;
		plist_get_uid_val(pDict, &val);
		pRet = plist_array_get_item(m_pObjectArray, (uint32_t)val);

		return pRet;
	}

	std::string GetDictClassName(plist_t pDict)
	{
		std::string strRet;
		plist_t pClassName = GetNodeByUidDict(pDict);
		if (pClassName)
		{
			if (plist_get_node_type(pClassName) == PLIST_DICT)
			{
				plist_t pName = plist_dict_get_item(pClassName, "$classname");
				if (pName)
				{
					uint64_t sLen = 0;
					const char* pszName = plist_get_string_ptr(pName, &sLen);
					if (pszName)
						strRet = pszName;
				}
			}
		}

		return strRet;
	}

	void SetValue(plist_t pValue, Json::Value& jsonValue) const
	{
		int nType = plist_get_node_type(pValue);
		if (nType == PLIST_STRING)
		{
			uint64_t sLen = 0;
			const char* pszValue = plist_get_string_ptr(pValue, &sLen);
			if (pszValue)
			{
				_bplist_printf("val(str):%s \n", pszValue);
				jsonValue = pszValue;
			}
		}
		else if (nType == PLIST_UINT)
		{
			uint64_t nValue = 0;
			plist_get_uint_val(pValue, (uint64_t*)&nValue);
			_bplist_printf("val(uint):%llu \n", nValue);
			jsonValue = nValue;
		}
		else if (nType == PLIST_BOOLEAN)
		{
			uint8_t nValue = 0;
			plist_get_bool_val(pValue, &nValue);
			_bplist_printf("val(bool):%d \n", nValue);
			jsonValue = nValue;
		}
		else if (nType == PLIST_DATA)
		{
			uint64_t nDataLen = 0;
			const char* pszValue = plist_get_data_ptr(pValue, &nDataLen);

			std::string strValue;
			if (nDataLen > 0)
			{
				//add by fenlog 2019.11.07 转义data中的plist
				if (m_bConvertDataPlist && nDataLen > 16 && (memcmp(pszValue, "bplist00", 8) == 0 || memcmp(pszValue, "<?xml", 5) == 0))
				{
					CPlistObject mSubPlist(true);
					if (mSubPlist.OpenPlistBuf(pszValue, (size_t)nDataLen))
					{
						jsonValue = mSubPlist;
						return;
					}
				}

				strValue = base64_encode((const unsigned char*)pszValue, (size_t)nDataLen);
			}

			_bplist_printf("val(data):%s \n", strValue.c_str());
			jsonValue = strValue;
		}
		else if (nType == PLIST_REAL)
		{
			double nValue;
			plist_get_real_val(pValue, &nValue);
			_bplist_printf("val(real):%lf \n", nValue);
			jsonValue = nValue;
		}
		else if (nType == PLIST_DATE)
		{
			int32_t nSec, nMSec;
			plist_get_date_val(pValue, &nSec, &nMSec);
			uint32_t dwSec = nSec + 978278400; //Represents the number of seconds since 01/01/2001
			jsonValue = dwSec;
		}
		else
		{
			_bplist_printf("val(%d) \n", nType);
		}
	}

	inline bool CheckItemType(plist_t pNode, plist_type nType)
	{
		if (pNode && plist_get_node_type(pNode) == nType)
			return true;

		return false;
	}

	void EnumDictNSMutableArray(plist_t pDictObject, Json::Value& jsonValue)
	{
		plist_t pNSObjects = plist_dict_get_item(pDictObject, "NS.objects");
		if (CheckItemType(pNSObjects, PLIST_ARRAY))
		{
			uint32_t nObjects = plist_array_get_size(pNSObjects);
			for (uint32_t i = 0; i < nObjects; i++)
			{
				plist_t pValue = GetNodeByUidDict(plist_array_get_item(pNSObjects, i));
				if (pValue)
				{
					plist_type nType = plist_get_node_type(pValue);
					_bplist_printf("%d - type %d ", i, nType);

					if (nType == PLIST_DICT)
					{
						_bplist_printf("\n");
						ConvertDict(pValue, jsonValue[i]);
					}
					else
					{
						SetValue(pValue, jsonValue[i]);
					}
				}
			}
		}
	}

	void EnumDictNSMutableDictionary(plist_t pDictObject, Json::Value& jsonValue)
	{
		plist_t pNSKeys = plist_dict_get_item(pDictObject, "NS.keys");
		plist_t pNSObjects = plist_dict_get_item(pDictObject, "NS.objects");
		if (CheckItemType(pNSKeys, PLIST_ARRAY) && CheckItemType(pNSObjects, PLIST_ARRAY))
		{
			uint32_t nKeys = plist_array_get_size(pNSKeys);
			if (plist_array_get_size(pNSObjects) == nKeys)
			{
				for (uint32_t i = 0; i < nKeys; i++)
				{
					plist_t pKey = GetNodeByUidDict(plist_array_get_item(pNSKeys, i));
					plist_t pValue = GetNodeByUidDict(plist_array_get_item(pNSObjects, i));
					if (pKey && pValue)
					{
						//modify by fenlog 2019.07.18
						plist_type nKeyType = plist_get_node_type(pKey);
						plist_type nValueType = plist_get_node_type(pValue);
						if (nKeyType == PLIST_STRING)
						{
							uint64_t sLen = 0;
							const char* pszKey = plist_get_string_ptr(pKey, &sLen);
							if (pszKey)
							{
								_bplist_printf("%s - type %d ", pszKey, nValueType);

								if (nValueType == PLIST_DICT)
								{
									_bplist_printf("\n");
									ConvertDict(pValue, jsonValue[pszKey]);
								}
								else
								{
									SetValue(pValue, jsonValue[pszKey]);
								}
							}
						}
						else if (nKeyType == PLIST_UINT)
						{
							uint64_t nKeyValue = 0;
							plist_get_uint_val(pKey, &nKeyValue);

							_bplist_printf("%llu - type %d ", nKeyValue, nValueType);

							if (nValueType == PLIST_DICT)
							{
								_bplist_printf("\n");
								ConvertDict(pValue, jsonValue[std::to_string(nKeyValue)]);
							}
							else
							{
								SetValue(pValue, jsonValue[std::to_string(nKeyValue)]);
							}
						}
						else if (nKeyType == PLIST_DICT)
						{
							std::string index = std::to_string(i);
							ConvertDict(pKey, jsonValue[index]["key"]);
							if (nValueType == PLIST_DICT)
								ConvertDict(pValue, jsonValue[index]["value"]);
							else
								SetValue(pValue, jsonValue[index]["value"]);
						}
						else
						{
							_bplist_printf("unknow type %d \n", nKeyType);
						}
					}
				}
			}
		}
	}

	void EnumArray(plist_t pArrObject, Json::Value& jsonValue)
	{
		plist_type nType = plist_get_node_type(pArrObject);
		if (nType != PLIST_ARRAY)
			return;

		uint32_t nArrayCount = plist_array_get_size(pArrObject);
		for (uint32_t i = 0; i < nArrayCount; i++)
		{
			plist_t pItem = plist_array_get_item(pArrObject, i);
			nType = plist_get_node_type(pItem);
			if (nType == PLIST_DICT)
			{
				EnumDictKeyValueDefault(pItem, jsonValue[i]);
			}
			else if (nType == PLIST_ARRAY)
			{
				EnumArray(pItem, jsonValue[i]);
			}
			else
			{
				SetValue(pItem, jsonValue[i]);
			}
		}
	}

	void EnumDictKeyValueDefault(plist_t pDictObject, Json::Value& jsonValue)
	{
		plist_dict_iter it = nullptr;
		char* key = nullptr;
		plist_t subnode = nullptr;
		plist_dict_new_iter(pDictObject, &it);
		plist_dict_next_item(pDictObject, it, &key, &subnode);
		while (subnode)
		{
			int nType = plist_get_node_type(subnode);
			//UID的重新修正目标指针
			if (nType == PLIST_UID)
			{
				subnode = GetNodeByUidDict(subnode);
				//重新读取type
				if (subnode)
					nType = plist_get_node_type(subnode);
			}

			_bplist_printf("%s - type %d \n", key, nType);

			if (nType == PLIST_DICT)
			{
				_bplist_printf("\n");
				ConvertDict(subnode, jsonValue[key]);
			}
			else if (nType == PLIST_ARRAY)
			{
				EnumArray(subnode, jsonValue[key]);
			}
			else
			{
				SetValue(subnode, jsonValue[key]);
			}

			subnode = nullptr;
			plist_to_bin_free(key); //没有plist_mem_free，临时用这个代替
			key = nullptr;
			plist_dict_next_item(pDictObject, it, &key, &subnode);
		}
		plist_to_bin_free((char*)it);//没有plist_mem_free，临时用这个代替
	}

	void ConvertDict(plist_t pDict, Json::Value& jsonValue)
	{
		//如果是dict 可能是对象描述
		plist_t pDictObject = plist_dict_get_item(pDict, "$class");
		if (pDictObject)
		{
			std::string strClassName = GetDictClassName(pDictObject);

			//一般这里都不会为空
			if (!strClassName.empty())
			{
				_bplist_printf("Get Class:%s \n", strClassName.c_str());

				if (strClassName == "NSMutableDictionary" || strClassName == "NSDictionary")
				{
					EnumDictNSMutableDictionary(pDict, jsonValue);
				}
				else if (strClassName == "NSMutableArray" || strClassName == "NSArray")
				{
					EnumDictNSMutableArray(pDict, jsonValue);
				}
				else
				{
					//遍历里面的key-value
					EnumDictKeyValueDefault(pDict, jsonValue);
				}
			}
		}
		else
		{
			EnumDictKeyValueDefault(pDict, jsonValue);
		}
	}

	std::string ConvertPlistToXML(plist_t plist = nullptr) const
	{
		std::string strRet;
		if (!plist)
		{
			if (!m_plistMain)
				return strRet;

			plist = m_plistMain;
		}

		char* pszMsg = nullptr;
		uint32_t nMsgLen = 0;
		plist_to_xml(plist, &pszMsg, &nMsgLen);
		//printf("%s \n", pszMsg);
		if (pszMsg)
		{
			strRet = pszMsg;
			plist_to_xml_free(pszMsg);
		}

		return strRet;
	}

	plist_t m_plistMain;
	plist_t m_pObjectArray;
	bool m_bConvertDataPlist;
};

比如一个示例的plist：demo.plist

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>$version</key>
	<integer>100000</integer>
	<key>$archiver</key>
	<string>NSKeyedArchiver</string>
	<key>$top</key>
	<dict>
		<key>root</key>
		<dict>
			<key>CF$UID</key>
			<integer>1</integer>
		</dict>
	</dict>
	<key>$objects</key>
	<array>
		<string>$null</string>
		<dict>
			<key>_closeLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_intimateRelationDark</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_sex</key>
			<dict>
				<key>CF$UID</key>
				<integer>9</integer>
			</dict>
			<key>_gameLastLoginTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_closeDays</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_chatHotLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_isFriendDontDisturb</key>
			<dict>
				<key>CF$UID</key>
				<integer>10</integer>
			</dict>
			<key>_magicFontOpenFlagUpdateTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_onlineMusicRemainingTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_needShowFriendTreeAnimation</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_onlineMusicEndTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_interactiveSignMode</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_friendTreeLastChatTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_richOnlineState</key>
			<dict>
				<key>CF$UID</key>
				<integer>5</integer>
			</dict>
			<key>_ctType</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_needShipAnimation</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_friendTreePreLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_vipInfoDic</key>
			<dict>
				<key>CF$UID</key>
				<integer>15</integer>
			</dict>
			<key>_intimateRelationFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_network</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_lastGetCustomStateTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>20</integer>
			</dict>
			<key>_enableQSL</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_QQRobert</key>
			<dict>
				<key>CF$UID</key>
				<integer>3</integer>
			</dict>
			<key>_avatarIdUpdateTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_isMatchRealNick</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_shouldShowCustomState</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_status</key>
			<dict>
				<key>CF$UID</key>
				<integer>6</integer>
			</dict>
			<key>_magicFontType</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_cSpecialFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>3</integer>
			</dict>
			<key>_specialCareZone</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_qzoneLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_gameAppId</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_createTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_nameplateVipType</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_eIconType</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_isShortcutEnable</key>
			<dict>
				<key>CF$UID</key>
				<integer>2</integer>
			</dict>
			<key>_memberLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_isFriendMask</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_isMatchUIN</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_friendTreeFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_loverKeyFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_age</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_fuin</key>
			<dict>
				<key>CF$UID</key>
				<integer>13</integer>
			</dict>
			<key>_abiFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_priority</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_locationAbility</key>
			<dict>
				<key>CF$UID</key>
				<integer>3</integer>
			</dict>
			<key>_matchRange</key>
			<dict>
				<key>CF$UID</key>
				<integer>21</integer>
			</dict>
			<key>_loverKeyLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_intimateRelationLastChatTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_topIdentityInfo</key>
			<dict>
				<key>CF$UID</key>
				<integer>10</integer>
			</dict>
			<key>_fontIdUpdateTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_lastGetOnlineInfoTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>18</integer>
			</dict>
			<key>_isEnglishName</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_qslCreateTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_loverKeyTransFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_gameNameplateId</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_notiNoVibrate</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_enableYQHType</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_praiseHotLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_lastKeyTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_praiseHotDays</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_loverFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_avatarId</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_newBoatLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_groupId</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_lastLoginClient</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_extendNameplateId</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_faceAddonId</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_isBlockedMask</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_onlineMusicSourceType</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_lastPraiseTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_colorRingId</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_isShortcutEnableUpdate</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_isBlockMask</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_dstUin</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_terminalDescription</key>
			<dict>
				<key>CF$UID</key>
				<integer>17</integer>
			</dict>
			<key>_customStateDescription</key>
			<dict>
				<key>CF$UID</key>
				<integer>17</integer>
			</dict>
			<key>_gameRank</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_intimateRelationLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_friendTreeContinuityDays</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_qzoneDays</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_isRemark</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_holdFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_grayNameplateFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>$class</key>
			<dict>
				<key>CF$UID</key>
				<integer>23</integer>
			</dict>
			<key>_notiNeedHideSession</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_isFriendSetTop</key>
			<dict>
				<key>CF$UID</key>
				<integer>10</integer>
			</dict>
			<key>_vipFontId</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_nick</key>
			<dict>
				<key>CF$UID</key>
				<integer>12</integer>
			</dict>
			<key>_lastChatTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_onlineMusicTotalTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_isSpecialCareOpen</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_pendantIdUpdateTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_head</key>
			<dict>
				<key>CF$UID</key>
				<integer>8</integer>
			</dict>
			<key>_sqq</key>
			<dict>
				<key>CF$UID</key>
				<integer>3</integer>
			</dict>
			<key>_isMsfUser</key>
			<dict>
				<key>CF$UID</key>
				<integer>3</integer>
			</dict>
			<key>_maxGetCustomStateInterval</key>
			<dict>
				<key>CF$UID</key>
				<integer>19</integer>
			</dict>
			<key>_isQimFriend</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_chatHotDays</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_magicFontTypeUpdateTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_supportVideo</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_isWifi</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_notiNoSound</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_lastQzoneTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_recommendHoldFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_friendTreeNotifyTime</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_bNotShowNetWorkIcon</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_gameIconShowFlag</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_notiNoPreview</key>
			<dict>
				<key>CF$UID</key>
				<integer>4</integer>
			</dict>
			<key>_maxGetOnlineInfoInterval</key>
			<dict>
				<key>CF$UID</key>
				<integer>19</integer>
			</dict>
			<key>_lastLoginType</key>
			<dict>
				<key>CF$UID</key>
				<integer>7</integer>
			</dict>
			<key>_newBoatDays</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_friendTreeLevel</key>
			<dict>
				<key>CF$UID</key>
				<integer>11</integer>
			</dict>
			<key>_sig</key>
			<dict>
				<key>CF$UID</key>
				<integer>14</integer>
			</dict>
			<key>_propertyMD5</key>
			<dict>
				<key>CF$UID</key>
				<integer>22</integer>
			</dict>
		</dict>
		<true/>
		<integer>0</integer>
		<false/>
		<integer>65535</integer>
		<integer>20</integer>
		<integer>0</integer>
		<integer>201</integer>
		<integer>2</integer>
		<integer>-1</integer>
		<integer>0</integer>
		<string>10001</string>
		<string>1000194</string>
		<string>U</string>
		<dict>
			<key>NS.keys</key>
			<array>
			</array>
			<key>NS.objects</key>
			<array>
			</array>
			<key>$class</key>
			<dict>
				<key>CF$UID</key>
				<integer>16</integer>
			</dict>
		</dict>
		<dict>
			<key>$classname</key>
			<string>NSDictionary</string>
			<key>$classes</key>
			<array>
				<string>NSDictionary</string>
				<string>NSObject</string>
			</array>
		</dict>
		<string></string>
		<real>1682211584.541188</real>
		<real>0.000000</real>
		<real>1682211584.541188</real>
		<data>
		AAAAAAAAAAAAAAAAAAAAAA==
		</data>
		<string></string>
		<dict>
			<key>$classname</key>
			<string>QQFriendModel</string>
			<key>$classes</key>
			<array>
				<string>QQFriendModel</string>
				<string>QQModel</string>
				<string>NSObject</string>
			</array>
		</dict>
	</array>
</dict>
</plist>

可以看到里面有很多CF$UID这种UID类型的key值需要重新匹配具体内容，还涉及到NSDictionary等对象，通过类解析后的json结构是：

{
    "$class" : 
    {
        "$classes" : 
        [
            "QQFriendModel",
            "QQModel",
            "NSObject"
        ],
        "$classname" : "QQFriendModel"
    },
    "_QQRobert" : 0,
    "_abiFlag" : 0,
    "_age" : 0,
    "_avatarId" : 0,
    "_avatarIdUpdateTime" : 0,
    "_bNotShowNetWorkIcon" : 0,
    "_cSpecialFlag" : 0,
    "_chatHotDays" : 0,
    "_chatHotLevel" : 0,
    "_closeDays" : 0,
    "_closeLevel" : 0,
    "_colorRingId" : 0,
    "_createTime" : 0,
    "_ctType" : 0,
    "_customStateDescription" : "",
    "_dstUin" : 0,
    "_eIconType" : 0,
    "_enableQSL" : 0,
    "_enableYQHType" : 0,
    "_extendNameplateId" : 0,
    "_faceAddonId" : 0,
    "_fontIdUpdateTime" : 0,
    "_friendTreeContinuityDays" : 0,
    "_friendTreeFlag" : 0,
    "_friendTreeLastChatTime" : 0,
    "_friendTreeLevel" : 0,
    "_friendTreeNotifyTime" : 0,
    "_friendTreePreLevel" : 0,
    "_fuin" : "1000194",
    "_gameAppId" : 0,
    "_gameIconShowFlag" : 0,
    "_gameLastLoginTime" : 0,
    "_gameNameplateId" : 0,
    "_gameRank" : 0,
    "_grayNameplateFlag" : 0,
    "_groupId" : 0,
    "_head" : 201,
    "_holdFlag" : 0,
    "_interactiveSignMode" : 0,
    "_intimateRelationDark" : 0,
    "_intimateRelationFlag" : 0,
    "_intimateRelationLastChatTime" : 0,
    "_intimateRelationLevel" : 0,
    "_isBlockMask" : 0,
    "_isBlockedMask" : 0,
    "_isEnglishName" : 0,
    "_isFriendDontDisturb" : 18446744073709551615,
    "_isFriendMask" : 0,
    "_isFriendSetTop" : 18446744073709551615,
    "_isMatchRealNick" : 0,
    "_isMatchUIN" : 0,
    "_isMsfUser" : 0,
    "_isQimFriend" : 0,
    "_isRemark" : 0,
    "_isShortcutEnable" : 1,
    "_isShortcutEnableUpdate" : 0,
    "_isSpecialCareOpen" : 0,
    "_isWifi" : 0,
    "_lastChatTime" : 0,
    "_lastGetCustomStateTime" : 1682211584.541188,
    "_lastGetOnlineInfoTime" : 1682211584.541188,
    "_lastKeyTime" : 0,
    "_lastLoginClient" : 0,
    "_lastLoginType" : 0,
    "_lastPraiseTime" : 0,
    "_lastQzoneTime" : 0,
    "_locationAbility" : 0,
    "_loverFlag" : 0,
    "_loverKeyFlag" : 0,
    "_loverKeyLevel" : 0,
    "_loverKeyTransFlag" : 0,
    "_magicFontOpenFlagUpdateTime" : 0,
    "_magicFontType" : 0,
    "_magicFontTypeUpdateTime" : 0,
    "_matchRange" : "AAAAAAAAAAAAAAAAAAAAAA==",
    "_maxGetCustomStateInterval" : 0.0,
    "_maxGetOnlineInfoInterval" : 0.0,
    "_memberLevel" : 0,
    "_nameplateVipType" : 0,
    "_needShipAnimation" : 0,
    "_needShowFriendTreeAnimation" : 0,
    "_network" : 0,
    "_newBoatDays" : 0,
    "_newBoatLevel" : 0,
    "_nick" : "10001",
    "_notiNeedHideSession" : 0,
    "_notiNoPreview" : 0,
    "_notiNoSound" : 0,
    "_notiNoVibrate" : 0,
    "_onlineMusicEndTime" : 0,
    "_onlineMusicRemainingTime" : 0,
    "_onlineMusicSourceType" : 0,
    "_onlineMusicTotalTime" : 0,
    "_pendantIdUpdateTime" : 0,
    "_praiseHotDays" : 0,
    "_praiseHotLevel" : 0,
    "_priority" : 0,
    "_propertyMD5" : "",
    "_qslCreateTime" : 0,
    "_qzoneDays" : 0,
    "_qzoneLevel" : 0,
    "_recommendHoldFlag" : 0,
    "_richOnlineState" : 65535,
    "_sex" : 2,
    "_shouldShowCustomState" : 0,
    "_sig" : "U",
    "_specialCareZone" : 0,
    "_sqq" : 0,
    "_status" : 20,
    "_supportVideo" : 0,
    "_terminalDescription" : "",
    "_topIdentityInfo" : 18446744073709551615,
    "_vipFontId" : 0,
    "_vipInfoDic" : null
}

比如需要解析并读取"_richOnlineState"字段的值，解析示例代码：

CPlistObject mPlist;
mPlist.OpenPlistFile("demo.plist");
uint32_t v = mPlist["_richOnlineState"].asInt();

嗯，非常简单。最后读取的时候，记得校验字段是否存在，否则jsoncpp可能会抛异常。

wgs84：GPS使用的坐标系

gcj02：中国国家测绘局制订的地理信息系统的坐标系统，是在WGS84经纬度的基础上执行加密算法而成。因为GPS得到的经纬度直接在 GCJ-02 坐标系下会定位到错误的地点，有种到了火星的感觉，因此在坊间也将 GCJ-02 戏称为火星坐标系。高德地图、腾讯地图均使用的此坐标系。

bd09：百度地图使用的，在gcj02基础上又做了一次转换。

//由于坐标系名词比较拗口，注释写的就通俗易懂了

//百度转高德坐标系
void bd09togcj02(double bd_lat, double bd_lon, double& out_lat, double& out_lon);
//高德转百度坐标系
void gcj02tobd09(double gcj_lat, double gcj_lon, double& out_lat, double& out_lon);
//高德转wgs84
void gcj02towgs84(double gcj_lat, double gcj_lon, double& out_lat, double& out_lon);
//wgs84转高德
void wgs84togcj02(double wgs_lat, double wgs_lon, double& out_lat, double& out_lon);


double x_PI = 3.14159265358979323846 * 3000.0 / 180.0;
double PI = 3.1415926535897932384626;
double a = 6378245.0;
double ee = 0.00669342162296594323;

bool outof_China(double lon, double lat)
{
	return(lon < 72.004 || lon>137.8374 || lat < 0.8293 || lat >55.8271 || false);
}
double translate_lon(double lon, double lat)
{
	double ret = 300.0 + lon + 2.0 * lat + 0.1 * lon * lon + 0.1 * lon * lat + 0.1 * sqrt(abs(lon));
	ret += (20.0 * sin(6.0 * lon * PI) + 20.0 * sin(2.0 * lon * PI)) * 2.0 / 3.0;
	ret += (20.0 * sin(lon * PI) + 40.0 * sin(lon / 3.0 * PI)) * 2.0 / 3.0;
	ret += (150 * sin(lon / 12.0 * PI) + 300.0 * sin(lon / 30.0 * PI)) * 2.0 / 3.0;
	return ret;
}
double translate_lat(double lon, double lat)
{
	double ret = -100 + 2.0 * lon + 3.0 * lat + 0.2 * lat * lat + 0.1 * lon * lat + 0.2 * sqrt((abs(lon)));
	ret += (20.0 * sin(6.0 * lon * PI) + 20 * sin(2.0 * lon * PI)) * 2.0 / 3.0;
	ret += (20.0 * sin(lat * PI) + 40.0 * sin(lat / 3.0 * PI)) * 2.0 / 3.0;
	ret += (160.0 * sin(lat / 12.0 * PI) + 320.0 * sin(lat / 30.0 * PI)) * 2.0 / 3.0;
	return ret;
}
void bd09togcj02(double bd_lat, double bd_lon, double& out_lat, double& out_lon)
{
	double x = bd_lon - 0.0065;
	double y = bd_lat - 0.006;
	double z = sqrt(x * x + y * y) - 0.00002 * sin(y * x_PI);
	double theta = atan2(y, x) - 0.000003 * cos(x * x_PI);
	out_lon = z * cos(theta);
	out_lat = z * sin(theta);
}
void gcj02tobd09(double gcj_lat, double gcj_lon, double& out_lat, double& out_lon)
{
	double z = sqrt(gcj_lon * gcj_lon + gcj_lat * gcj_lat) + 0.00002 * sin(gcj_lat * x_PI);
	double theta = atan2(gcj_lat, gcj_lon) + 0.000003 * cos(gcj_lon * x_PI);
	out_lon = z * cos(theta) + 0.0065;
	out_lat = z * sin(theta) + 0.006;
}
void gcj02towgs84(double gcj_lat, double gcj_lon, double& out_lat, double& out_lon)
{
	if (outof_China(gcj_lon, gcj_lat))
	{
		out_lon = gcj_lon;
		out_lat = gcj_lat;
		return;
	}
	
	double dlat = translate_lat(gcj_lon - 105.0, gcj_lat - 35.0);
	double dlon = translate_lon(gcj_lon - 105.0, gcj_lat - 35.0);
	double radlat = gcj_lat / 180.0 * PI;
	double magic = sin(radlat);
	magic = 1 - ee * magic * magic;
	double squrtmagic = sqrt(magic);
	dlon = (dlon * 180.0) / (a / squrtmagic * cos(radlat) * PI);
	dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * squrtmagic) * PI);
	out_lon = gcj_lon - dlon;
	out_lat = gcj_lat - dlat;
}
void wgs84togcj02(double wgs_lat, double wgs_lon, double& out_lat, double& out_lon)
{
	if (outof_China(wgs_lon, wgs_lat))
	{
		out_lon = wgs_lon;
		out_lat = wgs_lat;
		return;
	}
	
	double dlat = translate_lat(wgs_lon - 105.0, wgs_lat - 35.0);
	double dlon = translate_lon(wgs_lon - 105.0, wgs_lat - 35.0);
	double radlat = wgs_lat / 180.0 * PI;
	double magic = sin(radlat);
	magic = 1 - ee * magic * magic;
	double squrtmagic = sqrt(magic);
	dlon = (dlon * 180.0) / (a / squrtmagic * cos(radlat) * PI);
	dlat = (dlat * 180.0) / ((a * (1 - ee)) / (magic * squrtmagic) * PI);
	out_lon = wgs_lon + dlon;
	out_lat = wgs_lat + dlat;
}

任务队列可以认为是执行同一个方法来处理数据的队列，指定回调函数。

线程池就是先开辟好多个线程，然后将要执行的方法+参数丢到线程池中，支持返回值获取。

均依赖了无锁队列库 https://github.com/cameron314/concurrentqueue

本来不想依赖三方组件的，但是测试发现这个库效率是真的高，比带锁的队列快非常多。

而且vs中的std::queue是有BUG的，pop后不释放内存，也有一定的隐患（急死强迫症）

任务队列库TaskQueue：

#pragma once

#include <functional>
#include <vector>
#include <thread>
#include <future>
#include <atomic>
#include <chrono>
#include <mutex>

#include "queue/blockingconcurrentqueue.h" //for tsBlockQuque

template <class T, class P = void*>
class CTaskQueue
{
private:
	typedef std::function<void(P &param)> functionTaskInit;
	typedef std::function<void(P &param)> functionTaskExit;
	typedef std::function<bool(T &data)> functionTaskCallback;
	typedef std::function<bool(T &data, P &param)> functionTaskExCallback;
	//退出的时候用的回调
	typedef std::function<void(uint64_t, uint64_t)> functionWaitCallback;

	//退出标记
	bool m_bExit;
	//检测队列的等待时间，毫秒
	int m_nWaitTime;
	//延时模式开关
	bool m_bDelayMode;
	//延时模式下，启动新工作线程需要加锁
	std::mutex m_mtStartWorkThread;
	//最大线程数
	size_t m_nMaxThreadCount;
	//添加的总数量的数量
	std::atomic<uint64_t> m_nTotalCount;
	//已处理完毕的数量
	std::atomic<uint64_t> m_nProcessedCount;
	//任务队列
	tsBlockQuque <T> m_taskQueue;

	//单参数的回调
	functionTaskCallback m_TaskCallBack;

	//带扩展参数的回调
	functionTaskInit m_TaskInitCallBack;
	functionTaskExit m_TaskExitCallBack;
	functionTaskExCallback m_TaskExCallBack;

	//工作线程
	std::vector <std::future<int>> m_arrWorkThreads;

	//启动工作线程
	void _StartWorkThread(size_t nThreadCount)
	{
		std::lock_guard<std::mutex> lock(m_mtStartWorkThread);

		if (m_arrWorkThreads.size() >= m_nMaxThreadCount)
			return;
		
		for (size_t i = 0; i < nThreadCount; i++)
		{
			m_arrWorkThreads.emplace_back(std::async(std::launch::async, [this]()->int{

				P param;
				if (m_TaskInitCallBack)
					m_TaskInitCallBack(param);

				while (true)
				{
					T data;
					if (m_taskQueue.wait_dequeue_timed(data, std::chrono::milliseconds(m_nWaitTime)))
					{
						//找到一组数据 回调
						if (m_TaskCallBack)
						{
							if (!m_TaskCallBack(data))
							{
								//处理失败了 重新丢回队列里面去
								m_taskQueue.enqueue(data);
								continue;
							}
						}
						else if (m_TaskExCallBack)
						{
							if (!m_TaskExCallBack(data, param))
							{
								//处理失败了 重新丢回队列里面去
								m_taskQueue.enqueue(data);
								continue;
							}
						}

						m_nProcessedCount++;
						continue;
					}

					//结束标记并且队列没有数据了 返回
					if (m_bExit)
						break;
				}

				if (m_TaskExitCallBack)
					m_TaskExitCallBack(param);

				return 0;
			}));
		}

		//创建完毕工作线程后，重置一下标记
		if (m_bDelayMode && m_arrWorkThreads.size() >= m_nMaxThreadCount)
			m_bDelayMode = false;
	}
public:

	//禁止拷贝和移动
	CTaskQueue(const CTaskQueue&) = delete;
	CTaskQueue& operator=(const CTaskQueue&) = delete;

	/*
	构造函数：
		bDelayMode: 延时模式
			true:延时启动工作线程，有需要的时候启动
			false:立即启动工作线程
		nWaitTime:等待队列的超时时间，毫秒
	*/
	CTaskQueue(bool bDelayMode = false, int nWaitTime = 200)
	{
		m_bExit = false;
		m_nTotalCount = 0;
		m_nProcessedCount = 0;
		m_bDelayMode = bDelayMode;
		m_nWaitTime = nWaitTime;
	}
	~CTaskQueue()
	{
		m_bExit = true;

		for (auto& fu : m_arrWorkThreads)
		{
			try
			{
				fu.get();
			}
			catch (...){}
		}
	}

	/*
	简单的回调方法的初始化
	参数：
		线程数
		回调方法
	*/
	void InitTaskQueue(size_t nMaxThreadCount, functionTaskCallback fnTaskCallback)
	{
		m_TaskCallBack = fnTaskCallback;
		m_TaskExCallBack = nullptr;
		m_TaskInitCallBack = nullptr;
		m_TaskExitCallBack = nullptr;
		m_nMaxThreadCount = nMaxThreadCount;

		if (!m_bDelayMode)
			_StartWorkThread(nMaxThreadCount);
	}
	/*
	带队列线程初始化和销毁回调方法的初始化
	参数：
		线程数
		数据处理回调方法
		队列线程初始化回调
		队列线程销毁回调
	*/
	void InitTaskQueue(int nMaxThreadCount, functionTaskExCallback fnTaskExCallback, functionTaskInit fnTaskInitCallback, functionTaskExit fnTaskExitCallback)
	{
		m_TaskCallBack = nullptr;
		m_TaskExCallBack = fnTaskExCallback;
		m_TaskInitCallBack = fnTaskInitCallback;
		m_TaskExitCallBack = fnTaskExitCallback;
		m_nMaxThreadCount = nMaxThreadCount;

		if (!m_bDelayMode)
			_StartWorkThread(nMaxThreadCount);
	}

	//添加数据
	void AddData(const T &data)
	{
		if (m_bDelayMode)
		{
			//延时模式下，如果任务还没有处理完毕，就增加一个工作线程
			if (!IsFinished() || m_arrWorkThreads.size() == 0)
			{
				//内部有工作线程数检测，达到最大线程数后自动关闭延时模式
				_StartWorkThread(1);
			}
		}

		assert(m_arrWorkThreads.size());
		m_taskQueue.enqueue(data);
		m_nTotalCount++;
	}

	//获取当前工作线程数
	size_t GetWorkThreadCount()
	{
		return m_arrWorkThreads.size();
	}

	//读取当前队列中待处理的数量
	uint64_t GetQueueSize()
	{
		return m_taskQueue.size_approx();
	}

	//读取已经处理过的数量
	uint64_t GetProcessedCount()
	{
		return m_nProcessedCount;
	}

	//读取所有加入过队列的数量
	uint64_t GetTotalCount()
	{
		return m_nTotalCount;
	}

	//查询队列是否处理完毕  立即返回
	bool IsFinished()
	{
		if (m_nTotalCount == m_nProcessedCount && GetQueueSize() == 0)
			return true;

		return false;
	}

	//等待队列结束  阻塞执行
	void WaitForFinish(int nCheckms = 100, functionWaitCallback fnWaitCallback = nullptr)
	{
		printf("Wait for finish...\n");

		while (!IsFinished())
		{
			if (fnWaitCallback)
				fnWaitCallback(m_nProcessedCount, m_nTotalCount);

			std::this_thread::sleep_for(std::chrono::milliseconds(nCheckms));
		}

		if (fnWaitCallback)
			fnWaitCallback(m_nProcessedCount, m_nTotalCount);

		printf("All finished. \n");
	}
};

示例代码：

    
    //
    CTaskQueue<int, int> taskTester;  //第二个int可忽略
	
	//单一回调
	taskTester.InitTaskQueue(8, [](int data)->bool{
		printf("task:%d\n", data);
		return true; //返回false会重新插回队列中
	}
	
	//多个回调的初始化方法
	taskTester.InitTaskQueue(8, [](int data, int &param)->bool{
		printf("task:%d, param:%d\n", data, param);
		return true;
	},
	[](int &param){
		param = GetCurrentThreadId();
		printf("task work thread init:%d \n", param);
	},
	[](int &param){
		printf("task work thread exit:%d \n", param);
	});

	for (int i = 0; i < 10000; i++)
	{
		taskTester.AddData(i);
	}

	taskTester.WaitforFinish(100, [](uint64_t processed, uint64_t total){
		uint64_t ret = (processed * 100) / total;
		printf("processed:%I64d, total:%I64d, %d%% \n", processed, total, (int)ret);
	});

线程池是用之前的帖子中的线程池修改的，增加了几个方法，修正了vs下的BUG 。。。

#pragma once

#include <vector>
#include <memory>
#include <thread>
#include <future>
#include <functional>
#include <stdexcept>
#include <atomic>
#include <chrono>
#include <mutex>

#include "queue/blockingconcurrentqueue.h" //for tsBlockQuque

class ThreadPool 
{
private:
	//退出时回调方法声明
	typedef std::function<void(uint64_t, uint64_t)> functionWaitCallback;

	//工作线程
	std::vector<std::future<int>> m_arrWorkThreads;
	//任务队列
	tsBlockQuque < std::function<void()> > m_TaskQueue;

	//退出标记
	bool m_bExit;
	//检测队列的等待时间，毫秒
	int m_nWaitTime;
	//延时模式开关
	bool m_bDelayMode;
	//延时模式下，启动新工作线程需要加锁
	std::mutex m_mtStartWorkThread;
	//最大线程数
	size_t m_nMaxThreadCount;
	//添加的总数量的数量
	std::atomic<uint64_t> m_nTotalCount;
	//已处理完毕的数量
	std::atomic<uint64_t> m_nProcessedCount;

	//启动工作线程
	void _StartWorkThread(size_t nThreadCount)
	{
		std::lock_guard<std::mutex> lock(m_mtStartWorkThread);

		if (m_arrWorkThreads.size() >= m_nMaxThreadCount)
			return;

		for (size_t i = 0; i < nThreadCount; i++)
		{
			m_arrWorkThreads.emplace_back(std::async(std::launch::async, [this]()->int{

				printf("thread pool thread start...\n");

				while (true)
				{
					std::function<void()> task;
					if (m_TaskQueue.wait_dequeue_timed(task, std::chrono::milliseconds(m_nWaitTime)))
					{
						task();
						m_nProcessedCount++;
						continue;
					}

					//结束标记并且队列没有数据了 返回
					if (m_bExit)
						break;
				}

				printf("thread pool thread exit...\n");
				return 0;
			}));
		}

		//创建完毕工作线程后，重置一下标记
		if (m_bDelayMode && m_arrWorkThreads.size() >= m_nMaxThreadCount)
			m_bDelayMode = false;
	}

public:

	//禁止拷贝和移动
	ThreadPool(const ThreadPool&) = delete;
	ThreadPool& operator=(const ThreadPool&) = delete;

	/*
	构造函数
		nMaxThreadCount:最大工作线程数
		bDelayMode：延时模式
			true:延时启动工作线程，有需要的时候启动
			false:立即启动工作线程
		nWaitTime:等待队列的超时时间，毫秒
	*/
	ThreadPool(size_t nMaxThreadCount, bool bDelayMode = false, int nWaitTime = 200)
	{
		m_nTotalCount = 0;
		m_nProcessedCount = 0;
		m_bExit = false;

		InitThreadPool(nMaxThreadCount, bDelayMode, nWaitTime);
	}
	ThreadPool()
	{
		m_nTotalCount = 0;
		m_nProcessedCount = 0;
		m_bExit = false;
	}
	~ThreadPool()
	{
		m_bExit = true;

		for (auto& fu : m_arrWorkThreads)
		{
			try
			{
				fu.get();
			}
			catch (...){}
		}
	}

	/*
	初始化线程池，如果使用带参数的构造函数初始化，则无需调用此方法
		nMaxThreadCount:最大工作线程数
		bDelayMode：延时模式
			true:延时启动工作线程，有需要的时候启动
			false:立即启动工作线程
		nWaitTime:等待队列的超时时间，毫秒
	*/
	void InitThreadPool(size_t nMaxThreadCount, bool bDelayMode = false, int nWaitTime = 200)
	{
		m_nMaxThreadCount = nMaxThreadCount;
		m_bDelayMode = bDelayMode;
		m_nWaitTime = nWaitTime;

		if (!m_bDelayMode)
			_StartWorkThread(nMaxThreadCount);
	}

	//添加任务
	template<class F, class... Args>
	auto AddTask(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type>
	{
		if (m_bDelayMode)
		{
			//延时模式下，如果任务还没有处理完毕，就增加一个工作线程
			if (!IsFinished() || m_arrWorkThreads.size() == 0)
			{
				//内部有工作线程数检测，达到最大线程数后自动关闭延时模式
				_StartWorkThread(1);
			}
		}

		assert(m_arrWorkThreads.size());

		using return_type = typename std::result_of<F(Args...)>::type;
		auto task = std::make_shared< std::packaged_task<return_type()> >(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
		std::future<return_type> res = task->get_future();
		m_TaskQueue.enqueue([task](){ (*task)(); });
		m_nTotalCount++;

		return res;
	}

	//获取当前工作线程数
	size_t GetWorkThreadCount()
	{
		return m_arrWorkThreads.size();
	}

	//获取总共插入过的任务数
	uint64_t GetTotalCount()
	{
		return m_nTotalCount;
	}

	//获取已经处理完毕的任务数
	uint64_t GetProcessedCount()
	{
		return m_nProcessedCount;
	}

	//读取当前队列中待处理的数量
	uint64_t GetQueueSize()
	{
		return m_TaskQueue.size_approx();
	}

	//判断是否已经执行完毕已经插入的任务
	bool IsFinished()
	{
		if (m_nProcessedCount == m_nTotalCount && m_TaskQueue.size_approx() == 0)
			return true;

		return false;
	}


	//阻塞等待队列执行完毕
	void WaitForFinish(int nCheckms = 100, functionWaitCallback fnWaitCallback = nullptr)
	{
		printf("Wait for finish...\n");

		while (!IsFinished())
		{
			if (fnWaitCallback)
				fnWaitCallback(m_nProcessedCount, m_nTotalCount);

			std::this_thread::sleep_for(std::chrono::milliseconds(nCheckms));
		}

		if (fnWaitCallback)
			fnWaitCallback(m_nProcessedCount, m_nTotalCount);

		printf("All finished. \n");
	}
};

最后说说vs神奇的BUG。。。

#include <iostream>
#include <string>
#include <vector>
#include <thread>


class MyClass
{
private:
	std::vector<std::thread> arrthreads;
	bool bexit;
public:
	MyClass()
	{
		bexit = false;
	};
	~MyClass()
	{
		bexit = true;
		for (auto &x : arrthreads)
		{
			x.join();  //vs编译的这里会卡死，gcc编译的正常执行
		}
	};

	void init()
	{
		for (int i = 0; i < 4; i++)
		{
			arrthreads.emplace_back([this](){

				printf("trhead start...\n");

				while (true)
				{
					if (bexit)
						break;

				}

				printf("trhead exit...\n");
			});
		}
	};
};


MyClass testthread;

int main()
{
    printf("main2\n");
    
    testthread.init();
    
    return 0;
}

MyClass析构函数中让工作线程退出，毫无问题，但是vs编译的，join会卡死阻塞或者崩溃跑飞，gcc编译的无问题。

各位大师有何看法。。。

很多应用需要监控系统资源的使用率等信息，之前零散写过很多。

近日需要读取硬盘的IO使用率，就是任务管理器中的硬盘相关信息。

读写速度很好搞定，但是这个百分比的使用率（活动时间）恶心了，最后搜索到的技术点都指向了Pdh(performance data helper)库。

上手一个技术点确实有点懵逼，花了一天学习才搞明白是什么意思。

这玩意是windows系统底层封装好的一个统计器，并提供了一套API可以让使用者自行调用来统计。

网上写的越来越复杂，越想描述越说不清楚，整的一脸懵逼，其实整理出来流程就5步。

直接说下最简单扼要的流程：

//1.创建监控器

PdhOpenQueryA(NULL, NULL, &m_hQuery);

//2.添加要监控的Counter，这个Counter是一个类似path的字符串，这个后续补充说明怎么查看，返回监控的目标的句柄

PdhAddCounterA(m_hQuery, strCounterPath.c_str(), 0, &hCounter);

//3.每隔一段时间要刷新一下监控器，注意两次调用之间一定要隔开足够长的时间，官网的示例是sleep（1000），1秒

PdhCollectQueryData(m_hQuery);

//4.读取监控的Counter的值

PdhGetFormattedCounterValue(hCounter,nFmt,&CounterType,&mRet);

//5.不用了要关闭监控器

PdhCloseQuery(m_hQuery);

实际原理就是先建立一个监控器，然后往这个监控器里面添加要监控的条目（Counter），允许监控的信息特别详细特别多什么CPU内存硬盘网络等等都有。然后每隔一段时间调用一下刷新监控器（PdhCollectQueryData），然后就再读取数值就得到了两次刷新之间监控的目标的数据了。

这里在强调一遍，两次调用刷新一定要间隔大一些，如果顺序连续两次调用，等于间隔时间无限小，会造成数据极为不准确。可以简单理解为计算下载速度一样，先前后两次读取下载的字节数，然后差值除以间隔时间就是速度，如果间隔时间太小就会造成不精确。

最后是关键信息，监控的Counter怎么查看，怎么得到路径。

win+R，打开perfmon.msc（性能监视器）

在中间空白的地方点击右键，添加计数器，会弹出来“可用计数器”的页面让你选择，这里就是系统支持的所有类型。

比如按照上述的需求要统计硬盘的使用率，那么就是下图所示：（坑爹的玩意硬盘使用率叫DiskTime，开始一直以为是DiskUsage所以没搜索到）

选择好后确定，就能看到底部多了一条监控Counter。

底部Counter的条目点击右键，属性，就能查看到具体的Counter的Path了，调用PdhAddCounterA传入的那个Path就是这个。

当然很多名字起得非常相似，可以自己先添加进去看看，实际确认一下。

最后非常简单的封装了一个C++的类

头文件 PDHCounterHandler.h

#pragma once

#include <map>
#include <string>
#include <pdh.h>
#include <pdhmsg.h>

#pragma comment(lib, "pdh.lib")

/*
使用方法
CPDHCounterHandler mPDHCounter;
//1.初始化
mPDHCounter.Init();
//2.添加counter
mPDHCounter.AddCounter("\\LogicalDisk(F:)\\% Disk Time", "DiskTimeF");
//3.循环读取counter的数值
while (true)
{
	//刷新counter数值，两次调用间隔不能太短 官方写的是1秒 可自由发挥
	Sleep(1000);
	mPDHCounter.CollectData();

	//读取数值
	printf("F: %d \n", mPDHCounter.GetCounterValue("DiskTimeF", PDH_FMT_LONG).longValue);
}


如何查看各种counter的路径
win+R，打开perfmon.msc（性能监视器）
右键添加计数器即可查看
*/
class CPDHCounterHandler
{
private:
	HQUERY m_hQuery;
	std::map<std::string, HCOUNTER> m_mapCounter;
	
public:
	CPDHCounterHandler();
	~CPDHCounterHandler();

	bool Init();
	bool UnInit();
	bool AddCounter(const std::string &strCounterPath, const std::string &strAlias = "");
	/*
	刷新数据 
	GetCounterValue前一定要先调用此方法刷新数据 
	两次调用此函数间隔不要太短
	*/
	bool CollectData();
	bool HasCounter(const std::string &strCounterName);
	PDH_FMT_COUNTERVALUE GetCounterValue(const std::string &strCounterName, int nFmt);

	//void ShowCounterBrowser();
};


Cpp  PDHCounterHandler.cpp

#include "stdafx.h"
#include "PDHCounterHandler.h"



CPDHCounterHandler::CPDHCounterHandler()
{
	m_hQuery = NULL;

}


CPDHCounterHandler::~CPDHCounterHandler()
{
	UnInit();
}

bool CPDHCounterHandler::Init()
{
	PDH_STATUS Status;
	Status = PdhOpenQueryA(NULL, NULL, &m_hQuery);
	if (Status != ERROR_SUCCESS)
	{
		printf("PdhOpenQuery failed with status 0x%x.\n", Status);
		return false;
	}

	return true;
}

bool CPDHCounterHandler::UnInit()
{
	if (m_hQuery)
	{
		PdhCloseQuery(m_hQuery);
		m_hQuery = NULL;
	}

	return true;
}


bool CPDHCounterHandler::AddCounter(const std::string &strCounterPath, const std::string &strAlias/* = ""*/)
{
	PDH_STATUS Status;
	HCOUNTER hCounter;
	Status = PdhAddCounterA(m_hQuery, strCounterPath.c_str(), 0, &hCounter);
	if (Status != ERROR_SUCCESS)
	{
		printf("PdhAddCounter %s failed with status 0x%x.\n", strCounterPath.c_str(), Status);
		return false;
	}

	//
	// Most counters require two sample values to display a formatted value.
	// PDH stores the current sample value and the previously collected
	// sample value. This call retrieves the first value that will be used
	// by PdhGetFormattedCounterValue in the first iteration of the loop
	// Note that this value is lost if the counter does not require two
	// values to compute a displayable value.
	//

	//创建后就刷新一下数据
	if (!CollectData())
		return false;

	if (strAlias.empty())
		m_mapCounter.insert(std::make_pair(strCounterPath, hCounter));
	else
		m_mapCounter.insert(std::make_pair(strAlias, hCounter));

	return true;
}

//刷新数据
bool CPDHCounterHandler::CollectData()
{
	PDH_STATUS Status;
	Status = PdhCollectQueryData(m_hQuery);
	if (Status != ERROR_SUCCESS)
	{
		printf("PdhCollectQueryData failed with 0x%x.\n", Status);
		return false;
	}

	return true;
}

bool CPDHCounterHandler::HasCounter(const std::string &strCounterName)
{
	auto iter = m_mapCounter.find(strCounterName);
	if (iter == m_mapCounter.end())
		return false;

	return true;
}

/*
fmt:PDH_FMT_DOUBLE PDH_FMT_LONG ...
*/
PDH_FMT_COUNTERVALUE CPDHCounterHandler::GetCounterValue(const std::string &strCounterName, int nFmt)
{
	PDH_FMT_COUNTERVALUE mRet = { 0 };
	auto iter = m_mapCounter.find(strCounterName);
	if (iter == m_mapCounter.end())
		return mRet;

	PDH_STATUS Status;
	DWORD CounterType;
	Status = PdhGetFormattedCounterValue(iter->second,
		nFmt,
		&CounterType,
		&mRet);
	if (Status != ERROR_SUCCESS)
	{
		printf("PdhGetFormattedCounterValue failed with status 0x%x.", Status);
	}

	return mRet;
}
// 
// void CPDHCounterHandler::ShowCounterBrowser()
// {
// 	//
// 	// Initialize the browser dialog window settings.
// 	//
// 	PDH_STATUS Status;
// 	PDH_BROWSE_DLG_CONFIG_A BrowseDlgData;
// 	char CounterPathBuffer[PDH_MAX_COUNTER_PATH];
// 
// 	ZeroMemory(&CounterPathBuffer, sizeof(CounterPathBuffer));
// 	ZeroMemory(&BrowseDlgData, sizeof(PDH_BROWSE_DLG_CONFIG));
// 
// 	BrowseDlgData.bIncludeInstanceIndex = FALSE;
// 	BrowseDlgData.bSingleCounterPerAdd = TRUE;
// 	BrowseDlgData.bSingleCounterPerDialog = TRUE;
// 	BrowseDlgData.bLocalCountersOnly = FALSE;
// 	BrowseDlgData.bWildCardInstances = TRUE;
// 	BrowseDlgData.bHideDetailBox = TRUE;
// 	BrowseDlgData.bInitializePath = FALSE;
// 	BrowseDlgData.bDisableMachineSelection = FALSE;
// 	BrowseDlgData.bIncludeCostlyObjects = FALSE;
// 	BrowseDlgData.bShowObjectBrowser = FALSE;
// 	BrowseDlgData.hWndOwner = NULL;
// 	BrowseDlgData.szReturnPathBuffer = CounterPathBuffer;
// 	BrowseDlgData.cchReturnPathLength = PDH_MAX_COUNTER_PATH;
// 	BrowseDlgData.pCallBack = NULL;
// 	BrowseDlgData.dwCallBackArg = 0;
// 	BrowseDlgData.CallBackStatus = ERROR_SUCCESS;
// 	BrowseDlgData.dwDefaultDetailLevel = PERF_DETAIL_WIZARD;
// 	BrowseDlgData.szDialogBoxCaption = "Select a counter to monitor.";
// 
// 	//
// 	// Display the counter browser window. The dialog is configured
// 	// to return a single selection from the counter list.
// 	//
// 
// 	Status = PdhBrowseCountersA(&BrowseDlgData);
// 
// 	if (Status != ERROR_SUCCESS)
// 	{
// 		if (Status == PDH_DIALOG_CANCELLED)
// 		{
// 			printf("Dialog canceled by user.\n");
// 		}
// 		else
// 		{
// 			printf("PdhBrowseCounters failed with status 0x%x.\n", Status);
// 		}
// 	}
// 	else if (strlen(CounterPathBuffer) == 0)
// 	{
// 		printf("User did not select any counter. \n");
// 	}
// 	else
// 	{
// 		printf("Counter selected: %ls \n", CounterPathBuffer);
// 	}
//}

最后贴一个示例：

        CPDHCounterHandler mPDHCounter;
	mPDHCounter.Init();
	mPDHCounter.AddCounter("\\LogicalDisk(F:)\\% Disk Time", "DiskTimeF");
	while (true)
	{
		//刷新监控器
		Sleep(1000);
		mPDHCounter.CollectData();

		printf("F: %d \n", mPDHCounter.GetCounterValue("DiskTimeF", PDH_FMT_LONG).longValue);
                
        //只要init之后，可以随时添加Counter进去
		if (!mPDHCounter.HasCounter("DiskTimeE"))
		{
			mPDHCounter.AddCounter("\\LogicalDisk(E:)\\% Disk Time", "DiskTimeE");
		}
		else
		{
			printf("E: %d \n", mPDHCounter.GetCounterValue("DiskTimeE", PDH_FMT_LONG).longValue);

			if (!mPDHCounter.HasCounter("DiskTimeD"))
			{
				mPDHCounter.AddCounter("\\LogicalDisk(D:)\\% Disk Time", "DiskTimeD");
			}
			else
			{
				printf("D: %d \n", mPDHCounter.GetCounterValue("DiskTimeD", PDH_FMT_LONG).longValue);
			}
		}
	}

2024.12.16更新

评论提到的ws问题修正了，实际上就是注释掉了一个多余的判断处理。

mongoose版本是6.18版本

https://github.com/cesanta/mongoose/releases/tag/6.18

题外话：

当时写这个cpp用了两天，用了一年多后来平台升级切换到了C++17就用了其他框架。后来发现虽然过去了好几年，但是关注的人还是很多，说明mongoose真的是好使，虽然有很多性能更好的库，但是在嵌入式设备等某些场景真的很实用，这也是当时选这个库作为框架的原因。这里面有个小BUG，所以代码更新修正了，有问题欢迎留言或者加QQ沟通继续完善。不提github了，某些原因不想提交上去。。。下面也推荐了几个笔者最近用过的其他框架，也很nice。

2024.5.22更新

推荐几个已经使用的http库：

A C++11 single-file header-only cross platform HTTP/HTTPS library.

https://github.com/yhirose/cpp-httplib

跟mongoose类似的框架，单文件无依赖跨平台，include后就能使用，这个库的作者也很积极，反馈过BUG提交过PR都处理的非常好，性能不要求很变态的情况下很推荐！

国产高性能框架基于C++17/20的Http应用框架，使用Drogon可以方便的使用C++构建各种类型的Web应用服务端程序

https://github.com/drogonframework/drogon

Header only c++ network library, based on asio,support tcp,udp,http,websocket,rpc,ssl,icmp,serial_port.

https://github.com/zhllxt/asio2

背景需求

每个工作背景都不同，需要总结一下：

1.C++编写，跨平台（windows上用的vs2013，所以是C++11标准）

2.支持http和ws的server，支持多线程，支持uri映射(类似addhandler("/hello",onrequestcallback);)，支持请求中相关字段的获取（get/post参数读取、header、cookie等读取）

3.不用性能超强，并发数也不大（几十并发）

4.依赖库少一点，不想为了一个小功能引入boost之类的大家伙

之前一直用的是libevent库提供的http服务作为一个接口服务器，后来有了新的需求要增加ws支持，官方的不支持ws，自己魔改libevent增加ws支持实力不够改的兼容性不好，框架网上有大把的框架，用现成的吧。

筛选

查找了很多库 https://github.com/fffaraz/awesome-cpp#networking

前后测试了两遍没有完全满足的，都要二次封装，那么就选一个库作为基石来鼓捣。

最后选择的是mongoose（具体过程不说了，完全是个人情况而定的）

mongoose一个很单纯的C编写的库，包含了client和server的功能，单线程业务处理，不过提供的方法倒是挺多的，非常方便使用。不过这个库不是性能优先，如果非常注重性能（几万并发起步）那还是不要用了，不过却满足我的当前需求。

建立http服务

mongoose简单示例（官方）

#include "mongoose.h"

//连接上所有事件的回调函数
static void ev_handler(struct mg_connection *nc, int ev, void *p) 
{
  
  //http请求
  if (ev == MG_EV_HTTP_REQUEST) 
  {
    //发送返回值，有多个函数可以用不同姿势发送返回值
    mg_printf(nc, "%s", "HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nOK");
  }

}

int main(void) 
{
  struct mg_mgr mgr;
  struct mg_connection *nc;

  mg_mgr_init(&mgr, NULL); //初始化连接管理器

  //绑定端口，设置回调函数
  nc = mg_bind(&mgr, "8000", ev_handler); 
  if (nc == NULL) {
    printf("Failed to create listener\n");
    return 1;
  }

  //允许http和websocket
  mg_set_protocol_http_websocket(nc);  

  //事件循环
  for (;;) {
    mg_mgr_poll(&mgr, 1000);
  }

  //释放连接管理器
  mg_mgr_free(&mgr);

  return 0;
}

先建立连接管理器(mg_mgr)，然后所有的连接都在mg_mgr中以链表的形式管理。

然后在mg_mgr中bind一个本地端口，并设置该连接允许http和websocket（mg_set_protocol_http_websocket），然后处理回调消息就完事了，非常简单。

那么也简单了，按照这几个方法，很容易封装出来一个C++的版本，这里不多贴代码了。

多线程的使用

多线程的官方示例：

#include "mongoose.h"

static sig_atomic_t s_received_signal = 0;
static const char *s_http_port = "8000";
static const int s_num_worker_threads = 5;
static unsigned long s_next_id = 0;

static void signal_handler(int sig_num) {
  signal(sig_num, signal_handler);
  s_received_signal = sig_num;
}
static struct mg_serve_http_opts s_http_server_opts;
static sock_t sock[2];

// This info is passed to the worker thread
struct work_request {
  unsigned long conn_id;  // needed to identify the connection where to send the reply
  // optionally, more data that could be required by worker 
};

// This info is passed by the worker thread to mg_broadcast
struct work_result {
  unsigned long conn_id;
  int sleep_time;
};

static void on_work_complete(struct mg_connection *nc, int ev, void *ev_data) {
  (void) ev;
  char s[32];
  struct mg_connection *c;
  for (c = mg_next(nc->mgr, NULL); c != NULL; c = mg_next(nc->mgr, c)) {
    if (c->user_data != NULL) {
      struct work_result *res = (struct work_result *)ev_data;
      if ((unsigned long)c->user_data == res->conn_id) {
        sprintf(s, "conn_id:%lu sleep:%d", res->conn_id, res->sleep_time);
        mg_send_head(c, 200, strlen(s), "Content-Type: text/plain");
        mg_printf(c, "%s", s);
      }
    }
  }
}

void *worker_thread_proc(void *param) {
  struct mg_mgr *mgr = (struct mg_mgr *) param;
  struct work_request req = {0};
  
  while (s_received_signal == 0) {
    if (read(sock[1], &req, sizeof(req)) < 0)
      perror("Reading worker sock");
    int r = rand() % 10;
    sleep(r);
    struct work_result res = {req.conn_id, r};
    mg_broadcast(mgr, on_work_complete, (void *)&res, sizeof(res));
  }
  return NULL;
}

static void ev_handler(struct mg_connection *nc, int ev, void *ev_data) {
  (void) nc;
  (void) ev_data;
  
  switch (ev) {
    case MG_EV_ACCEPT:
      nc->user_data = (void *)++s_next_id;
      break;
    case MG_EV_HTTP_REQUEST: {
      struct work_request req = {(unsigned long)nc->user_data};

      if (write(sock[0], &req, sizeof(req)) < 0)
        perror("Writing worker sock");
      break;
    }
    case MG_EV_CLOSE: {
      if (nc->user_data) nc->user_data = NULL;
    }
  }
}

int main(void) {
  struct mg_mgr mgr;
  struct mg_connection *nc;
  int i;

  if (mg_socketpair(sock, SOCK_STREAM) == 0) {
    perror("Opening socket pair");
    exit(1);
  }

  signal(SIGTERM, signal_handler);
  signal(SIGINT, signal_handler);

  mg_mgr_init(&mgr, NULL);

  nc = mg_bind(&mgr, s_http_port, ev_handler);
  if (nc == NULL) {
    printf("Failed to create listener\n");
    return 1;
  }

  mg_set_protocol_http_websocket(nc);
  s_http_server_opts.document_root = ".";  // Serve current directory
  s_http_server_opts.enable_directory_listing = "no";

  for (i = 0; i < s_num_worker_threads; i++) {
    mg_start_thread(worker_thread_proc, &mgr);
  }

  printf("Started on port %s\n", s_http_port);
  while (s_received_signal == 0) {
    mg_mgr_poll(&mgr, 200);
  }

  mg_mgr_free(&mgr);

  closesocket(sock[0]);
  closesocket(sock[1]);

  return 0;
}

开始看的我有点懵逼，建立了一个mg_socketpair来完成业务线程与工作线程的通信，在多线程的工作线程中要用mg_broadcast回调在回调里面真正发送数据，开始没有很好地理解写错了，崩溃了整整一宿（20:00到3:00）。后来仔细阅读了代码结合一些其他人的描述，才弄明白原理。

首先mongoose是业务线程是单线程，就是mg_mgr_poll那个循环就是业务线程，也就是说ev_handler这个回调和发送返回值操作都要在业务线程中做，不在业务线程中调用发送函数(例如mg_send_head)是错误的直接蹦。工作线程是可以多个线程来处理业务，处理完毕后要通知回业务线程。这个通知的方法就是mg_broadcast。

至于这个mg_socketpair可以认为是一个队列，用于业务线程接收到事件后，封装数据的发送到工作线程。补个图。

多线程之间通信

ev_handler回调的数据发送到工作线程

官方示例中使用mg_socketpair通信，其实就是建立了一对socket一个作为发送者一个作为接收者，就是socket通信而已。实际上可以用队列比较方便。建议使用无锁队列效率比较高（写的第一版用的是加锁队列，效率差了十多倍），无锁队列库：https://github.com/cameron314/concurrentqueue  （个人比较喜欢的header only方式）

数据传输这里，开始我直接传递的event_data指针，发现完全不行，因为ev_handler返回后该数据会被销毁，所以要在回调中把event_data中所需要的数据都缓存下来。比如http的回调事件MG_EV_HTTP_REQUEST，event_data是http_message*数据，里面包含uri、mehtod、body、message、header等等信息，都要自己另存下来，否则回调一返回数据就会被销毁了。保存好这份数据后，将其插入队列等待工作线程取数据处理。这时候回调返回，业务线程可以继续loop去干其他事情。

			http_message *msg = (http_message *)event_data;

			//保存回调里面的关键数据
			MG_EVENT_DATA_PTR cbdata = new MG_EVENT_DATA;
			cbdata->event_type = event_type;
			cbdata->body.assign(msg->body.p, msg->body.len);
			cbdata->method.assign(msg->method.p, msg->method.len);
			cbdata->uri.assign(msg->uri.p, msg->uri.len);
			cbdata->query.assign(msg->query_string.p, msg->query_string.len);
			cbdata->proto.assign(msg->proto.p, msg->proto.len);
			cbdata->contentlength = msg->content_length;
			for (int i = 0; i < MG_MAX_HTTP_HEADERS; i++)
			{
				if (msg->header_names[i].len == 0)
					break;
				cbdata->headers.emplace_back(std::string(msg->header_names[i].p, msg->header_names[i].len), std::string(msg->header_values[i].p, msg->header_values[i].len));
			}
			//将cbdata插入队列

工作线程处理与返回

工作线程是多线程，例如4线程就用std::thread开启4个work_handler()。里面的逻辑就是先从队列里面取出来数据，然后取出来数据后回调给用户接口，用户接口干活，干完之后封装返回值，这些都不用多说就是个简单的callback而已。这里再次强调不能直接在工作线程中调用发送方法（例如mg_send_head），要用回调将数据返回给业务线程去处理。重点就是mg_broadcast这个坑，写的真尼玛晦涩难懂，还都是坑，怪不得网上很多人都说官方的多线程例子是坨屎。

首先说说mg_broadcast这个方法

//工作线程中调用
void mg_broadcast(struct mg_mgr *mgr, mg_event_handler_t cb, void *data, size_t len) {
  struct ctl_msg ctl_msg;

  /*
   * Mongoose manager has a socketpair, `struct mg_mgr::ctl`,
   * where `mg_broadcast()` pushes the message.
   * `mg_mgr_poll()` wakes up, reads a message from the socket pair, and calls
   * specified callback for each connection. Thus the callback function executes
   * in event manager thread.
   */
  if (mgr->ctl[0] != INVALID_SOCKET && data != NULL &&
      len < sizeof(ctl_msg.message)) {
    size_t dummy;

    ctl_msg.callback = cb;
    memcpy(ctl_msg.message, data, len);
    dummy = MG_SEND_FUNC(mgr->ctl[0], (char *) &ctl_msg,
                         offsetof(struct ctl_msg, message) + len, 0);
    dummy = MG_RECV_FUNC(mgr->ctl[0], (char *) &len, 1, 0);
    (void) dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */
  }
}


//业务线程中接收
static void mg_mgr_handle_ctl_sock(struct mg_mgr *mgr) {
  struct ctl_msg ctl_msg;
  int len = (int) MG_RECV_FUNC(mgr->ctl[1], (char *) &ctl_msg, sizeof(ctl_msg), 0);
  size_t dummy = MG_SEND_FUNC(mgr->ctl[1], ctl_msg.message, 1, 0);
  DBG(("read %d from ctl socket", len));
  (void) dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */
  if (len >= (int) sizeof(ctl_msg.callback) && ctl_msg.callback != NULL) {
    struct mg_connection *nc;
    for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) {
      //回调方法
      ctl_msg.callback(nc, MG_EV_POLL,
                       ctl_msg.message MG_UD_ARG(nc->user_data));
    }
  }
}

void mg_broadcast(struct mg_mgr *mgr, mg_event_handler_t cb, void *data, size_t len);

第二个参数是广播的回调方法，data和len是数据。工作线程中调用mg_broadcast来广播，触发的回调方法里面就是业务线程了（开始没理解，后来通过打印调用和回调的threadid才明白）。

内部很简单其实就是一个在内部建立了一个mg_socketpair（上面描述过），将要传递的数据封装到结构体里面，工作线程中调用send把结构体发送出去，业务线程里面recv到这个结构体，然后触发回调，很简单的逻辑。这里官方代码很坑，connection在连接后 （ MG_EV_ACCEPT 事件），初始化了一个唯一connid（ s_next_id ）给每个connection（存储到了user_data里面），广播会将每个connection都回调一遍(上面代码里面nc那个链表的遍历)，然后在回调里面判断当前的connection是不是我要发送数据的connid，不是的话返回，是的话继续发送数据。官方示例里面在on_work_complete又遍历了一遍所有connection这里其实是错误的，一个大坑，因为回调已经是遍历所有connection回调了。这个也符合mg_broadcast这个名字，广播给所有connection回调。

这里还有一个大坑，因为mg_broadcast其实也是异步的，利用socket发送用户数据，那个结构体的定义为：

struct ctl_msg { 

    mg_event_handler_t callback; 

    char message[MG_CTL_MSG_MESSAGE_SIZE];  //默认是8192 

}; 

所以这里传递的数据不能是原始返回内容的buffer，太小了不合适呀，所以要new一个buffer传递进去，然后在回调里面去delete掉。但这里会引入另外一个问题，broadcast里面是遍历所有正常的connection，如果某个用户接口处理时间比较长比如要2秒，返回的时候connection已经断开了（多线程下是可能存在的），那么这个广播后就不能触发回调，导致这份buffer无法被删除造成内存泄露。

问题总结：

1.广播时connection断开了无法删除buffer

2.异步的，不知道当前connection的状态

3.工作线程与业务线程传递数据使用广播，意味着每次都要通知一遍所有的connection，这完全没有必要呀，我有connid那只回调一个connection就可以了哇。当然原本的broadcast到所有nc还是有必要的。

开始魔改mg_broadcast吧。。。改后的代码：

struct ctl_msg {
  mg_event_handler_t callback;
  uint32_t connid;  //connID，可以遍历指定的connection
  int syncflag;     //异步和同步执行标记
  void *data;       //传递的数据
};

//增加connid参数，可以指定connid来触发回调，如果connid为0那就是广播（给connection初始化connid的时候不能设置为0）
//data： 用户数据指针
//ret：返回值指针，NULL为异步，如果设置了就意味着同步发送 发送完毕后才返回。同步方式可以节省内存，异步发送需要新开辟内存
void mg_broadcast(struct mg_mgr *mgr, uint32_t connid, mg_event_handler_t cb, void *data, int *ret) {
  struct ctl_msg ctl_msg;
  /*
   * Mongoose manager has a socketpair, `struct mg_mgr::ctl`,
   * where `mg_broadcast()` pushes the message.
   * `mg_mgr_poll()` wakes up, reads a message from the socket pair, and calls
   * specified callback for each connection. Thus the callback function executes
   * in event manager thread.
   */
  if (mgr->ctl[0] != INVALID_SOCKET && data != NULL) {
    size_t dummy;

    ctl_msg.callback = cb;
	ctl_msg.connid = connid;
	if (ret)
		ctl_msg.syncflag = 1;
	ctl_msg.data = data;
	dummy = MG_SEND_FUNC(mgr->ctl[0], (char *)&ctl_msg, sizeof(ctl_msg), 0);
	dummy = MG_RECV_FUNC(mgr->ctl[0], (char *)&ctl_msg.syncflag, sizeof(int), 0);
    (void) dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */
	if (ret)
		*ret = ctl_msg.syncflag;
  }
}
static void mg_mgr_handle_ctl_sock(struct mg_mgr *mgr) {
	struct ctl_msg ctl_msg;
	size_t dummy;
	int ret = 1;
	int len = (int)MG_RECV_FUNC(mgr->ctl[1], (char *)&ctl_msg, sizeof(ctl_msg), 0);

	//不是同步执行 就立刻返回
	if (ctl_msg.syncflag == 0)
		dummy = MG_SEND_FUNC(mgr->ctl[1], (char *)&ret, sizeof(int), 0);
	
	DBG(("read %d from ctl socket", len));
	(void)dummy; /* https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509 */
	if (len >= (int) sizeof(ctl_msg.callback) && ctl_msg.callback != NULL) {
		struct mg_connection *nc;
		if (ctl_msg.connid == 0)
		{
			//先广播所有正常的连接
			for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) {
				ctl_msg.callback(nc, MG_EV_POLL,
					ctl_msg.data MG_UD_ARG(nc->user_data));
			}
			//最后发送一个nc为NULL的回调 表示广播结束了 用于清理内存等等
			ctl_msg.callback(NULL, MG_EV_POLL,
				ctl_msg.data MG_UD_ARG(nc->user_data));
		}
		else
		{
			for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc)) {
				if (nc->connid == ctl_msg.connid)
					break;
			}
			if (nc == NULL)
				ret = 0;
			ctl_msg.callback(nc, MG_EV_POLL,
				ctl_msg.data MG_UD_ARG(nc->user_data));
		}
	}

	//同步执行的情况下 执行完毕了 返回ret
	if (ctl_msg.syncflag)
		dummy = MG_SEND_FUNC(mgr->ctl[1], (char *)&ret, sizeof(int), 0);
}

增加connid参数，可以指定connid来触发回调，如果connid为0那就是广播到所有connection（给connection初始化connid的时候不能设置为0）。

增加异步、同步控制变量(int *ret)，传入NULL还为异步执行，如果设置了就意味着同步发送，发送完毕后才返回。同步方式可以节省内存，异步发送需要新开辟内存。

回调变动：

    指定connid：如果connection还活着，那么正常回调（一次），如果connection关闭了没了，那么回调的mg_connection*是个NULL，用于清理缓冲区

    未指定connid：广播到所有connection上，并且在所有connection回调完毕后，附加一次mg_connection*为NULL的广播，表示广播结束，用于清理缓冲区

小魔改：

上述保存connection的connid用的是mg_connection的user_data变量，但是我们实现业务肯定也有一堆数据要存储，而且不同类型的请求例如http和ws要保存的数据类型也不一样，区分处理很麻烦，随手魔改了mg_connection结构体，直接给他加上了connid这个变量。开始做第一版的时候，用了mg_connection结构体里面的sock这个变量作为connid，也就是socket的句柄，不过后来想想大并发下socket关闭后再建立新连接可能句柄是会重复的，那就失去唯一的作用了，所以新增了connid变量。

好啦，完事！

用压力测试跑了下几十个并发，对比发现低并发下跟其他库比如libevent差不多，满足要求。

=========================================================

2021.06.25更新

虽然上述的修改满足了要求，但是却修改了mongoose官方的代码，而且改动很细节，所以后来直接优化了一版，将上述的方法封装到了自己的C++代码中，mongoose直接引用官方6.18版本的代码即可，无需任何改动。

具体实现为自己封装了一个_broadcast方法，不魔改官方的mg_broadcast了。。。

void FHttpServer::_broadcast(uint32_t connID, void* data, BROADCAST_CALLBACK cb)
{
	MG_BROADCAST_MSG ctlmsg;
	ctlmsg.connid = connID;
	ctlmsg.callback = cb;
	ctlmsg.data = data;

	send(m_broadsender, (const char*)&ctlmsg, sizeof(ctlmsg), 0);
};

//内部使用方法是在线程里面发送数据的时候，通个回调函数的方式通过lambda封装丢到主线程里面去干活
	m_pServer->_broadcast(m_connID, pSendData, [](struct mg_connection* nc, void* data) {
		std::string* buf = (std::string*)data;
		if (nc)
			mg_send(nc, buf->c_str(), (int)buf->length());

		delete buf;
	});

=========================================================

=========================================================

2021.07.23更新

有朋友指出官方的6.18版本无法编译通过，发现还真的是有个结构体声明有问题，当时开发我拿的是假的6.18么？

根据官方最后的6.18版本，重新调整。。。

增加静态文件服务器模式StartFileServer方法，该方法不能与StartServer同时使用，二选一。静态文件本地路径要求是"/"分割，不能用windows的"\"。

例如StartFileServer("127.0.0.1:8686", "D:/");

=========================================================

完整代码(2021.07.23更新)：

需要依赖无锁队列库：https://github.com/cameron314/concurrentqueue

如果不开启ssl则无其他第三方依赖库。

C++11标准，编译器为vs2013。

FHttpServer.h

#pragma once

#include <string>
#include <chrono>
#include <vector>
#include <map>
#include <thread>
#include <mutex>
#include <functional>
#include "concurrentqueue/blockingconcurrentqueue.h" //from https://github.com/cameron314/concurrentqueue


//如果需要ssl支持，开启下面的宏
//#define MG_ENABLE_SSL 1

#include "mongoose.h"


typedef std::vector <std::pair<std::string, std::string>>  StringPairArray;


//每个连接的userdata
typedef struct
{
	uint32_t connID;
	std::string uri; //ws依赖 用于回调的map key
	std::string wsname;//ws依赖 用于广播 类似组名 可重复
}MG_CONNECT_USERDATA;


//多线程任务队列
typedef struct
{
	union socket_address saddr;
	//uint32_t connFlags;
	uint32_t connID;
	int event_type;

	std::string body; //如果是websocket 这里是data
	std::string method;
	std::string uri;
	std::string query;
	std::string proto;
	StringPairArray headers;
	int wsflags;  //ws frame事件中的flags
}MG_EVENT_DATA, * MG_EVENT_DATA_PTR;


class FHttpServer;


//http请求信息
class FHttpRequest
{
	//不可复制
	FHttpRequest(const FHttpRequest&) = delete;
	FHttpRequest& operator=(const FHttpRequest&) = delete;

	MG_EVENT_DATA_PTR m_pEventData;

public:
	FHttpRequest(MG_EVENT_DATA_PTR eventdata) : m_pEventData(eventdata) {};
	~FHttpRequest() {};

	uint32_t GetConnID();
	std::string GetURI();
	std::string GetMethod();
	std::string GetRemoteIP();
	//从url上面得到参数
	std::string GetQueryParam(const char* name);
	//从post的数据中得到参数
	std::string GetPostParam(const char* name);
	//读取header
	std::string GetHeader(const char* name);
	//读取所有header
	const StringPairArray& GetHeaders();
	std::string GetCookies();
	size_t GetDataLen();
	std::string GetData();

private:
	std::string GetParam(mg_str* query_string, const char* name);
};

//http返回值操作
class FHttpResponse
{
	//不可复制
	FHttpResponse(const FHttpResponse&) = delete;
	FHttpResponse& operator=(const FHttpResponse&) = delete;

	FHttpServer* m_pServer;
	uint32_t m_connID;
	int m_nStatusCode;
	std::string m_strStatus;
	StringPairArray* m_pDefaultHeaders;    //默认的返回headers
	StringPairArray m_arrHeaders;      //如果修改了，那么使用自己的副本

public:
	FHttpResponse(uint32_t connID, FHttpServer* pServer, StringPairArray* defaultHeaders);
	~FHttpResponse();
	//是否已经发送过返回值了
	bool m_bsenddata;

	//设置http返回code和reason，要在Send之前调用
	void SetHttpStatusCode(int nStatusCode, const char* reason);
	//设置header 唯一header名 要在Send之前调用
	void SetHttpHeader(const std::string& key, const std::string& value);
	//追加header，类似多个SetCookie这种头部 要在Send之前调用
	void AppendHttpHeader(const std::string& key, const std::string& value);

	//发送320转向
	void SetHttpRedirect(const std::string& rurl);

	//发送数据 直接发送
	void SendHttpContent(const std::string& data, const char* type = NULL);

	//以chunk方式发送数据，调用SendChunkContent发送数据，不要直接用SendContent
	void SendHttpChunkBegin();
	//发送chunk数据，结束chunk发送一个空buf
	void SendHttpChunkContent(const std::string& data);


private:
	void _SendData(const std::string* content);
	void _MakeResponseHeaders(std::string* data);
};

//websocket的消息信息
class FWSMessage
{
	MG_EVENT_DATA_PTR m_pEventData;

public:
	FWSMessage(MG_EVENT_DATA_PTR eventdata) : m_pEventData(eventdata) {};
	~FWSMessage() {};

	uint32_t GetConnID();
	std::string GetMsg();
	int GetFlag();
};

//websocket回话操作
class FWSSession
{
	FHttpServer* m_pServer;
	uint32_t m_connID;
public:
	FWSSession(uint32_t connID, FHttpServer* pServer) :
		m_connID(connID),
		m_pServer(pServer) {
	};
	~FWSSession() {};

	//设置该ws连接的name
	void SetName(const std::string& name);

	//发送websocket数据
	void SendFrameMsg(const std::string& data, int type = WEBSOCKET_OP_TEXT);

	//关闭连接
	void CloseConnect();
};

class FHttpServer
{
	//静态文件服务器
	struct mg_serve_http_opts m_mHttpServerOpts;
	//mg_serve_http_opts傻逼结构体用的是指针，还要保存下来字符串变量
	std::string m_strlocalpath;
	bool m_bisfileserver;

	struct mg_mgr m_mMgr;
	bool m_exitflag;

	//线程之间广播使用
	typedef void(*BROADCAST_CALLBACK)(struct mg_connection* nc, void* ev_data);
	typedef struct
	{
		BROADCAST_CALLBACK callback;
		uint32_t connid;  //connID，可以遍历指定的connection
		void* data;       //传递的数据
	}MG_BROADCAST_MSG;
	sock_t m_broadsender;

	uint32_t m_nSeqConnid;

	//默认的返回headers
	StringPairArray m_defaultHeaders;

	//工作线程和队列
	moodycamel::BlockingConcurrentQueue<MG_EVENT_DATA_PTR> m_TaskQueue;
	std::vector <std::thread> m_threadPool;

	//http回调方法和映射表
	typedef std::function<void(FHttpRequest&, FHttpResponse&)> funcHttpCallback;
	std::map <std::string, funcHttpCallback> m_mapHttpRouter;
	//websocket回调方法和映射表
	typedef std::function<void(FHttpRequest&, FWSSession&)> funcWSOnReadyCallback;
	typedef std::function<void(FWSMessage&, FWSSession&)> funcWSOnMsgCallback;
	typedef std::function<void(uint32_t)> funcWSOnCloseCallback;
	struct stWebSocketCallback
	{
		funcWSOnReadyCallback onready;
		funcWSOnMsgCallback onmessage;
		funcWSOnCloseCallback onclose;
	};
	std::map <std::string, stWebSocketCallback> m_mapWSRouter;

public:
	FHttpServer();
	~FHttpServer();

	bool StartFileServer(const std::string& addr, const std::string& localpath);
	//启动服务 addr可以是"8888", ":8888", "127.0.0.1:8888"; nThread为工作线程数
	bool StartServer(const std::string& addr, int nThread);
	//停止服务
	void StopServer();
	//添加默认返回的http头，唯一值
	void AddDefaultHeader(const std::string& key, const std::string& value);
	//添加http回调接口
	void AddHttpHandler(const std::string& uri, funcHttpCallback callback);
	//添加websocket回调接口
	void AddWSHandler(const std::string& uri,
		funcWSOnReadyCallback onready,
		funcWSOnMsgCallback onmessage,
		funcWSOnCloseCallback onclose);

	//////////////////////////////////////////////////////////////////////////
	//websocket使用的接口
	//////////////////////////////////////////////////////////////////////////
	//发送数据到connID这个ws连接上
	void SendWSFrame(uint32_t connID, const std::string& data, int type = WEBSOCKET_OP_TEXT);
	//关闭ws连接
	void CloseWSConn(uint32_t connID);
	//广播数据到name这个组
	void BroadcastWS(const std::string& name, const std::string& data, int type = WEBSOCKET_OP_TEXT);
	//////////////////////////////////////////////////////////////////////////


	//内部使用的接口，外部不要调用
	void _settaskquque(MG_EVENT_DATA_PTR eventdata);
	bool _ishttphandler(const std::string& uri);
	bool _iswshandler(const std::string& uri);
	bool _isstop();
	void _broadcast(uint32_t connID, void* data, BROADCAST_CALLBACK cb);

private:
	static void onEventCallback(mg_connection* nc, int event_type, void* event_data);
	void TaskQuqueRunner();
	void WorkEventHandler(MG_EVENT_DATA_PTR eventdata);
};

FHttpServer.cpp

#include "stdafx.h"
#include "FHttpServer.h"


#define     is_websocket(nc)        (nc->flags & MG_F_IS_WEBSOCKET)
#define     MG_REQUEST_MAXLENGTH    10 * 1024 * 1024   //10M

FHttpServer::FHttpServer()
{
	mg_mgr_init(&m_mMgr, this);

	m_bisfileserver = false;
	m_nSeqConnid = 1;
	m_exitflag = false;

	//默认返回的http头
	AddDefaultHeader("Content-Type", "text/plain; charset=GBK");
	AddDefaultHeader("Connection", "Keep-Alive");
}


FHttpServer::~FHttpServer()
{
	StopServer();
}

bool FHttpServer::StartFileServer(const std::string& addr, const std::string& localpath)
{
	m_strlocalpath = localpath;
	memset(&m_mHttpServerOpts, 0, sizeof(struct mg_serve_http_opts));
	m_mHttpServerOpts.document_root = m_strlocalpath.c_str();
	m_mHttpServerOpts.enable_directory_listing = "yes";

	m_bisfileserver = true;
	return StartServer(addr, 1);
}

bool FHttpServer::StartServer(const std::string& addr, int nThread)
{
	//mg_connection *connection = mg_bind(&m_mMgr, addr.c_str(), FHttpServer::OnEventHandler, this);
	mg_connection* connection = mg_bind(&m_mMgr, addr.c_str(), onEventCallback);
	if (connection == NULL)
	{
		printf("listen server %s err.\n", addr.c_str());
		return false;
	}

	//     mg_register_http_endpoint(connection, "/upload", [](struct mg_connection *nc, int ev, void *p){
	//         struct mg_http_multipart_part *mp = (struct mg_http_multipart_part *) p;
	//         printf("endpoint eventtype:%d \n", ev, mp->status);
	//     });

		//用于异步通知主线程干活 不修改mongoose源码模拟和扩展mg_broadcast方法
	mg_connection* udprecv = mg_bind(&m_mMgr, "udp://127.0.0.1:0", [](mg_connection* nc, int event_type, void* event_data)
	{
		if (event_type == MG_EV_RECV)
		{
			struct mbuf* io = &nc->recv_mbuf;
			if (io->len == sizeof(MG_BROADCAST_MSG))
			{
				MG_BROADCAST_MSG* pctlmsg = (MG_BROADCAST_MSG*)io->buf;
				if (pctlmsg->callback != NULL)
				{

					struct mg_mgr* mgr = nc->mgr;
					struct mg_connection* nc;
					if (pctlmsg->connid == 0)
					{
						//先广播所有正常的连接
						for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc))
						{
							if (nc->user_data)
								pctlmsg->callback(nc, pctlmsg->data);
						}
						//最后发送一个nc为NULL的回调 表示广播结束了 用于清理内存等等
						pctlmsg->callback(NULL, pctlmsg->data);
					}
					else
					{
						for (nc = mg_next(mgr, NULL); nc != NULL; nc = mg_next(mgr, nc))
						{
							if (nc->user_data && ((MG_CONNECT_USERDATA*)nc->user_data)->connID == pctlmsg->connid)
								break;
						}
						pctlmsg->callback(nc, pctlmsg->data);
					}
				}
			}

			// In case of UDP, Mongoose creates new virtual connection for
			// incoming messages
			// We can keep it (and it will be reused for another messages from
			// the same address) or we can close it (this saves some memory, but
			// decreases perfomance, because it forces creation of connection
			// for every incoming dgram)
			nc->flags |= MG_F_SEND_AND_CLOSE;
			// Discard message from recv buffer
			mbuf_remove(io, io->len);

		}//eventhandler
	});
	if (udprecv == NULL)
	{
		printf("listen broadcase channel err.\n");
		return false;
	}
	//建立发送者
	union socket_address broadrecvsa;
	socklen_t len = sizeof(broadrecvsa.sin);
	getsockname(udprecv->sock, &broadrecvsa.sa, &len);
	//建立发送者的udp socket
	union socket_address udpsasender;
	memset(&udpsasender, 0, sizeof(udpsasender));
	len = sizeof(udpsasender.sin);
	udpsasender.sin.sin_family = AF_INET;
	udpsasender.sin.sin_addr.s_addr = htonl(0x7f000001); /* 127.0.0.1 */
	m_broadsender = socket(AF_INET, SOCK_DGRAM, 0);
	if (m_broadsender == INVALID_SOCKET)
	{
		printf("make broadcase channel err.\n");
		return false;
	}
	if (bind(m_broadsender, &udpsasender.sa, len) != 0)
	{
		printf("bind broadcase channel err.\n");
		return false;
	}
	if (connect(m_broadsender, &broadrecvsa.sa, len) != 0)
	{
		printf("connect broadcase channel err.\n");
		return false;
	}

	//both http and websocket
	mg_set_protocol_http_websocket(connection);

	//初始化工作队列
	for (int i = 0; i < nThread; i++)
		m_threadPool.emplace_back(&FHttpServer::TaskQuqueRunner, this);

	std::thread([this] {
		// loop
		while (!m_exitflag)
			mg_mgr_poll(&m_mMgr, 200); // ms
	}).detach();

	printf("started server on: %s(tid:%d)\n", addr.c_str(), GetCurrentThreadId());

	return true;
}

void FHttpServer::StopServer()
{
	if (m_exitflag)
		return;

	printf("set stop flag.\n");
	m_exitflag = true;

	printf("wait for work thread finish...\n");
	for (std::thread& th : m_threadPool)
	{
		if (th.joinable())
			th.join();
	}

	printf("free mgr.\n");
	mg_mgr_free(&m_mMgr);

	printf("server stopped.");
}

void FHttpServer::AddDefaultHeader(const std::string& key, const std::string& value)
{
	for (auto& header : m_defaultHeaders)
	{
		if (mg_ncasecmp(key.c_str(), header.first.c_str(), key.length()) == 0)
		{
			header.second = value;
			return;
		}
	}

	m_defaultHeaders.emplace_back(key, value);
}

void FHttpServer::AddHttpHandler(const std::string& uri, funcHttpCallback callback)
{
	m_mapHttpRouter.emplace(uri, callback);
}

void FHttpServer::AddWSHandler(const std::string& uri,
	funcWSOnReadyCallback onready,
	funcWSOnMsgCallback onmessage,
	funcWSOnCloseCallback onclose)
{
	stWebSocketCallback cb = { onready, onmessage, onclose };
	m_mapWSRouter.emplace(uri, cb);
}

void FHttpServer::SendWSFrame(uint32_t connID, const std::string& data, int type /*= WEBSOCKET_OP_TEXT*/)
{
	return FWSSession(connID, this).SendFrameMsg(data, type);
}

void FHttpServer::CloseWSConn(uint32_t connID)
{
	FWSSession(connID, this).CloseConnect();
}

void FHttpServer::BroadcastWS(const std::string& name, const std::string& data, int type /*= WEBSOCKET_OP_TEXT*/)
{
	struct wsData
	{
		int type;
		std::string name;
		std::string buf;
	};
	wsData* param = new wsData{ type, name, data };

	//传入connid为0，广播到所有nc上
	_broadcast(0, param, [](struct mg_connection* nc, void* data) {
		if (nc)
		{
			if (is_websocket(nc))
			{
				wsData* p = (wsData*)data;
				MG_CONNECT_USERDATA* pUserdata = (MG_CONNECT_USERDATA*)nc->user_data;
				if (pUserdata->wsname == p->name)
					mg_send_websocket_frame(nc, p->type, p->buf.c_str(), p->buf.length());
			}
		}
		else
		{
			//nc为NULL就是广播完毕了 这类清理内存
			delete ((wsData*)data);
		}
	});
}

void FHttpServer::_settaskquque(MG_EVENT_DATA_PTR eventdata)
{
	m_TaskQueue.enqueue(eventdata);
}

bool FHttpServer::_ishttphandler(const std::string& uri)
{
	if (m_mapHttpRouter.find(uri) == m_mapHttpRouter.end())
		return false;
	return true;
}

bool FHttpServer::_iswshandler(const std::string& uri)
{
	if (m_mapWSRouter.find(uri) == m_mapWSRouter.end())
		return false;
	return true;
}

void FHttpServer::_broadcast(uint32_t connID, void* data, BROADCAST_CALLBACK cb)
{
	MG_BROADCAST_MSG ctlmsg;
	ctlmsg.connid = connID;
	ctlmsg.callback = cb;
	ctlmsg.data = data;

	send(m_broadsender, (const char*)&ctlmsg, sizeof(ctlmsg), 0);
};

bool FHttpServer::_isstop()
{
	return m_exitflag;
}

//单线程回调函数
void FHttpServer::onEventCallback(mg_connection* nc, int event_type, void* event_data)
{
	FHttpServer* pServer = (FHttpServer*)nc->mgr->user_data;
	MG_CONNECT_USERDATA* pUserData = (MG_CONNECT_USERDATA*)nc->user_data;

	//debug
   //if (event_type != MG_EV_POLL)
	//  printf("EventCallback(%d): type:%d, sockid:%d\n", GetCurrentThreadId(), event_type, (pUserData ? pUserData->connID : 0));
//     if (event_type == MG_EV_RECV)
//     {
//         struct mbuf *io = &nc->recv_mbuf;
//         WriteBufferToFile("request.txt", io->buf, io->len, TRUE);
//     }

	//连接上后 创建出来connid等信息
	if (event_type == MG_EV_ACCEPT)
	{
		pUserData = new MG_CONNECT_USERDATA;
		pUserData->connID = pServer->m_nSeqConnid;

		nc->user_data = pUserData;
		//数据包最大限制
		//nc->recv_mbuf_limit = pServer->m_HttpMaxLength;

		pServer->m_nSeqConnid++;
		//connid使用0来标记 所以要+1
		if (pServer->m_nSeqConnid == 0)
			pServer->m_nSeqConnid++;

		return;
	}

	//关闭事件 清理user_data
	if (event_type == MG_EV_CLOSE)
	{
		if (is_websocket(nc))
		{
			//websocket的话要回调
			MG_EVENT_DATA_PTR cbdata = new MG_EVENT_DATA;
			cbdata->event_type = event_type;
			cbdata->connID = pUserData->connID;
			cbdata->uri = pUserData->uri;

			pServer->_settaskquque(cbdata);
		}

		//删掉user_data
		delete pUserData;
		nc->user_data = NULL;

		return;
	}


	//http请求和websocket握手完毕 要读取http request信息
	if (event_type == MG_EV_HTTP_REQUEST ||
		event_type == MG_EV_WEBSOCKET_HANDSHAKE_REQUEST ||
		event_type == MG_EV_WEBSOCKET_HANDSHAKE_DONE ||
		event_type == MG_EV_WEBSOCKET_FRAME)
	{
		if (event_type == MG_EV_HTTP_REQUEST)
		{
			if (pServer->m_bisfileserver)
			{
				mg_serve_http(nc, (http_message*)event_data, pServer->m_mHttpServerOpts);
				return;
			}

			//处理映射表 不在映射表的就不加入队列了
			std::string uri;
			uri.assign(((http_message*)event_data)->uri.p, ((http_message*)event_data)->uri.len);
			auto iter = pServer->m_mapHttpRouter.find(uri);
			if (iter == pServer->m_mapHttpRouter.end())
			{
				//不支持的uri映射 返回403吧
				mg_http_send_error(nc, 403, "Not Support.");
				return;
			}
		}
		else if (event_type == MG_EV_WEBSOCKET_HANDSHAKE_REQUEST)
		{
			//处理映射表 不在映射表的就不加入队列了
			std::string uri;
			uri.assign(((http_message*)event_data)->uri.p, ((http_message*)event_data)->uri.len);
			auto iter = pServer->m_mapWSRouter.find(uri);
			if (iter == pServer->m_mapWSRouter.end())
			{
				//不支持的uri映射 返回403吧
				mg_http_send_error(nc, 403, "Not Support.");
			}

			return;
		}

		MG_EVENT_DATA_PTR cbdata = new MG_EVENT_DATA;
		cbdata->event_type = event_type;
		cbdata->connID = pUserData->connID;

		if (event_type == MG_EV_WEBSOCKET_FRAME)
		{
			websocket_message* wsmsg = (websocket_message*)event_data;
			cbdata->body.assign((char*)wsmsg->data, wsmsg->size);
			cbdata->wsflags = wsmsg->flags;
			//从user_data里面读取uri
			cbdata->uri = pUserData->uri;
		}
		else
		{
			http_message* httpmsg = (http_message*)event_data;

			//用于读取远程IP
			cbdata->saddr = nc->sa;

			//http request信息
			cbdata->body.assign(httpmsg->body.p, httpmsg->body.len);
			cbdata->method.assign(httpmsg->method.p, httpmsg->method.len);
			cbdata->uri.assign(httpmsg->uri.p, httpmsg->uri.len);
			cbdata->query.assign(httpmsg->query_string.p, httpmsg->query_string.len);
			cbdata->proto.assign(httpmsg->proto.p, httpmsg->proto.len);
			for (int i = 0; i < MG_MAX_HTTP_HEADERS; i++)
			{
				if (httpmsg->header_names[i].len == 0)
					break;
				cbdata->headers.emplace_back(std::string(httpmsg->header_names[i].p, httpmsg->header_names[i].len), std::string(httpmsg->header_values[i].p, httpmsg->header_values[i].len));
			}

			//ws默认name就是uri 可用于广播
			if (event_type == MG_EV_WEBSOCKET_HANDSHAKE_DONE)
				pUserData->wsname = pUserData->uri = cbdata->uri;
		}

		//printf("AddEvent Data(%d): %d\n", GetCurrentThreadId(), cbdata->event_type);
		pServer->_settaskquque(cbdata);
	}
}

void FHttpServer::TaskQuqueRunner()
{
	while (true)
	{
		//结束标记，退出线程
		if (m_exitflag)
			break;

		MG_EVENT_DATA_PTR eventdata;
		if (m_TaskQueue.wait_dequeue_timed(eventdata, std::chrono::seconds(1)))
		{
			//printf("TaskQuque Get Data(%d): %d\n", GetCurrentThreadId(), eventdata->event_type);
			WorkEventHandler(eventdata);

			//用完了要删掉
			delete eventdata;
		}
		else
		{
			//printf("Empty quque.\n");
		}
	}

	return;
}

void FHttpServer::WorkEventHandler(MG_EVENT_DATA_PTR eventdata)
{
	//printf("WorkHandler Data(%d): %d\n", GetCurrentThreadId(), eventdata->event_type);

	if (eventdata->event_type == MG_EV_HTTP_REQUEST)
	{
		//普通http请求
		 //OnHttpHandler(eventdata);

		 //准备变量
		FHttpRequest request(eventdata);
		FHttpResponse response(eventdata->connID, this, &m_defaultHeaders);

		//回调
		m_mapHttpRouter[eventdata->uri](request, response);
		return;
	}

	//剩下的都是ws的事件了
	stWebSocketCallback wsCB = m_mapWSRouter[eventdata->uri];
	if (eventdata->event_type == MG_EV_WEBSOCKET_HANDSHAKE_DONE && wsCB.onready)
	{
		FHttpRequest req(eventdata);
		FWSSession wssession(eventdata->connID, this);
		wsCB.onready(req, wssession);
	}
	else if (eventdata->event_type == MG_EV_WEBSOCKET_FRAME && wsCB.onmessage)
	{
		FWSMessage wsmsg(eventdata);
		FWSSession wssession(eventdata->connID, this);
		wsCB.onmessage(wsmsg, wssession);
	}
	else if (eventdata->event_type == MG_EV_CLOSE && wsCB.onclose)
	{
		wsCB.onclose(eventdata->connID);
	}
}

uint32_t FHttpRequest::GetConnID()
{
	return m_pEventData->connID;
}

std::string FHttpRequest::GetURI()
{
	return m_pEventData->uri;
}

std::string FHttpRequest::GetMethod()
{
	return m_pEventData->method;
}

std::string FHttpRequest::GetRemoteIP()
{
	char addr[32];
	mg_sock_addr_to_str(&m_pEventData->saddr, addr, sizeof(addr), MG_SOCK_STRINGIFY_IP);
	return std::string(addr);
}

std::string FHttpRequest::GetParam(mg_str* query_string, const char* name)
{
	char value[128];
	int ret = mg_get_http_var(query_string, name, value, sizeof(value) - 1);
	if (ret <= 0)
		return std::string();
	if (ret < sizeof(value))
		return std::string(value, ret);

	//数据过长了
	std::unique_ptr<char> buf(new char[ret + 1]);
	ret = mg_get_http_var(query_string, name, buf.get(), ret + 1);
	return std::string(buf.get(), ret);
}

std::string FHttpRequest::GetQueryParam(const char* name)
{
	mg_str query_string;
	query_string.p = m_pEventData->query.c_str();
	query_string.len = m_pEventData->query.length();
	return GetParam(&query_string, name);
}

std::string FHttpRequest::GetPostParam(const char* name)
{
	mg_str query_string;
	query_string.p = m_pEventData->body.c_str();
	query_string.len = m_pEventData->body.length();
	return GetParam(&query_string, name);
}

std::string FHttpRequest::GetHeader(const char* name)
{
	for (auto& header : m_pEventData->headers)
	{
		if (mg_ncasecmp(name, header.first.c_str(), header.first.length()) == 0)
			return header.second;
	}

	return std::string();
}

const StringPairArray& FHttpRequest::GetHeaders()
{
	return m_pEventData->headers;
}

std::string FHttpRequest::GetCookies()
{
	return GetHeader("Cookie");
}

size_t FHttpRequest::GetDataLen()
{
	return m_pEventData->body.length();
}

std::string FHttpRequest::GetData()
{
	return m_pEventData->body;
}

FHttpResponse::FHttpResponse(uint32_t connID, FHttpServer* pServer, StringPairArray* defaultHeaders) :
	m_connID(connID),
	m_pServer(pServer),
	m_nStatusCode(200),
	m_strStatus("OK"),
	m_pDefaultHeaders(defaultHeaders),
	m_bsenddata(false)
{

}

FHttpResponse::~FHttpResponse()
{
	if (!m_bsenddata)
		SendHttpContent(std::string());
}

void FHttpResponse::SetHttpStatusCode(int nStatusCode, const char* reason)
{
	m_nStatusCode = nStatusCode;
	m_strStatus = reason;
}

void FHttpResponse::SetHttpHeader(const std::string& key, const std::string& value)
{
	//修改了header 就建立自己的副本
	if (m_pDefaultHeaders)
	{
		m_arrHeaders = *m_pDefaultHeaders;
		m_pDefaultHeaders = NULL;
	}

	for (auto& header : m_arrHeaders)
	{
		if (mg_ncasecmp(key.c_str(), header.first.c_str(), key.length()) == 0)
		{
			header.second = value;
			return;
		}
	}

	m_arrHeaders.emplace_back(key, value);
}

void FHttpResponse::AppendHttpHeader(const std::string& key, const std::string& value)
{
	//修改了header 就建立自己的副本
	if (m_pDefaultHeaders)
	{
		m_arrHeaders = *m_pDefaultHeaders;
		m_pDefaultHeaders = NULL;
	}

	m_arrHeaders.emplace_back(key, value);
}

void FHttpResponse::SetHttpRedirect(const std::string& rurl)
{
	m_bsenddata = true;

	m_pServer->_broadcast(m_connID, new std::string(rurl), [](struct mg_connection* nc, void* data) {
		std::string* rurl = (std::string*)data;
		if (nc)
			mg_http_send_redirect(nc, 302, mg_mk_str(rurl->c_str()), mg_mk_str(NULL));

		delete rurl;
	});
}

void FHttpResponse::SendHttpContent(const std::string& data, const char* type /*= NULL*/)
{
	if (type)
		SetHttpHeader("Content-Type", type);

	_SendData(&data);
}

void FHttpResponse::SendHttpChunkBegin()
{
	_SendData(NULL);
}

void FHttpResponse::SendHttpChunkContent(const std::string& data)
{
	m_pServer->_broadcast(m_connID, new std::string(data), [](struct mg_connection* nc, void* data) {
		std::string* buf = (std::string*)data;
		if (nc)
			mg_send_http_chunk(nc, buf->c_str(), buf->length());

		delete buf;
	});
}

void FHttpResponse::_MakeResponseHeaders(std::string* data)
{
	//拼接header
	StringPairArray* headers = m_pDefaultHeaders;
	if (headers == NULL)
		headers = &m_arrHeaders;
	size_t nHeanderSize = headers->size();
	for (size_t i = 0; i < nHeanderSize; i++)
	{
		std::string str = headers->at(i).first + ": " + headers->at(i).second + "\r\n";
		data->append(str);
	}
}

void FHttpResponse::_SendData(const std::string* content)
{
	//不要重复发送
	if (m_bsenddata)
		return;

	std::string* pSendData = new std::string("HTTP/1.1 " + std::to_string(m_nStatusCode) + " " + m_strStatus + "\r\n");
	_MakeResponseHeaders(pSendData);

	if (content == NULL)
	{
		//开启了chunk模式
		pSendData->append("Transfer-Encoding: chunked\r\n\r\n");
	}
	else
	{
		//有Content
		pSendData->append("Content-Length: " + std::to_string(content->length()) + "\r\n\r\n");

		//拼接数据
		pSendData->append(*content);
	}

	//发送 要用mg_broadcast来完成回调 异步发送
	m_pServer->_broadcast(m_connID, pSendData, [](struct mg_connection* nc, void* data) {
		std::string* buf = (std::string*)data;
		if (nc)
			mg_send(nc, buf->c_str(), (int)buf->length());

		delete buf;
	});

	m_bsenddata = true;
}

uint32_t FWSMessage::GetConnID()
{
	return m_pEventData->connID;
}

std::string FWSMessage::GetMsg()
{
	return m_pEventData->body;
}

int FWSMessage::GetFlag()
{
	return m_pEventData->wsflags;
}

void FWSSession::SetName(const std::string& name)
{
	m_pServer->_broadcast(m_connID, new std::string(name), [](struct mg_connection* nc, void* data) {
		std::string* name = (std::string*)data;
		if (nc)
			((MG_CONNECT_USERDATA*)nc->user_data)->wsname = *name;

		delete name;
	});
}

void FWSSession::SendFrameMsg(const std::string& data, int type /*= WEBSOCKET_OP_TEXT*/)
{
	int ret = 0;
	struct wsData
	{
		int type;
		std::string buf;
	};
	wsData* param = new wsData{ type, data };

	//需要返回值 所以使用同步的方式发送
	m_pServer->_broadcast(m_connID, param, [](struct mg_connection* nc, void* data) {
		wsData* p = (wsData*)data;
		if (nc)
			mg_send_websocket_frame(nc, p->type, p->buf.c_str(), p->buf.length());

		delete p;
	});
}

void FWSSession::CloseConnect()
{
	m_pServer->_broadcast(m_connID, NULL, [](struct mg_connection* nc, void* data) {
		if (nc)
			mg_send_websocket_frame(nc, WEBSOCKET_OP_CLOSE, "bye", 3);
	});
}

最后使用方法：

	FHttpServer server;
	server.AddHttpHandler("/hello", [](FHttpRequest& req, FHttpResponse& response) {
		printf("uri:%s\n", req.GetURI().c_str());
		printf("remote:%s\n", req.GetRemoteIP().c_str());
		printf("method:%s\n", req.GetMethod().c_str());
		printf("p:%s\n", req.GetQueryParam("p").c_str());
		printf("header host:%s\n", req.GetHeader("Host").c_str());
		//所有headers
		printf("headers:\n");
		for (const auto& header : req.GetHeaders())
		{
			printf("\t%s:%s\n", header.first.c_str(), header.second.c_str());
		}
		printf("body(%d):%s\n", req.GetDataLen(), req.GetData().c_str());

		response.SendHttpContent("hello word!");
	});

	uint32_t connID = -1;
	server.AddWSHandler("/ws", [&](FHttpRequest& req, FWSSession& session)
	{
		//websocket握手完毕连接建立
		printf("ws on ready %s.\n", req.GetQueryParam("id").c_str());
		session.SendFrameMsg("ready.");
		session.SetName(req.GetQueryParam("id"));
		connID = req.GetConnID();
	}, [](FWSMessage& req, FWSSession& session)
	{
		//接收到websocket消息
		printf("body:%s\n", req.GetMsg().c_str());
		session.SendFrameMsg(req.GetMsg());
	},[](uint32_t connID)
	{
		printf("ws on close.\n");
	});

	//不阻塞，返回bool
	server.StartServer("8881", 32);

	while (true)
	{
		int x = getchar();
		if (x == 'q')
			break;

		//向已连接的websocket客户端发送数据，支持多线程调用发送数据
		server.SendWSFrame(connID, "hello");

		//支持websocket组广播
		server.BroadcastWS("123", "broadcase msg.");
	}

	server.StopServer();	

访问：

http://127.0.0.1:8881/hello?p=123

输出：

 uri:/hello

 remote:127.0.0.1

 method:GET

 p:123

 header host:127.0.0.1:8881

 headers:

    Host:127.0.0.1:8881

    Connection:keep-alive

    sec-ch-ua:"Google Chrome";v="131", "Chromium";v="131", "Not_A Brand";v="24"

    sec-ch-ua-mobile:?0

    sec-ch-ua-platform:"Windows"

    DNT:1

    Upgrade-Insecure-Requests:1

    User-Agent:Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36

    Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7

    Sec-Fetch-Site:none

    Sec-Fetch-Mode:navigate

    Sec-Fetch-User:?1

    Sec-Fetch-Dest:document

    Accept-Encoding:gzip, deflate, br, zstd

    Accept-Language:zh-CN,zh;q=0.9

 body(0):