http客户端-基于boost开发

http客户端-基于boost开发

　　基于BOOST编写的http客户端，作为BOOST开发学习之用。目前支持功能：

• http协议，单向链接返回http response code 200
• 可content type 为text或image下载到本地
• 仅支持http返回code为200，不支持3XX、4XX等
• 暂不支持chunk传输，chunk代码待调试
• 日志文件，提供类ACE的输出方式，如LOG((LOG_DEBUG,"[%T(%t)] test begin %d  %s "), int_num_2, string_test.c_str());
• 数据缓冲区，当前为new方式，后续可更改为从boost pool获取
• 。。。

　

　　

 1 类关系图

 

2 核心代码

2.1 IOServer，提供asio线程环境

#pragma once
#include "boost/serialization/singleton.hpp"
#include "boost/asio.hpp"
#include "boost/thread.hpp"
#include "boost/bind.hpp"
#include "Event.h"
#include "../concurrent/IRunable.h"
#include "SimpleLog.h"
class IO_Server : public IRunable
{
public:
    IO_Server(): bExit(false)
    {
    }
    boost::asio::io_service* GetIOS()
    {
        return &ios;
    }
    void ActiveIOS()
    {
        boost::unique_lock<boost::mutex> lock(mu);
        if (ios.stopped())
        {
            cond.notify_one();
        }
    }
    void Exit()
    {
        ios.stop();
        bExit = true;
    }
private:
    virtual int Run()
    {
        LOG((LOG_DEBUG,"[%T(%t)] ios server run ,id = %d
", boost::this_thread::get_id()));
        ios.stop();
        while (1)
        {
            // 设置退出线程
            if (bExit)
            {
                break;
            }
            //
            {
                boost::unique_lock<boost::mutex> lock(mu);
                if (ios.stopped())
                {
                    cond.wait(mu);
                }
            }
            if (ios.stopped())
            {
                ios.reset();
                ios.run();
            }
        }
        return 0;
    }
private:
    boost::asio::io_service            ios;    //所有的asio都要有个ios
    boost::mutex                    mu;
    boost::condition_variable_any    cond;
    bool                            bExit;
};
typedef boost::serialization::singleton<IO_Server> IOS;

2.2 task及sock资源管理器

#pragma once
#include "ios.h"
#include "handle.h"
#include "ios.h"
#include "SimpleLog.h"
#include "../concurrent/ThreadPool.h"
#include "../concurrent/IRunable.h"
#include "MsgQueue.h"
/************************************************************************/
/* Handle的集合.多线程共享                                       */
/************************************************************************/
typedef boost::shared_ptr<IRunable> IRunablePtr;
typedef CMsgQueue<IRunablePtr> IRunPtrQueue;
template<class CLIENT>
class HandleSet : public IRunable
{
public:
    HandleSet()
    {
        bExit = false;
        nHighWaterMark = 5;
        nClientUsed = 0;

        m_poThreadPool = boost::shared_ptr<ThreadPool>(new ThreadPool("HandleSet_Pool", 1, boost::thread::hardware_concurrency()));
        //启动ioserver线程
        IO_Server& ioserver = IOS::get_mutable_instance();
        m_poThreadPool->Start(&ioserver);
        //启动
        m_poThreadPool->Start(this);
    }
    ~HandleSet(){}
    //加入一个task
    void AddTask(TaskPtr task)
    {
        boost::unique_lock<boost::mutex> lock(mu);
        ClientHandlePtr client;
        if (!GetFreeClient(client))
        {
            tasks.push_back(task);
            return;
        }
        client->Busy(true);
        client->HTTP_Connect(task);
        InterlockedIncrement(&nClientUsed);
        IOS::get_mutable_instance().ActiveIOS();
    }

    //设置client水位标
    void HighWaterMark(int mark)
    {
        nHighWaterMark = mark;
    }                    

    void NotifyComplete(ClientHandle* client, const boost::system::error_code& ec, 
        CMsgBlock& msg)
    {
        switch (ec.value())
        {
        case 0:    //正常退出
            {
                boost::unique_lock<boost::mutex> lock(mu);
                client->pTask->Finish(SUCCESS, msg);
                client->Busy(false);
                client->Reset();
                InterlockedDecrement(&nClientUsed);
            }
            break;
        case 2:    //远端关闭连接
            {
                
            }
            break;
        }
    }
private:
    //找出一个空闲的client
    bool GetFreeClient(ClientHandlePtr& ptr)
    {
        if (clients.size() >= nHighWaterMark && nClientUsed >= nHighWaterMark)
        {
            return false;
        }
        //空队列，创建一个新的
        if (clients.empty())
        {
            ptr = CreateNewHandle();
            clients.push_back(ptr);
            return true;
        }
        //非空则找出一个空闲
        LiClientHandlePtr::iterator iter = clients.begin();
        for ( ;iter != clients.end(); iter++)
        {
            ClientHandlePtr client = *iter;
            if (!client->Busy())
            {
                ptr = client;
                return true;
            }
        }
        //无空闲且饱和
        if (nClientUsed < nHighWaterMark)
        {
            ptr = CreateNewHandle();
            clients.push_back(ptr);
            return true;
        }
        return false;
    }
    ClientHandlePtr CreateNewHandle()
    {
        return ClientHandlePtr(
            new CLIENT(IOS::get_mutable_instance().GetIOS(), boost::bind(&HandleSet::NotifyComplete, this, _1, _2, _3)));
    }
private:
    virtual int Run()
    {
        LOG((LOG_DEBUG,"[%T(%t)] handleSet %s thread run
", typeid(this).name()));
        while (1)
        {
            // 设置退出线程
            if (bExit)
            {
                break;
            }
            {
                boost::unique_lock<boost::mutex> lock(mu);
                if (!tasks.empty())
                {
                    ClientHandlePtr client;
                    if (GetFreeClient(client))
                    {
                        TaskPtr task = tasks.front();
                        tasks.pop_front();
                        client->Busy(true);
                        client->HTTP_Connect(task);
                        InterlockedIncrement(&nClientUsed);
                    }
                    IOS::get_mutable_instance().ActiveIOS();
                }
            }
            boost::this_thread::sleep_for(boost::chrono::milliseconds(10));

            //线程池模式
            /*if (queue.empty())
            {
                boost::this_thread::sleep_for(boost::chrono::milliseconds(20));
                continue;
            }

            IRunablePtr ptrTask;
            queue.dequeue_head(ptrTask, 10);

            if (ptrTask)
            {
                m_poThreadPool->Start(ptrTask);
            }*/
        }
        return 0;
    }
private:
    int                    nHighWaterMark;        //并发执行数量为1--nHighWaterMark
    LiClientHandlePtr    clients;

    TaskPtrList            tasks;
    long                nClientUsed;
    bool                bExit;
    boost::mutex        mu;

    boost::shared_ptr<ThreadPool> m_poThreadPool; ///<线程池共享指针
    IRunPtrQueue        queue;
};

2.3 socket工厂模式虚接口，供资源管理器调用

#pragma once
/************************************************************************/
/* 提供网络行为                                               */
/************************************************************************/
#include <string>
#include "boost/smart_ptr.hpp"
#include "boost/asio.hpp"
#include "boost/date_time/posix_time/posix_time.hpp"
#include "boost/thread.hpp"
#include "MsgBlock.h"
#include "SimpleLog.h"
#include "userTask.h"
using namespace boost;
using namespace boost::asio;
using namespace std;

class ClientHandle;
typedef boost::shared_ptr<ip::tcp::socket> sock_ptr;
typedef boost::shared_ptr<ClientHandle> ClientHandlePtr;
typedef std::list<ClientHandlePtr>    LiClientHandlePtr;

typedef boost::function<void(ClientHandle* handle, 
    const boost::system::error_code& ec, CMsgBlock&)>    NotifyCompleteFunc;

class ClientHandle
{
public:
    ClientHandle(boost::asio::io_service* ios, NotifyCompleteFunc completeFun);
    ~ClientHandle();
public:    //主动请求
    void HTTP_Connect(TaskPtr task);
    //http send请求
    void HTTP_Send(CMsgBlock& block);
    //http close
    void HTTP_Close();
    //http recv，接收到数据后回调
    void HTTP_Recv();
    bool Busy();
    void Busy(bool busy);
    void Reset();
public:    //回调函数
    //http send，接收到数据后回调
    virtual void CB_Send(const boost::system::error_code& ec, size_t len) = 0;
    //http recv，接收到数据后回调
    virtual void CB_Recv(const boost::system::error_code& ec, size_t len) = 0;
    //http connect result,连接结果回调
    virtual void CB_HTTP_Connect_Result(const boost::system::error_code& ec) = 0;
    //http result, 返回错误码及第一次数据
    virtual int CB_HTTP_CODE(int retCode, CMsgBlock& block) = 0;
    //连接超时
    virtual void CB_HTTP_Timeout() = 0;
    //对端关闭连接
    virtual void CB_Remote_Close() = 0;
public:
    TaskPtr        pTask;
protected:
    //写缓冲区和写指针
    CMsgBlock    _rdBuf;
    CMsgBlock    _wrBuf;
    DWORD        lastDataTime;    //活动时间
    long        recvSz;            //累计接收数据量
    //记录任务
    sock_ptr    sock;
    boost::asio::ip::tcp::endpoint ep;
    bool        bBusy;
    NotifyCompleteFunc _completeFun;
};

2.4 socket管理实例

//http recv，接收到数据后回调
void ITsoftware_Index::CB_Send(const boost::system::error_code& ec, size_t len)
{
    if (ec)
    {
        //错误,调用返回
        return;
    }
    if (len == _wrBuf.Size())
    {
        _rdBuf.Reset();
        sock->async_read_some(boost::asio::buffer(_rdBuf.Base() + _rdBuf.WtPtr(), _rdBuf.Space()), 
            bind(&ClientHandle::CB_Recv, this, _1, _2));
    }
    else
    {
        sock->async_write_some(boost::asio::buffer(_wrBuf.Base() + len, _wrBuf.Size() - len), 
            bind(&ClientHandle::CB_Send, this, _1, _2));
    }
}

//http recv，接收到数据后回调
void ITsoftware_Index::CB_Recv(const boost::system::error_code& ec, size_t len)
{
    if (ec || !pTask)
    {
        return;
    }
    recvSz += len;
    _rdBuf.WtPtr(len);

    bool bLastData = (_rdBuf.Space() > 0)? true : false;    //缓冲区未接收满，说明当前数据已经收完

    int ret = 0;
    if (!pTask->_head.bReady)
    {
        ret = ParseHead(_rdBuf);
        if (ret == 0)    //头未收完，继续接收
        {
            sock->async_read_some(boost::asio::buffer(_rdBuf.Base() + _rdBuf.WtPtr(), _rdBuf.Space()), 
                bind(&ClientHandle::CB_Recv, this, _1, _2));
            return;
        }
        // 返回为http的代码
        ret = CB_HTTP_CODE(ret, _rdBuf);
    }

    switch (ret)
    {
    case -1:
        {
            sock->shutdown(ip::tcp::socket::shutdown_both);
            sock->close();
            _completeFun(this, ec, parseOnlineBlock);
            parseOnlineBlock.Reset();
        }
        break;
    case 0:
        {
            int retWriteData = 0;
            if (_rdBuf.Size() > 0)
            {
                retWriteData = WriteData(_rdBuf);        //处理数据流
            }
            _rdBuf.Reset();
            if (retWriteData == -1)
            {
                sock->shutdown(ip::tcp::socket::shutdown_both);
                sock->close();
                _completeFun(this, ec, parseOnlineBlock);
                parseOnlineBlock.Reset();
            }
            else
            {
                sock->async_read_some(boost::asio::buffer(_rdBuf.Base() + _rdBuf.WtPtr(), _rdBuf.Space()), 
                    bind(&ClientHandle::CB_Recv, this, _1, _2));
            }
        }
        break;
    case 1:
        {

        }
        break;
    }
}
//http connect result,连接结果回调
void ITsoftware_Index::CB_HTTP_Connect_Result(const boost::system::error_code& ec)
{
    if (ec)
    {
        //错误,调用返回
        return;
    }
    std::string getContent = "GET " + pTask->_info.URI + " HTTP/1.1
";
    getContent += "Host: " + pTask->_info.host + "
";
    getContent += "Connection: keep-alive
";
    getContent += "User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/61.0.3163.100 Safari/537.36
";
    getContent += "Accept-Encoding: gzip, deflate
";
    getContent += "Accept-Language: zh-CN,zh;q=0.8

";

    _wrBuf.Reset();
    _wrBuf.Write(getContent.c_str(), getContent.length());
    HTTP_Send(_wrBuf);
}

//http recv,收到全部数据后回调，httpcode=200
int ITsoftware_Index::CB_HTTP_CODE(int retCode, CMsgBlock& block)
{
    int ret = 0;
    //准备文件及缓冲区
    if (retCode == 200)        
    {
        if (pTask->HasFlag(CONTENT_TYPE_DOWNLOAD))            //开启下载
        {
            if (pTask->_head.nContentType == CONTENT_TYPE_IMAGE ||
                pTask->_head.nContentType == CONTENT_TYPE_TEXT)
            {
                char sss[100] = {0};
                sprintf_s(sss, 100, "%d", InterlockedIncrement(&filenameprev));
                pTask->FilePtr(std::string(sss) + pTask->_info.lastName);        //创建文件
                if (!pTask->FilePtr())        //文件创建失败，则接收失败
                {
                    ret = -1;
                    //LOG((LOG_DEBUG,"[%T(%t)] create file failed, %s 
", pTask->_url.c_str()));
                }
            }
        }
        if (pTask->HasFlag(CONTENT_TYPE_PARSEONLINE))        //调用完成后回传给task
        {
            if (pTask->_head.bContentLength)
            {
                parseOnlineBlock.Capacity(pTask->_head.nContentLength);
            }
            else if (pTask->_head.bChunked)
            {
                parseOnlineBlock.Capacity(block.Capacity() * 2);
            }
            if (parseOnlineBlock.Capacity() == 0)
            {
                ret = -1;
                //LOG((LOG_DEBUG,"[%T(%t)] create parseOnlineBlock buffer failed, %s 
", pTask->_url.c_str()));
            }
        }
    }
    //重定向
    else if (300 < retCode && retCode < 399)
    {
        ret = -1;        //中断当前
    }
    return ret;
}

//连接超时
void ITsoftware_Index::CB_HTTP_Timeout()
{

}
//对端关闭连接
void ITsoftware_Index::CB_Remote_Close()
{

}

int ITsoftware_Index::ParseHead(CMsgBlock& _block)
{
    int ret = 0;
    int rnrn = Tools::KMPFind(_block.Base(), _block.Size(), RNRN, RNRN_SIZE);
    if (rnrn != -1)
    {
        //头收完全，处理http头
        char* cRnrn = new char[rnrn + 1 + 2];
        ZeroMemory(cRnrn,rnrn+1);
        memcpy(cRnrn, _block.Base(), rnrn + 2);
        if (pTask->_head.ParseHead(cRnrn ))
        {
            pTask->_head.bReady = true;
            //数据移位，把头去掉，保证缓冲区内都是数据体
            int remain = _block.Size() - rnrn -4;        //剩余长度
            char* remain_begin_pos = _block.Base() + rnrn + 4;
            _block.Reset();                                //读写指针置零
            _block.Write(remain_begin_pos, remain);        //重新写入
            ret =  pTask->_head.code;
        }
        else    //文件头出错，关闭连接
        {
            ret = -1;
            //LOG((LOG_DEBUG,"[%T(%t)] recv http head parse error, %s
, %s 
", pTask->_url.c_str() ,cRnrn));
        }
        delete cRnrn;
    }
    else
    {
        //没有收到

，则表明头还没收完全
        ret = 0;
    }
    return ret;
}

int ITsoftware_Index::WriteData(CMsgBlock& _block)
{
    int ret = 0; 
    if(pTask->_head.bContentLength)
    {
        if (pTask->HasFlag(CONTENT_TYPE_DOWNLOAD) && 
            (pTask->_head.nContentType == CONTENT_TYPE_IMAGE ||    pTask->_head.nContentType == CONTENT_TYPE_TEXT))
        {
            if (!pTask->FilePtr()->bad())
            {
                pTask->FilePtr()->write(_block.Base(), _block.Size());
            }
        }
        if (pTask->HasFlag(CONTENT_TYPE_PARSEONLINE))
        {
            parseOnlineBlock.Write(_block.Base(), _block.Size());
        }
        if (recvSz >= pTask->_head.nContentLength)
        {
            if (pTask->HasFlag(CONTENT_TYPE_DOWNLOAD) && 
                (pTask->_head.nContentType == CONTENT_TYPE_IMAGE ||    pTask->_head.nContentType == CONTENT_TYPE_TEXT))
            {
                pTask->FilePtr()->close();
            }
            ret = -1;
        }
    }
    else if (pTask->_head.bChunked)
    {
        //    //chunk,通过辨识末尾7位是否是HTTP_END，来判断数据是否已接收完整
        //    if(_block.RdPtr() > HTTP_END_SIZE)
        //    {
        //        char cend[HTTP_END_SIZE+1]= {0};
        //        memcpy(cend, _block.Base() + _block.Size() - 7, HTTP_END_SIZE);
        //        int cmp = strcmp(cend,HTTP_END);
        //        if (cmp != 0)
        //        {
        //            //未接收完整，继续接收
        //            return 0;
        //        }
        //    }
        //    //数据接收完全，把chunk的长度字符全部删除
        //    int beginPos = rnrn + 4;
        //    while (true)
        //    {
        //        int rnBegin = Tools::KMPFind(_block.Base(), _block.Size(), RN, RN_SIZE, beginPos);
        //        if (rnBegin != -1)
        //        {
        //            char*  tets = _block.Base() + rnBegin;
        //            //计算出chunk的长度
        //            char* cchunk = new char[rnBegin - rnrn - 4 + 1];
        //            ZeroMemory(cchunk, rnBegin - rnrn - 4 + 1);
        //            memcpy(cchunk, _block.Base() + rnrn + 4, rnBegin - rnrn - 4);
        //            int chunk = strtol(cchunk,NULL,16);
        //            delete cchunk;
        //            if (chunk ==0)
        //                break;
        //            //copy chunck的字节到body
        //            result.Write(_block.Base() + rnBegin + RN_SIZE, chunk); 
        //            beginPos = rnBegin + chunk+RN_SIZE*2;
        //        }
        //        else
        //            break;
    }
    return ret;
}

2.5 下发任务

#pragma once
#include <string>
#include "boost/bind.hpp"
#include "boost/function.hpp"
#include "boost/smart_ptr.hpp"
#include "SimpleLog.h"
#include "MsgBlock.h"
#include "httphead.h"
#include "Tools.h"
using namespace std;
class Task;

enum NotifyType{
    SUCCESS,
    FAILED
};

typedef boost::function<void(NotifyType,const std::string&)>    NotifyFunc;
typedef boost::shared_ptr<Task> TaskPtr;
typedef std::list<TaskPtr> TaskPtrList;

class Task
{
public:
    static TaskPtr CreateTask(std::string url, long flag = CONTENT_TYPE_NONE, std::string downPath = "")
    {
        return boost::shared_ptr<Task>(new Task(url, flag, downPath));
    }
public:
    virtual ~Task()
    {
        if (_file)
        {
            _file->close();
        }
    }
    virtual void Finish(NotifyType type, CMsgBlock& retMsg)
    {
        LOG((LOG_DEBUG, "[%T(%t)] NotifyComplete %d, %s 
", type, _url.c_str()));
//         if (type == SUCCESS)
//         {
//             std::vector<std::string> vecs;
//             Tools::HttpStringOpt::ExtractAllUrl(std::string(result.Base(), result.Size()), vecs);
//         }
    }
    inline ofstreamPtr FilePtr()
    {
        return _file;
    }
    inline void FilePtr(std::string filename)
    {
        if (_file)
        {
            _file->close();
        }
        std::string filepath = _downloadPath + std::string("/") + filename;
        ofstreamPtr ptr = Tools::GetNewFile(filepath);
        _file.swap(ptr);
    }
    Task(const Task& t)
    {
        _url = t._url;
    }
    Task* operator= (const Task& t)
    {
        _url = t._url;
    }
    inline bool HasFlag(long flag)
    {
        return flag & _flag;
    }
private:
    Task(std::string url, long flag, std::string downPath)
        :_url(url),
        _flag(flag),
        _downloadPath(downPath)
    {
        _head.Reset();
        Tools::HttpStringOpt::SpliterHttpUrl(_url, _info);        
    }
public:
    std::string _url;
    long        _flag;
    HttpHead    _head;
    std::string _downloadPath;        //下载目录
    UrlInfo        _info;
private:
    ofstreamPtr _file;
};

2.5 缓冲数据块

#pragma once
#include "boost/smart_ptr.hpp"
#ifndef DEFAULT_BUF_SIZE
#define DEFAULT_BUF_SIZE 1024
#endif
class CMsgBlock;
typedef boost::shared_ptr<CMsgBlock> MsgBlockPtr;

/************************************************************************/
/* 简易数据缓冲区                                                */
/************************************************************************/
class CMsgBlock
{
public:
    CMsgBlock(){
        Reset();
        _block = NULL;
        _capacity = 0;
    }
    CMsgBlock(int sz){
        Reset();
        _block = NULL;
        _capacity = 0;
        Capacity(sz);
    }
    ~CMsgBlock(){
        if (_block != NULL)
        {
            delete [] _block;
            _block = NULL;
        }
    }
    //重置缓冲区,仅移动指针
    void Reset()
    {
        _rdPrt = 0;
        _wrPtr = 0;
    }
    //获取数据块大小
    int     Size()
    {
        return _wrPtr - _rdPrt;
    }
    //获取缓冲区容量
    int     Capacity()    
    {
        return _capacity;
    }
    //获取剩余空间
    int  Space() 
    {
        return _capacity - _wrPtr;
    }
    // 获取基址
    char* Base() 
    {
        return _block;
    }
    //读地址
    int RdPtr() 
    {
        return _rdPrt;
    }
    void RdPtr(int ptr) 
    { 
        _rdPrt += ptr;
    }
    //写地址
    int WtPtr() 
    {
        return _wrPtr;    
    }
    void WtPtr(int ptr) 
    { 
        _wrPtr += ptr;
    }
    //重置缓冲区大小
    bool Capacity(int sz)
    {
        if (_capacity >= sz)
            return true;
        else 
        {
            char* temp = new char[sz];
            if (temp == NULL)
                return false;
            if (_block)
            {
                memcpy(temp,_block,_capacity);
                delete [] _block;
            }
            _block = temp;
            _capacity = sz;
        }
        return true;
    }
    //写缓冲区
    bool Write(const char* buf,int leng)
    {
        //缓冲区可写区域不足
        if (Space() < leng)
        {
            //重置缓冲区
            if (!Capacity(_capacity + 2*leng + DEFAULT_BUF_SIZE ))
                return false;
        }
        memcpy(_block + _wrPtr,buf,leng);
        _wrPtr += leng;
        return true;
    }
    void Copy(CMsgBlock* block)
    {
        if (block != this)
        {
            this->Reset();
            this->Write(block->Base(),block->Size());
        }
    }
    void Copy(CMsgBlock& block)
    {
        Copy(&block);
    }
private:
    char*    _block;                //数据块
    unsigned int _rdPrt;        //读指针
    unsigned int _wrPtr;        //写指针
    unsigned int _capacity;        //容量
};

2.6 日志输出

//输出日志
    void Log(LogType type,const char *format_str, ...)
    {

        //调整缓冲区 
        _block.Reset();

        va_list argp;
        va_start (argp, format_str);
        while (*format_str != '')
        {
            if (*format_str != '%')
            {
                _block.Write(format_str,1);
            }
            else if (format_str[1] == '%') // An "escaped" '%' (just print one '%').
            {
                format_str++;    // Store first %
            }
            else
            {
                char format[128] = {0}; // 临时变量，保存%转换的临时结果
                int     len = 0;
                format_str++;   // Copy in the %

                switch (*format_str)    
                {
                case '-':    case '+':    case '0':    case ' ':    case '#':
                case '1':    case '2':    case '3':    case '4':    case '5':
                case '6':    case '7':    case '8':    case '9':    case '.':
                case 'L':    case 'h':
                    //*fp++ = *format_str;
                    break;
                case 'l':    // Source file line number
                    len = sprintf_s (format,128,"%d",__LINE__);
                    _block.Write(format,len);
                    break;
                case 'N':             // Source file name
                    len = sprintf_s (format,128,"%s",__FILE__);
                    _block.Write(format,len);
                    break;
                case 'n':             // Program name
                    len = sprintf_s (format,128,"%s","<unknown>");
                    _block.Write(format,len);
                    break;
                case 'P':             // Process ID
                    len = sprintf_s (format,128,"%d", (int)getpid());
                    _block.Write(format,len);
                    break;
                case 'T': // Format the timestamp in hour:minute:sec:usec format.
                    {
                        std::string strColTime = Tools::GetCurrentTime();
                        _block.Write(strColTime.c_str(), strColTime.length());
                    }
                    break;
                case 't': // Format thread id.
                    len = sprintf_s (format,128,"%d", boost::this_thread::get_id());
                    _block.Write(format,len);
                    break;
                case 's':   
                    {// String
                        char *str1 = va_arg (argp, char *);
                        _block.Write(str1,strlen(str1));
                        break;
                    }
                case 'd': 
                case 'i': 
                case 'o':
                case 'u': 
                case 'x': 
                case 'X':
                    len = sprintf_s (format,128,"%d",va_arg (argp, int));
                    _block.Write(format,len);
                    break;
                default:
                    _block.Write(format_str,1);
                    break;
                }
            }
            ++format_str;
        }
        //末尾结束符号
        char c('');
        _block.Write(&c,1);
        //输出缓冲区
        if (BIT_ENABLED (_flags,STDERR)) // This is taken care of by our caller.
        {
            int const fwrite_result = fprintf (stderr,"%s",_block.Base());
            ::fflush (stderr);
        }
        if (BIT_ENABLED (_flags,OSTREAM))
        {
            if (_ostream != NULL)
            {
                *_ostream << _block.Base();
                _ostream->flush();
            }
        }
        va_end (argp);
    }