POCO C++ Libraies介绍及常见用法

Poco 专栏收录该内容
1 篇文章 0 订阅

  POCO C++ Libraies属于功能广泛、轻量级别的开源框架库,它拥有媲美Boost库的功能以及较小的体积广泛应用在物联网平台、工业自动化等领域。

  POCO C++ Libraies由多个功能模块组成,其中包括网络、多线程、日志、命令行程序等。POCO官方拥有众多模块的使用示例,可以在短时间内上手并完成相关功能。

  官方网址POCO官方
  官方文档POCO文档
  函数用法POCO函数用法


章节预览:

介绍(引自官方)
PocoNet
HTTP(TCP)服务器启动方式
HTTP(UDP)服务器启动方式
HTTP客户端编写方式
方法调用
DNS域名解析方式
PocoFoundation
Poco 日志(封装后的函数)
Poco 日志用法
Poco 智能指针用法
Poco json相关用法
Poco 获取当前时间
Poco 线程池用法
Poco 互斥锁用法
Poco 智能锁
Poco 智能锁用法
PocoUtil
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;
    }
  • 4
    点赞
  • 0
    评论
  • 14
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 博客之星2020 设计师:CY__ 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值