POCO C++ Libraies属于功能广泛、轻量级别的开源框架库，它拥有媲美Boost库的功能以及较小的体积广泛应用在物联网平台、工业自动化等领域。
POCO C++ Libraies由多个功能模块组成，其中包括网络、多线程、日志、命令行程序等。POCO官方拥有众多模块的使用示例，可以在短时间内上手并完成相关功能。
官方网址：POCO官方
官方文档：POCO文档
函数用法：POCO函数用法
介绍(引自官方)：
POCO C++库是开源C++类库的集合，这些库简化并加速了C++中以网络为中心的可移植应用程序的开发。这些库与C++标准库完美集成，并填补了它遗留的许多功能空白。它们的模块化，高效的设计和实现使POCO C++库非常适合嵌入式开发，因为C++编程语言同时适用于底层（设备I / O，中断处理程序等），因此C++编程语言正变得越来越流行。 。）和高级面向对象的开发。当然，POCO也已准备好应对企业级挑战。
POCO由四个核心库和许多附加库组成。核心库是Foundation，XML，Util和Net。附加库中的两个是NetSSL（为Net库中的网络类提供SSL支持）和Data（一个用于统一访问不同SQL数据库的库）。POCO旨在实现以网络为中心的跨平台C++软件开发，而Apple的Cocoa则是用于Mac开发，而Ruby on Rails则是用于Web开发，这是一个功能强大且易于使用的有趣平台，可用于构建您的应用程序。POCO严格使用标准ANSI / ISO C++（包括标准库）构建。贡献者试图在使用高级C++功能与保持类可理解以及代码干净，一致和易于维护之间找到一个良好的平衡。
PocoNet：
介绍：
PocoNet属于网络相关框架，集成功能有：
HTTP(TCP)服务器及客户端，HTTP(UDP)服务器以及DNS域名解析等。
PocoNet常用头定义及命名空间：
#include “Poco/Net/SocketAddress.h”
#include “Poco/Net/StreamSocket.h”
#include “Poco/Net/SocketStream.h”
#include “Poco/StreamCopier.h”
#include “Poco/Net/DNS.h”
using Poco::Net::DNS;
using Poco::Net::IPAddress;
using Poco::Net::HostEntry;
使用PocoNet框架需要包含库名：
PocoFoundation
PocoNet
HTTP(TCP)服务器启动方式：
Poco::Net::ServerSocket srv("www.test.com",8080);
for ( ; ; )
{
Poco::Net::StreamSocket ss = srv.acceptConnection();
Poco::Net::SocketStream str(ss);
str << "HTTP/1.0 200 OK\r\n"
"Content-Type: text/html\r\n"
"\r\n"
"<html><head><title>Server..</title></head>"
"<body><h1>Hello world</h1></body></html>"
<< std::flush;
usleep(1);
}
HTTP(UDP)服务器启动方式：
Poco::Net::SocketAddress socketAddress("www.test.com",8080);
Poco::Net::DatagramSocket datagram(socketAddress);
char buffer[1024];
for ( ; ; )
{
Poco::Net::SocketAddress sender;
int n = datagram.receiveFrom(buffer, sizeof(buffer) - 1, sender);
buffer[n] = '\0';
std::cout << sender.toString() << ": " << buffer << std::endl;
usleep(1);
}
HTTP客户端编写方式：
.h文件
class LPoco
{
public:
/*******************************************************************************/
//创建一个Tcp连接到服务器
Poco::Net::SocketAddress LCtSocketToServer(std::string http,int port);
//使用::Net::SocketStream类,它提供了一个I / O流StreamSocket接口
Poco::Net::StreamSocket LRwStreamSocket(Poco::Net::SocketAddress socket);
//format 流格式 比如xml ->
/*str << "GET / HTTP/1.1\r\n"
"Host: www.test.com\r\n"
"\r\n";*/
//拷贝流数据 使用内部缓冲区将从istr读取的所有字节写入std::ostream ostr
void LCopyStream(Poco::Net::StreamSocket stream,std::string format,std::ostream & ostr, std::size_t bufferSize = 8192);
//拷贝流数据 使用内部缓冲区将从istr读取的所有字节写入string ostr
std::string LCopyString(Poco::Net::StreamSocket stream,std::string format,std::string & ostr, std::size_t bufferSize = 8192);
/********************************************************************************/
};
.cpp文件
//创建一个Tcp连接到服务器
Poco::Net::SocketAddress LPoco::LCtSocketToServer(std::string http,int port)
{
Poco::Net::SocketAddress sa(http, port);
return sa;
}
//使用::Net::SocketStream类,它提供了一个I / O流StreamSocket接口
Poco::Net::StreamSocket LPoco::LRwStreamSocket(Poco::Net::SocketAddress socket)
{
Poco::Net::StreamSocket str(socket);
return str;
}
//format 流格式 比如xml ->
/*str << "GET / HTTP/1.1\r\n"
"Host: www.test.com\r\n"
"\r\n";*/
//拷贝流数据 使用内部缓冲区将从istr读取的所有字节写入ostr
void LPoco::LCopyStream(Poco::Net::StreamSocket stream,std::string format,std::ostream & ostr, std::size_t bufferSize)
{
Poco::Net::SocketStream Socket(stream);
Socket << format;
Socket.flush();
Poco::StreamCopier::copyStream(Socket, /*std::cout*/ostr,bufferSize);
}
//拷贝流数据 使用内部缓冲区将从istr读取的所有字节写入string ostr
std::string LPoco::LCopyString(Poco::Net::StreamSocket stream,std::string format,std::string & ostr, std::size_t bufferSize)
{
Poco::Net::SocketStream Socket(stream);
Socket << format;
Socket.flush();
Poco::StreamCopier::copyToString(Socket,ostr,bufferSize);
return ostr;
}
方法调用：
LPoco m_poco;
Poco::Net::SocketAddress stream = m_poco.LCtSocketToServer("www.test.com", 8080);
Poco::Net::StreamSocket socket = m_poco.LRwStreamSocket(stream);
std::string ostr;
m_poco.LCopyString(socket,"GET / HTTP/1.1\r\n"
"Host: www.test.com\r\n"
"\r\n",ostr);
std::cout << ostr << std::endl;
DNS域名解析方式：
const HostEntry& entry = DNS::hostByName("www.appinf.com");
//获取别名
const HostEntry::AliasList& aliases = entry.aliases();
HostEntry::AliasList::const_iterator it = aliases.begin();
int nNum = 0;
for (; it != aliases.end(); ++it)
{
std::cout << "Alias: " << *it << "" << ++nNum << std::endl;
}
//获取地址
nNum = 0;
const HostEntry::AddressList& addrs = entry.addresses();
HostEntry::AddressList::const_iterator it1 = addrs.begin();
for (; it1 != addrs.end(); ++it1)
{
std::cout << "Address: " << it1->toString() << " " << nNum++ << std::endl;
}
PocoFoundation：
介绍(引自官方)：
PocoFoundation是POCO的核心。它包含基础平台抽象层以及常用的实用程序类和功能。Foundation库包含用于固定大小整数的类型，用于在字节顺序之间转换整数的函数，Poco :: Any类（基于boost :: Any），用于错误处理和调试的实用程序，包括各种异常类和对断言的支持。还提供了许多用于内存管理的类，包括基于引用计数的智能指针，以及用于缓冲区管理和内存池的类。对于字符串处理，POCO包含许多功能，其中包括修剪字符串，执行不区分大小写的比较和大小写转换。还可以通过类的形式获得对Unicode文本的基本支持，这些类可以在不同的字符编码（包括UTF-8和UTF-16）之间转换文本。那里支持格式化和解析数字，包括sprintf的类型安全变体。还提供了基于众所周知的PCRE库（http://www.pcre.org）的正则表达式。
PocoFoundation常用头定义：
#include “Poco/Logger.h”
#include “Poco/AutoPtr.h”
#include “Poco/ConsoleChannel.h”
#include “Poco/PatternFormatter.h”
#include “Poco/FormattingChannel.h”
#include “Poco/SimpleFileChannel.h”
#include “Poco/LocalDateTime.h”
#include “Poco/Message.h”
使用PocoFoundation框架需要包含库名：
PocoFoundation
Poco日志(封装后的函数)：
.h文件
#include "Poco/Logger.h"
#include "Poco/AutoPtr.h"
#include "Poco/ConsoleChannel.h"
#include "Poco/PatternFormatter.h"
#include "Poco/FormattingChannel.h"
#include "Poco/SimpleFileChannel.h"
#include "Poco/LocalDateTime.h"
#include "Poco/Message.h"
#include <iostream>
#include <string>
#include <sstream>
#include <stdio.h>
#include <stdlib.h>
#include <map>
#include<ctype.h>
#include<string.h>
#include <cstdarg>
#define PATH "/works/examples"
#define NAME "poco_log"
#define SUFFIX ".log"
//日志是否有效写入，如果为false直接返回
#define LOGVALID true
void init_logger(const std::string app_name,
const std::string app_version,
bool use_console_log = true,
bool file_log = true,
const std::string target = "./log",
std::string loglevel = "information",
int64_t rotation_size = 10 * 1024 * 1024,
bool auto_flush = true);
struct LoggerInfo
{
std::string app_name;
std::string app_version;
bool use_console_log;
bool file_log;
std::string target;
std::string loglevel;
int64_t rotation_size;
bool auto_flush;
};
class poco_log
{
public:
poco_log();
//传入日志路径和名称，其中日志路径可以为空
poco_log(std::string path,std::string name);
poco_log(LoggerInfo log);
void fatal(std::string str);
void critical(std::string str);
void error(std::string str);
void warning(std::string str);
void debug(std::string str);
void trace(std::string str);
void information(std::string str);
void notice(std::string str);
void init(LoggerInfo log);
public:
Poco::Logger & m_logger = Poco::Logger::root();
Poco::AutoPtr<Poco::/*SimpleFileChannel*/Channel> m_Channel;
Poco::AutoPtr<Poco::PatternFormatter> m_patternFormatter;
Poco::AutoPtr<Poco::FormattingChannel> m_formattingChannel;
LoggerInfo m_logInfo;
};
static LoggerInfo g_logger;
void LOGE(std::string logs,std::string type = "");
void LOGE_Fmt(const char *fmt, ...);
void LOGE_Fmt_Type(std::string type,const char *fmt, ...);
void LOGD(std::string logs,std::string type = "");
void LOGD_Fmt(const char *fmt, ...);
void LOGD_Fmt_Type(std::string type,const char *fmt, ...);
void LOGW(std::string logs,std::string type = "");
void LOGW_Fmt(const char *fmt, ...);
void LOGW_Fmt_Type(std::string type,const char *fmt, ...);
void LOGC(std::string logs,std::string type = "");
void LOGC_Fmt(const char *fmt, ...);
void LOGC_Fmt_Type(std::string type,const char *fmt, ...);
void LOGF(std::string logs,std::string type = "");
void LOGF_Fmt(const char *fmt, ...);
void LOGF_Fmt_Type(std::string type,const char *fmt, ...);
void LOGI(std::string logs,std::string type = "");
void LOGI_Fmt(const char *fmt, ...);
void LOGI_Fmt_Type(std::string type,const char *fmt, ...);
void LOGN(std::string logs,std::string type = "");
void LOGN_Fmt(const char *fmt, ...);
void LOGN_Fmt_Type(std::string type,const char *fmt, ...);
void LOGT(std::string logs,std::string type = "");
void LOGT_Fmt(const char *fmt, ...);
void LOGT_Fmt_Type(std::string type,const char *fmt, ...);
//获取日志对象
poco_log *GetLogObj(std::string type);
//创建日志类型
poco_log *CreateLogObj(std::string type);
//释放所有日志对象
void FreeLogObjs();
.cpp文件
/**
* 李坤昱
*/
static bool g_bValid = false;
static std::string defaltName;
std::map<std::string,poco_log*> Llogs;
poco_log::poco_log()
{
}
poco_log::poco_log(LoggerInfo log):m_logInfo(log)
{
}
void poco_log::init(LoggerInfo log)
{
m_logInfo = log;
if (log.use_console_log)
m_Channel = new Poco::ConsoleChannel;
else
{
m_Channel = new Poco::SimpleFileChannel;
char StrFormat[256] = {0};
Poco::LocalDateTime local;local.utcTime();
sprintf(StrFormat,"%s%s%d%02d%02d%02d%02d%02d%s",log.target.c_str(),log.app_name.c_str(),local.year(),local.month(),local.day(),local.hour(),local.minute(),local.second(),SUFFIX);
std::string logname(StrFormat);
m_Channel->setProperty("path",logname);
memset(StrFormat,0,sizeof(StrFormat));
sprintf(StrFormat,"%d M",log.rotation_size / 1024 / 1024);
m_Channel->setProperty("rotation", StrFormat);
}
//m_patternFormatter = new Poco::PatternFormatter("[%Y-%n-%e %H:%M:%S] [%U(%u)] %p: %t");
m_patternFormatter = new Poco::PatternFormatter("[%Y-%n-%e %H:%M:%S] [%p]: %t");
m_patternFormatter->setProperty("times", "local"); // 格式化中的时间显示为本地时间
m_formattingChannel = new Poco::FormattingChannel(m_patternFormatter, m_Channel);
m_logger.setLevel(log.loglevel);
m_logger.setChannel(m_formattingChannel);
g_bValid = true;
}
void poco_log::error(std::string str)
{
if (!str.empty())
{
//m_logger.setChannel(m_formattingChannel);
m_logger.error(str);
}
}
void poco_log::debug(std::string str)
{
if (!str.empty())
{
//m_logger.setChannel(m_formattingChannel);
m_logger.debug(str);
}
}
void poco_log::fatal(std::string str)
{
if (!str.empty())
{
//m_logger.setChannel(m_formattingChannel);
m_logger.fatal(str);
}
}
void poco_log::warning(std::string str)
{
if (!str.empty())
{
//m_logger.setChannel(m_formattingChannel);
m_logger.warning(str);
}
}
void poco_log::trace(std::string str)
{
if (!str.empty())
{
//m_logger.setChannel(m_formattingChannel);
m_logger.trace(str);
}
}
void poco_log::critical(std::string str)
{
if (!str.empty())
{
//m_logger.setChannel(m_formattingChannel);
m_logger.critical(str);
}
}
void poco_log::information(std::string str)
{
if (!str.empty())
{
//m_logger.setChannel(m_formattingChannel);
m_logger.information(str);
}
}
void poco_log::notice(std::string str)
{
if (!str.empty())
{
//m_logger.setChannel(m_formattingChannel);
m_logger.notice(str);
}
}
void init_logger(const std::string app_name,
const std::string app_version,
bool use_console_log,
bool file_log,
const std::string target,
std::string loglevel,
int64_t rotation_size,
bool auto_flush)
{
g_logger = {app_name,app_version,use_console_log,file_log,
target,loglevel,rotation_size,auto_flush};
defaltName = app_name;
}
void LOGE(std::string logs,std::string type)
{
if (!LOGVALID)
return;
std::string logname = (type.empty() ? defaltName : type);
poco_log *logObj = GetLogObj(logname);
if (0 == logObj){
if (0 == (logObj = CreateLogObj(logname)))
return;
else
logObj->error(logs);
}
else
logObj->error(logs);
}
void LOGE_Fmt(const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGE(std::string(printf_buf));
}
void LOGE_Fmt_Type(std::string type,const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGE(std::string(printf_buf),type);
}
void LOGD(std::string logs,std::string type)
{
if (!LOGVALID)
return;
std::string logname = (type.empty() ? defaltName : type);
poco_log *logObj = GetLogObj(logname);
if (0 == logObj) {
if (0 == (logObj = CreateLogObj(logname)))
return;
else
logObj->debug(logs);
}
else
logObj->debug(logs);
}
void LOGD_Fmt(const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGD(std::string(printf_buf));
}
void LOGD_Fmt_Type(std::string type,const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGD(std::string(printf_buf),type);
}
void LOGW(std::string logs,std::string type)
{
if (!LOGVALID)
return;
std::string logname = (type.empty() ? defaltName : type);
poco_log *logObj = GetLogObj(logname);
if (0 == logObj) {
if (0 == (logObj = CreateLogObj(logname)))
return;
else
logObj->warning(logs);
}
else
logObj->warning(logs);
}
void LOGW_Fmt(const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGW(std::string(printf_buf));
}
void LOGW_Fmt_Type(std::string type,const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGW(std::string(printf_buf),type);
}
void LOGC(std::string logs,std::string type)
{
if (!LOGVALID)
return;
std::string logname = (type.empty() ? defaltName : type);
poco_log *logObj = GetLogObj(logname);
if (0 == logObj) {
if (0 == (logObj = CreateLogObj(logname)))
return;
else
logObj->critical(logs);
}
else
logObj->critical(logs);
}
void LOGC_Fmt(const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGC(std::string(printf_buf));
}
void LOGC_Fmt_Type(std::string type,const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGC(std::string(printf_buf),type);
}
void LOGF(std::string logs,std::string type)
{
if (!LOGVALID)
return;
std::string logname = (type.empty() ? defaltName : type);
poco_log *logObj = GetLogObj(logname);
if (0 == logObj) {
if (0 == (logObj = CreateLogObj(logname)))
return;
else
logObj->fatal(logs);
}
else
logObj->fatal(logs);
}
void LOGF_Fmt(const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGF(std::string(printf_buf));
}
void LOGF_Fmt_Type(std::string type,const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGF(std::string(printf_buf),type);
}
void LOGI(std::string logs,std::string type)
{
if (!LOGVALID)
return;
std::string logname = (type.empty() ? defaltName : type);
poco_log *logObj = GetLogObj(logname);
if (0 == logObj) {
if (0 == (logObj = CreateLogObj(logname)))
return;
else
logObj->information(logs);
}
else
logObj->information(logs);
}
void LOGI_Fmt(const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGI(std::string(printf_buf));
}
void LOGI_Fmt_Type(std::string type,const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGI(std::string(printf_buf),type);
}
void LOGN(std::string logs,std::string type)
{
if (!LOGVALID)
return;
std::string logname = (type.empty() ? defaltName : type);
poco_log *logObj = GetLogObj(logname);
if (0 == logObj) {
if (0 == (logObj = CreateLogObj(logname)))
return;
else
logObj->notice(logs);
}
else
logObj->notice(logs);
}
void LOGN_Fmt(const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGN(std::string(printf_buf));
}
void LOGN_Fmt_Type(std::string type,const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGN(std::string(printf_buf),type);
}
void LOGT(std::string logs,std::string type)
{
if (!LOGVALID)
return;
std::string logname = (type.empty() ? defaltName : type);
poco_log *logObj = GetLogObj(logname);
if (0 == logObj) {
if (0 == (logObj = CreateLogObj(logname)))
return;
else
logObj->trace(logs);
}
else
logObj->trace(logs);
}
void LOGT_Fmt(const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGT(std::string(printf_buf));
}
void LOGT_Fmt_Type(std::string type,const char *fmt, ...)
{
if (!LOGVALID)
return;
//定义接收输出信息最大长度1024字节
char printf_buf[1024];
//记录fmt对应的地址
va_list args;
//得到首个%对应的字符地址
va_start(args, fmt);
int printed = vsprintf(printf_buf, fmt, args);
va_end(args);
LOGT(std::string(printf_buf),type);
}
//获取日志对象
poco_log *GetLogObj(std::string type)
{
auto it = Llogs.find(type);
if (Llogs.end() != it)
return it->second;
return 0;
}
//创建日志类型
poco_log *CreateLogObj(std::string type)
{
poco_log *logObj = new poco_log;
LoggerInfo logger = g_logger;
logger.app_name = type;
logObj->init(logger);
Llogs[type] = logObj;
return logObj;
}
//释放所有日志对象
void FreeLogObjs()
{
for(auto it = Llogs.begin();it != Llogs.end();it++)
{
if (it->second)
delete it->second,it->second = 0;
}
}
Poco日志用法：
init_logger("test","1.0.0",1(日志输出到控制台),1(保存日志到文件),"/tmp",0);
LOGI_Fmt("load ini ... :%s \n","test.ini");
Poco智能指针用法：
Poco::AutoPtr<Taskalloc> taskalloc = new Taskalloc();
taskalloc->func();
Poco json相关用法：
解析json
//获取json数据
Parser parser;
Var result = parser.parse(msg);
//转换为可以解析key的json
Poco::JSON::Object::Ptr object = result.extract<Poco::JSON::Object::Ptr>();
Var test = object->get("test");//{"test" : { "property" : "value" } }
Poco::JSON::Object::Ptr subObject = test.extract<Poco::JSON::Object::Ptr>();
test = subObject->get("property"); // { "property" : "value" }
std::string val = test.toString();
转换为json格式的数据
JSON::Object json;
json.set("test", "123");
std::stringstream out;
Poco::JSON::Object::Ptr Object = json.extract<Poco::JSON::Object::Ptr>();
Object->stringify(json,out);
std::string str;
str = out.str()
Poco 获取当前时间：
char StrFormat[256] = {0};
Poco::LocalDateTime local;
local.utcTime();
sprintf(StrFormat,"02d%02d%02d%02d%02d",local.year(),local.month(),local.day(),local.hour(),local.minute(),local.second());
Poco 线程池用法：
class Task : public Poco::Runnable
{
virtual void run()
{
}
virtual void release()
{
}
};
Poco::ThreadPool m_workthrdpool;
//初始化线程数量
m_workthrdpool.addCapacity(8);
//线程池调用
if (0 < m_workthrdpool.available())
{
Task *task = new Task();
m_workthrdpool.start(*task);
}
Poco 互斥锁用法：
//互斥锁
Poco::Mutex m_mutex;
m_mutex.lock();
m_mutex.unlock();
Poco 智能锁：
class Lock : public Poco::Runnable
{
public:
Lock( Poco::Mutex& mtx ):
m_mtx(mtx)
{
}
void run( )
{
//获取锁
Poco::Mutex::ScopedLock s( m_mtx);
}
private:
Poco::Mutex& m_mtx;
};
Poco 智能锁用法：
//互斥锁
Poco::Mutex m_mutex;
void test()
{
Lock lock(m_mutex);
lock.run();
}
PocoUtil：
PocoUtil属于命令行程序及后台程序相关框架，集成功能有：
命令行参数调用、后台程序启动等，这个框架提供了对于Unix守护进行的支持。
PocoUtil常用头定义：
#include “Poco/Util/Application.h”
#include “Poco/Util/ServerApplication.h”
#include “Poco/Util/Option.h”
#include “Poco/Util/OptionSet.h”
#include “Poco/Util/HelpFormatter.h”
#include “Poco/Util/IntValidator.h”
#include “Poco/Util/RegExpValidator.h”
#include “Poco/Util/Subsystem.h”
使用PocoUtil框架需要包含库名：
PocoFoundation
PocoUtil
Poco 控制台程序：
.h文件
using namespace Poco;
class LPoco_Cli : public Util::Application
{
public:
void initialize( Application& self );
void uninitialize( );
void defineOptions( Util::OptionSet& options);
//
void handleHelp(const std::string& name, const std::string& value);
//version
void handleVersion(const std::string& name, const std::string& value);
}
.cpp文件
//程序名称
const char *__progname = "test";
void LPoco_Cli::initialize( Application& self )
{
Util::Application::initialize( self );
}
void LPoco_Cli::uninitialize( )
{
Util::Application::uninitialize( );
}
void LPoco_Cli::defineOptions( Util::OptionSet& options)
{
Util::Application::defineOptions( options );//必须调用
m_options = options;
options.addOption(
Util::Option("help", "h",
"show the help messages")
.required(false)
.repeatable(false)
.callback(Util::OptionCallback < LPoco_Cli >(this, &LPoco_Cli::handleHelp)));
options.addOption(
Util::Option("version", "v",
"show version")
.required(false)
.repeatable(false)
.callback(Util::OptionCallback < LPoco_Cli >(this, &LPoco_Cli::handleVersion)));
}
void LPoco_Cli::handleHelp(const std::string& name, const std::string& value )
{
std::cout << __progname << " Global command help:" << std::endl;
std::cout << "handleHelp : name " << name << std::endl;
std::cout << "handleHelp : value " << value << std::endl;
Poco::Util::HelpFormatter helpFormatter(options());
helpFormatter.format(std::cout);
}
void LPoco_Cli::handleVersion(const std::string& name, const std::string& value )
{
std::cout << __progname << " version :" << std::endl;
std::cout << " version :"<< "1.0.0" << std::endl;
}
int LPoco_Cli::main(const std::vector<std::string>& args)
{
std::function< void() > termination_callback;
Poco_Srv *app = new Poco_Srv();
termination_callback = std::bind(&Poco_Srv::Run, app);
return 0;
}
Poco 控制台程序启动方式：
在main函数中：
try
{
LPoco_Cli app;
app.init( argc, argv );//在这里传主函数参数。
app.run( );
}catch( Poco::Exception &e )
{
std::cerr << "error: " << e.what() << std::endl;
}
