利用gsoap库封装易用的rest框架

c++缺少web开发的框架，web框架分为异步和同步，异步的业务逻辑控制需要较强功底，同步代码实现起来容易，利于阅读理解

1.gsoap是c++写的webservice库，webservice应用层也是用http进行传输的，gsoap提供了httpget和httppost的插件，本文对这两个插件进行改造，可以支持restful风格的接口。下面是的代码需要在c++11支持的编译器下运行，rest包装的内容用json传递

2.利于gsoap的soapcpp2.exe工具生成env文件

命令

mkdir env

soapcpp2.exe -penv -denv env.h

3.拷贝源码目录下的stdsoap2.h和stdsoap2.cpp，和http插件包含进你的工程

4.server文件

 #ifndef SoapWebServer_279437A4_6013_4E56_B152_EC3D528A0CC2_H__
 #define SoapWebServer_279437A4_6013_4E56_B152_EC3D528A0CC2_H__

 #include <string>
 #include <map>
 #include <list>
 #include <queue>
 #include <mutex>
 #include <condition_variable>
 #include <thread>

 using namespace std;
 #include "stdsoap2.h"
 #include "RestServicePlugin.h"
 using namespace Http;

 class CSoapWebServer
 {
 public:
     CSoapWebServer();
     ~CSoapWebServer();

     static const int AcceptTimeout = ;//>单位s
     static const int RecvTimeout = ;//>单位s
     static const int SendTimeout = ;//>单位s
     static const int MaxThreadCount = ;
     static const unsigned int WaitTimeout = ; //>单位s
     void SetURI(const char* URI,RequestProcessFunc fun, void * user);
     void SetURI(const char* URI, RequestProcessFunction & fun);
     void ResetURI(const char* URI);
     void ClearURI();

     bool StartService(const char* ip,unsigned int port);
     void StopService();

 protected:
     struct THREAD_INFO
     {
         struct soap* soap_listen;
         struct soap* soap_client;
         CSoapWebServer* pThis;
     };
     bool StartThread();
     void CloseThread();

     void ServiceListenThread();
     void ServiceServeThread(THREAD_INFO*pParam);
     void Listen();
     void ExecuteServe(THREAD_INFO* info);
     int SoapServ(struct soap* soap);

     int BeginServe(struct soap* soap);
     int EndServe(struct soap* soap);

     struct soap* PopSoap(void);
     void PushSoap(struct soap* soap);
     void FreeSoapAll(void);
 private:

     CRestServicePlugin m_service;
     struct soap* m_pSoap;
     volatile bool m_bExit;
     std::thread *m_ListenThread;     //>接收线程句柄
     std::thread *m_ServeThread[MaxThreadCount]; //>服务执行线程
     struct CLIENT_INFO
     {
         SOAP_SOCKET socket;
         unsigned long ip;
         unsigned int port;
     };
     std::queue<CLIENT_INFO> m_acceptClientList;
     std::queue<struct soap*>    m_soapList;
     std::mutex m_listMt;
     std::condition_variable m_cvClient;
     unsigned int m_iClientCount;
 };

 #endif // SoapWebServer_279437A4_6013_4E56_B152_EC3D528A0CC2_H__

5.server.cpp文件

 #include "SoapWebServer.h"
 //#include "soap.nsmap"

 SOAP_NMAC struct Namespace namespaces[] = {
         {"SOAP-ENV", "http://schemas.xmlsoap.org/soap/envelope/", "http://www.w3.org/*/soap-envelope", NULL},
         {"SOAP-ENC", "http://schemas.xmlsoap.org/soap/encoding/", "http://www.w3.org/*/soap-encoding", NULL},
         {"xsi", "http://www.w3.org/2001/XMLSchema-instance", "http://www.w3.org/*/XMLSchema-instance", NULL},
         {"xsd", "http://www.w3.org/2001/XMLSchema", "http://www.w3.org/*/XMLSchema", NULL},
         {NULL, NULL, NULL, NULL}
     };

 int TestAPI(Request& request)
 {
     char* body = NULL;
     size_t body_len = request.GetBody(&body);

     Response res(request);
     res.SetContentType("text/json");
     res.Send("{\"name\":\"bobo\",\"age\": 50}");

     return SOAP_OK;
 }

 CSoapWebServer::CSoapWebServer():
 m_pSoap(NULL),
 m_bExit(false),
 m_ListenThread(nullptr),
 m_iClientCount()
 {
     for (int i = ; i < MaxThreadCount; ++i)
     {
         m_ServeThread[i]  = nullptr;
     }
 }

 CSoapWebServer::~CSoapWebServer()
 {

 }
 void CSoapWebServer::ClearURI()
 {
     m_service.ClearURI();
 }

 void CSoapWebServer::ResetURI( const char* URI )
 {
     if (URI)
     {
         m_service.UnRegisteURI(URI);
     }
 }

 void CSoapWebServer::SetURI( const char* URI,RequestProcessFunc fun, void * user)
 {
     if (!URI || !fun)
     {
         return;
     }

     m_service.RegisteURI(URI,fun, user);
 }

 void CSoapWebServer::SetURI(const char* URI, RequestProcessFunction & fun)
 {
     if (!URI || !fun)
     {
         return;
     }

     m_service.RegisteURI(URI,fun);
 }

 bool CSoapWebServer::StartService(const char* ip,unsigned int port)
 {
     //StopService();
     m_bExit = false;
     do
     {
         m_pSoap = soap_new();
         if (NULL == m_pSoap)
         {
             break;
         }

         soap_init1(m_pSoap, SOAP_C_UTFSTRING);
         m_pSoap->bind_flags = SO_REUSEADDR;
         m_pSoap->send_timeout = SendTimeout;
         m_pSoap->recv_timeout = RecvTimeout;
         m_pSoap->accept_timeout = AcceptTimeout;
         m_pSoap->imode = SOAP_C_UTFSTRING;

         m_pSoap->namespaces = namespaces;
         soap_set_local_namespaces(m_pSoap);

         m_service.Hook(m_pSoap);
         {
             FreeSoapFunction fun((FreeSoapFunction)std::tr1::bind(
                 &CSoapWebServer::PushSoap, this, std::tr1::placeholders::_1));
                 m_service.RegisterFreeSoap(fun);
         }

         SOAP_SOCKET serverSocket = soap_bind(m_pSoap,ip,port,);
         if (serverSocket == SOAP_INVALID_SOCKET)
         {
             printf("err soap_bind, %s:%u\n", ip, port);
             break;
         }
         printf("soap bind %s:%u\n", ip, port);

         if (!StartThread())
         {
             printf("err StartThread\n");
             break;
         }
         printf("start success\n");
         return true;
     } while (false);
     printf("err start failed\n");
     StopService();
     return false;
 }
 void CSoapWebServer::StopService()
 {
     m_bExit = true;
     CloseThread();
     m_iClientCount = ;

     m_service.ClearURI();
     FreeSoapAll();
     if (NULL != m_pSoap)
     {
         soap_destroy(m_pSoap);
         soap_end(m_pSoap);
         soap_done(m_pSoap);
         soap_free(m_pSoap);
         m_pSoap = NULL;
     }
 }
 bool CSoapWebServer::StartThread()
 {
     //>开启service接受执行线程
     m_ListenThread = new std::thread(
         &CSoapWebServer::ServiceListenThread,this);

     int iThreadCount = ;
     if( iThreadCount > MaxThreadCount)
     {
         iThreadCount = MaxThreadCount;
     }
     else if(iThreadCount == )
     {
         iThreadCount = ;
     }

     for (int i = ; i < iThreadCount; ++i)
     {
         soap* pSoap = soap_copy(m_pSoap);
         THREAD_INFO* info = new(std::nothrow)THREAD_INFO;
         if (info == NULL)
         {
             return false;
         }
         info->soap_listen = m_pSoap;
         info->soap_client = pSoap;
         info->pThis = this;
         m_ServeThread[i] = new std::thread(
             &CSoapWebServer::ServiceServeThread, this, info);
     }
     return true;
 }

 void CSoapWebServer::CloseThread()
 {
     m_cvClient.notify_all();
     if (m_ListenThread)
     {
         m_ListenThread->join();
         delete m_ListenThread;
         m_ListenThread = nullptr;
     }

     for (int i = ; i < MaxThreadCount; i++)
     {
         if(m_ServeThread[i])
         {
             m_ServeThread[i]->join();
             delete m_ServeThread[i];
             m_ServeThread[i] = nullptr;
         }
     }
 }
 void CSoapWebServer::ServiceListenThread()
 {
     Listen();
     return ;
 }
 void CSoapWebServer::Listen()
 {
     if (NULL == m_pSoap)
     {
         return ;
     }
     CLIENT_INFO clientInfo;
     while (!m_bExit)
     {
         clientInfo.socket = soap_accept(m_pSoap);
         if (clientInfo.socket != SOAP_INVALID_SOCKET )
         {
             std::unique_lock<std::mutex> guard(m_listMt);
             clientInfo.ip = m_pSoap->ip;
             clientInfo.port = m_pSoap->port;
             m_acceptClientList.push(clientInfo);
             ++m_iClientCount;
             m_cvClient.notify_one();
         }
     }
 }

 void CSoapWebServer::ServiceServeThread(THREAD_INFO* pParam )
 {
     if (NULL == pParam)
     {
         return ;
     }
     THREAD_INFO* info = (THREAD_INFO*)pParam;
     CSoapWebServer *pThis = info->pThis;

     if(NULL == pThis)
     {
         return ;
     }
     ExecuteServe(info);

     delete info;

     return ;
 }
 void CSoapWebServer::ExecuteServe(THREAD_INFO* info )
 {
     const int iTempSockCount = ;
     CLIENT_INFO tempClientArr[iTempSockCount] = {};
     int end_pos = ;
     struct soap* soap = NULL;

     soap = info->soap_client;
     int ret = SOAP_OK;

     while (!m_bExit)
     {
         {
             std::unique_lock<std::mutex> guard(m_listMt);
             if (m_acceptClientList.empty())
             {
                 m_cvClient.wait(guard);
             }
             for (end_pos=;
                 end_pos<iTempSockCount && !m_acceptClientList.empty();
                 ++end_pos )
             {
                 tempClientArr[end_pos] = m_acceptClientList.front();
                 m_acceptClientList.pop();
                 --m_iClientCount;
             }
         }

         for (int i =  ; i < end_pos; ++i)
         {
             soap->socket = tempClientArr[i].socket;
             soap->ip = tempClientArr[i].ip;
             soap->port = tempClientArr[i].port;
             if(!soap_valid_socket(soap->socket))
             {
                 continue;
             }

             if ((ret=BeginServe(soap)) != SOAP_OK)
             {
                 //printf("serve error.code:%d msg:%s\n", soap->error,*(soap_faultstring(soap)));
             }

             if (ret == SOAP_STOP/*(int)soap->user == RESPONSE_MODE_ASYN*/)
             {//异步
                 //获取一个soap
                 soap = PopSoap();
                 if (soap == NULL)
                 {//缓存没有,拷贝一个
                     soap = soap_copy(info->soap_listen);
                 }
             }
             else
             {
                 EndServe(soap);
             }

             soap_destroy(soap);
             soap_end(soap);
         }
     }

     //回收
     PushSoap(soap);
 }

 int CSoapWebServer::SoapServ( struct soap* soap )
 {
 #ifndef WITH_FASTCGI
     unsigned int k = soap->max_keep_alive;
 #endif
     do
     {
 #ifndef WITH_FASTCGI
         if (soap->max_keep_alive >  && !--k)
         {
             soap->keep_alive = ;
         }
 #endif
         if (soap_begin_serve(soap))
         {
             if (soap->error >= SOAP_STOP)
             {
                 continue;
             }
             return soap->error;
         }

 #ifdef WITH_FASTCGI
         soap_destroy(soap);
         soap_end(soap);
     } while ();
 #else
     } while (soap->keep_alive);
 #endif
     return SOAP_OK;
 }

 int CSoapWebServer::BeginServe(struct soap* soap)
 {
     void * user = soap->user;
     long ret = RESPONSE_MODE_SYN;

     soap_begin(soap);
     if (soap_begin_recv(soap)
         || soap_envelope_begin_in(soap)
         || soap_recv_header(soap)
         || soap_body_begin_in(soap))
     { if (soap->error < SOAP_STOP)
     {
 #ifdef WITH_FASTCGI
         (void)soap_send_fault(soap);
 #else
         return soap_send_fault(soap);
 #endif
     }
     }

     ret = (long)soap->user;
     soap->user = user;

     return (ret==RESPONSE_MODE_ASYN) ? SOAP_STOP: SOAP_OK;
 }

 int CSoapWebServer::EndServe(struct soap* soap)
 {
     return soap_closesock(soap);
 }

 struct soap* CSoapWebServer::PopSoap(void)
 {
     struct soap * soap = NULL;
     std::unique_lock<std::mutex> guard(m_listMt);
     if (m_soapList.empty())
     {
         return NULL;
     }
     soap = m_soapList.front();
     m_soapList.pop();

     return soap;
 }

 void CSoapWebServer::PushSoap(struct soap* soap)
 {
     if (soap == NULL)
     {
         return ;
     }

     std::unique_lock<std::mutex> guard(m_listMt);
     m_soapList.push(soap);
 }

 void CSoapWebServer::FreeSoapAll(void)
 {
     std::queue<struct soap*> lsoap;
     {
         std::unique_lock<std::mutex> guard(m_listMt);
         lsoap = m_soapList;
         while (!m_soapList.empty())
         {
             m_soapList.pop();
         }
     }

     struct soap * soap;
     while (!lsoap.empty())
     {
         soap = lsoap.front();

         soap_destroy(soap);
         soap_end(soap); 

         soap_done(soap);
         soap_free(soap);

         lsoap.pop();
     }
 }

6.插件头文件

 #ifndef RestServicePlugin_CEDAF949_DFA9_4D71_95EE_8EE7A7B2BAAB_H__
 #define RestServicePlugin_CEDAF949_DFA9_4D71_95EE_8EE7A7B2BAAB_H__

 #include <string>
 #include <map>
 #include <mutex>

 #if (defined _WIN32 || defined _WIN64)
 #   include <memory>    //shared_ptr
 #   include <functional>
 #elif defined(__linux__)
 #   include <tr1/memory>
 #   include <tr1/functional>
 #endif

 #include "stdsoap2.h"
 #include "httpget.h"
 #include "httppost.h"

 namespace Http
 {
     class CRestServicePlugin;
     class Request;

     typedef int (*RequestProcessFunc)(Request& request, void* user);
     typedef std::tr1::function<int(Request& request)> RequestProcessFunction;
     typedef std::tr1::function<void(struct soap*)> FreeSoapFunction;

     enum HTTP_STATUS
     {
         HTTP_STATUS_OK = ,
         HTTP_STATUS_BAD_REQUEST = , // invalid syntax
         HTTP_STATUS_DENIED = , // access denied
         HTTP_STATUS_PAYMENT_REQ = , // payment required
         HTTP_STATUS_FORBIDDEN = , // request forbidden
         HTTP_STATUS_NOT_FOUND = , // object not found
         HTTP_STATUS_BAD_METHOD = , // method is not allowed
         HTTP_STATUS_NONE_ACCEPTABLE = , // no response acceptable to client found
         HTTP_STATUS_PROXY_AUTH_REQ = , // proxy authentication required
         HTTP_STATUS_REQUEST_TIMEOUT = , // server timed out waiting for request
         HTTP_STATUS_CONFLICT = , // user should resubmit with more info
         HTTP_STATUS_GONE = , // the resource is no longer available
         HTTP_STATUS_LENGTH_REQUIRED = , // the server refused to accept request w/o a length
         HTTP_STATUS_PRECOND_FAILED = , // precondition given in request failed
         HTTP_STATUS_REQUEST_TOO_LARGE = , // request entity was too large
         HTTP_STATUS_URI_TOO_LONG = , // request URI too long
         HTTP_STATUS_UNSUPPORTED_MEDIA = , // unsupported media type
         HTTP_STATUS_RETRY_WITH = , // retry after doing the appropriate action.

         HTTP_STATUS_SERVER_ERROR =  ,// internal server error
         HTTP_STATUS_NOT_SUPPORTED = , // required not supported
         HTTP_STATUS_BAD_GATEWAY = , // error response received from gateway
         HTTP_STATUS_SERVICE_UNAVAIL = , // temporarily overloaded
         HTTP_STATUS_GATEWAY_TIMEOUT = , // timed out waiting for gateway
         HTTP_STATUS_VERSION_NOT_SUP =  // HTTP version not supported
     };

     enum HTTP_METHOD
     {
         HTTP_GET = ,
         HTTP_POST =
     };
     enum HTTP_RES_TYPE
     {
         HTTP_HTML = ,
         HTTP_FILE =
     };
     typedef struct rest_str_s
     {
         size_t  len;    //字符串长度
         char*   ptr;    //字符串首地址
     }rest_str_t;

     typedef struct rest_query_s
     {
         const char* key;
         const char* value;
     }rest_query_t;

     static const size_t QUERY_MAX_SIZE     =   ; //最多参数个数

     class Request
     {
         friend class CRestServicePlugin;
         friend class Response;
     public:
         Request()
         {
             soap = NULL;
         }

         /** @fn     Query
           * @brief  获取url中的请求参数
           * @param  key:
           * @return 返回查询到的值
          */
         const char* Query( const char* key);

         /** @fn     GetBody
           * @brief  获取请求体
           * @param
           * @return 请求内容字节数,0为空
          */
         size_t GetBody(char** body);

         HTTP_METHOD GetMethod(void){ return method;}

     protected:
         /** @fn     GetURI
           * @brief  获取请求的url
           * @param
           * @return
          */
         const char* GetURI();

         int ReponseWithEnd(int code);
         /************************************
         >@ Method:    ParseRequest
         >@ FullName:  Http::Request::ParseRequest
         >@ Brief:          解析请求参数
         >@ Access:      public
         >@ Returns:     bool
         >@ Qualifier:
         ************************************/
         bool ParseRequest();

         rest_query_t* GetQuery(void){return _query;}

     private:
         rest_query_t      _query[QUERY_MAX_SIZE];//请求参数
         HTTP_METHOD method;
         struct soap* soap;
         CRestServicePlugin * _plugin;
     };

 #define RESPONSE_MODE_SYN       0   //同步
 #define RESPONSE_MODE_ASYN      1   //异步

     class Response
     {
     public:
         Response(Request& req, int mod=RESPONSE_MODE_SYN);
         Response();
         ~Response();

         /** @fn     SetContentType
           * @brief  设置响应内容,默认为空,例如"text/json"
           * @param
           * @return
          */
         void SetContentType(const char* conttype);

         /** @fn     Send
           * @brief  发送响应数据,可以调用多次发送
           * @param
           * @return 0-发送成功
          */
         int Send(const char* data);
         int Send(const char* data, std::size_t len);

         /** @fn     BeginResponse
           * @brief  开始响应
           * @param  mod:响应模式,RESPONSE_MODE_SYN-同步,RESPONSE_MODE_ASYN-异步
           * @return
          */
         int BeginResponse(Request& req, int mod=RESPONSE_MODE_SYN);
         int EndResponse(void);

     protected:

     private:
         struct soap * _soap;
         int     _mod;
         CRestServicePlugin  *_plugin;
     };

     class CRestServicePlugin
     {
         friend class Response;
     public:
         CRestServicePlugin(void);
         ~CRestServicePlugin(void);

         static int http_get_handler(struct soap*);
         static int http_post_text_handler(struct soap *soap);
     public:
         bool Hook(struct soap* soap);
         void RegisteURI(const char* URI,RequestProcessFunc fun, void* user);
         void RegisteURI(const char* URI, RequestProcessFunction & fun);
         void UnRegisteURI(const char* URI);
         void ClearURI();

         void RegisterFreeSoap(FreeSoapFunction & fun);
     protected:
         int Process(struct soap* soap,HTTP_METHOD method);
     private:
         std::mutex m_dataMt;
         //uri的处理函数映射表
         std::map<std::size_t,RequestProcessFunction> m_uriFunMap;
         FreeSoapFunction    _funFreeSoap;
     };
 }

 #endif // RestServicePlugin_CEDAF949_DFA9_4D71_95EE_8EE7A7B2BAAB_H__

7.插件cpp文件

 #include "RestServicePlugin.h"
 #include "httpget.h"

 namespace Http
 {
     static const char* json_type = "application/json";
     static const char* http_unknow = "HTTP/1.1 -1 UNKNOW\r\nConnection: close\r\n\r\n";
     static const char* http_400 = "HTTP/1.1 400 BAD REQUEST\r\nConnection: close\r\n\r\n";
     static const char* http_404 = "HTTP/1.1 404 NOT FOUND\r\nConnection: close\r\n\r\n";
     static const char* http_500 = "HTTP/1.1 500 SERVER ERROR\r\nConnection: close\r\n\r\n";

     //FNV hash copy from gcc
     // Dummy generic implementation (for sizeof(size_t) != 4, 8).
     template<std::size_t = sizeof(std::size_t)>
     struct Fnv_hash
     {
         static std::size_t
             hash(const char* first, std::size_t length)
         {
             std::size_t result = ;
             for (; length > ; --length)
                 result = (result * ) + *first++;
             return result;
         }
     };

     template<>
     struct Fnv_hash<>
     {
         static std::size_t
             hash(const char* first, std::size_t length)
         {
             std::size_t result = static_cast<std::size_t>(2166136261UL);
             for (; length > ; --length)
             {
                 result ^= (std::size_t)*first++;
                 result *= 16777619UL;
             }
             return result;
         }
     };

     template<>
     struct Fnv_hash<>
     {
         static std::size_t
             hash(const char* first, std::size_t length)
         {
             std::size_t result = static_cast<std::size_t>(14695981039346656037ULL);
             for (; length > ; --length)
             {
                 result ^= (std::size_t)*first++;
                 result *= 1099511628211ULL;
             }
             return result;
         }
     };

     http_post_handlers handlers[] =
     {
         { "POST",   Http::CRestServicePlugin::http_post_text_handler },
         { NULL }
     };

     //////////////////////////////////////////////////////////////////////////
     //CRestServicePlugin
     CRestServicePlugin::CRestServicePlugin(void)

     {
     }

     CRestServicePlugin::~CRestServicePlugin(void)
     {
     }

     bool CRestServicePlugin::Hook( struct soap* soap )
     {
         if (NULL == soap)
         {
             return false;
         }
         soap->user = (void*)this;
         soap_register_plugin_arg(soap, http_get, (void*)http_get_handler);
         soap_register_plugin_arg(soap,http_post,(void*)handlers);
         return true;
     }

     void CRestServicePlugin::RegisteURI( const char* URI,RequestProcessFunc fun , void* user)
     {
         std::tr1::function<int(Request& request)> funl;
         funl = std::tr1::bind(fun, std::tr1::placeholders::_1, user);

         RegisteURI(URI, funl);
     }

     void CRestServicePlugin::RegisteURI(const char* URI, RequestProcessFunction & fun)
     {
         size_t hash_uri = Fnv_hash<>::hash(URI, strlen(URI));

         std::lock_guard<std::mutex> guard(m_dataMt);
         std::map<size_t, RequestProcessFunction>::iterator iter = m_uriFunMap.find(hash_uri);
         if (iter != m_uriFunMap.end())
         {
             iter->second = fun;
         }
         else
         {
             m_uriFunMap.insert(std::map<size_t,RequestProcessFunction>::value_type(hash_uri,fun));
         }
     }

     void CRestServicePlugin::RegisterFreeSoap(FreeSoapFunction & fun)
     {
         _funFreeSoap = fun;
     }

     void CRestServicePlugin::UnRegisteURI( const char* URI )
     {
         size_t hash_uri = Fnv_hash<>::hash(URI, strlen(URI));

         std::lock_guard<std::mutex> guard(m_dataMt);
         std::map<size_t,RequestProcessFunction>::iterator iter = m_uriFunMap.find(hash_uri);
         if (iter != m_uriFunMap.end())
         {
             m_uriFunMap.erase(iter);
         }
     }

     void CRestServicePlugin::ClearURI()
     {
         std::lock_guard<std::mutex> guard(m_dataMt);
         m_uriFunMap.clear();
         _funFreeSoap = NULL;
     }

     int CRestServicePlugin:: http_get_handler(struct soap* soap)
     {
         if (soap == NULL || soap->user == NULL)
         {
             return SOAP_ERR;
         }
         Http::CRestServicePlugin* pThis = (CRestServicePlugin*)soap->user;
         return pThis->Process(soap,HTTP_GET);
     }

     /* the text handler copies the message back */
     int CRestServicePlugin:: http_post_text_handler(struct soap *soap)
     {
         if (soap == NULL || soap->user == NULL)
         {
             return SOAP_ERR;
         }
         Http::CRestServicePlugin* pThis = (CRestServicePlugin*)soap->user;
         return pThis->Process(soap,HTTP_POST);
     }

     int CRestServicePlugin::Process( struct soap* soap ,HTTP_METHOD method)
     {
         Request request;
         request.method = method;
         request.soap = soap;
         request._plugin = this;

         std::tr1::function<int(Request& request)> *fun = NULL;
         {
             char* uri = query(soap);
             size_t hash_uri = Fnv_hash<>::hash(soap->path, uri? (uri-soap->path): strlen(soap->path));

             std::lock_guard<std::mutex> guard(m_dataMt);
             std::map<size_t,RequestProcessFunction>::iterator iter = m_uriFunMap.find(hash_uri);
             if (iter != m_uriFunMap.end())
             {
                 fun = &iter->second;
             }
         }

         if(!request.ParseRequest() || fun==NULL)
         {
             return request.ReponseWithEnd(HTTP_STATUS_NOT_FOUND);
         }
         return (*fun)(request);
     }

     //////////////////////////////////////////////////////////////////////////
     //Request
     const char* Request::GetURI( )
     {
         return soap->path;
     }
     bool Request::ParseRequest()
     {
         char *s;
         s = query(soap);
         int i = ;
         while (s && s[] != '\0' && i<QUERY_MAX_SIZE)
         {
             char *key = query_key(soap,&s);
             if (key == NULL)
             {
                 continue;
             }
             char* val = query_val(soap,&s);
             if (val == NULL)
             {
                 continue;
             }

             _query[i].key = key;
             _query[i].value = val;
             ++i;
         }

         if (i<QUERY_MAX_SIZE)
         {//最后一个初始化为空
             _query[i].key = NULL;
         }

         return true;
     }

     const char* Request::Query( const char* key)
     {
         if (key == NULL)
         {
             return NULL;
         }

         int i = ;
         while (i<QUERY_MAX_SIZE && _query[i].key!=NULL)
         {
             if (strcmp(_query[i].key, key) == )
             {
                 return _query[i].value;
             }
             ++i;
         }

         return NULL;
     }

     int Request::ReponseWithEnd( int code )
     {
         const char* res = NULL;
         switch(code)
         {
         case HTTP_STATUS_BAD_REQUEST:
             res = http_400;
             break;
         case HTTP_STATUS_NOT_FOUND:
             res = http_404;
             break;
         case HTTP_STATUS_SERVER_ERROR:
             res = http_500;
             break;
         default:
             res = http_unknow;
             break;
         }
         soap_send(soap,res);
         soap_end_send(soap);

         return SOAP_OK;
     }

     size_t Request::GetBody(char** body )
     {
         size_t len = ;
         if(SOAP_OK != soap_http_body(soap, body, &len))
         {
             return ;
         }

         return len;
     }

     //////////////////////////////////////////////////////////////////////////
     //response
     Response::Response()
     {
         _soap = NULL;
         _mod = RESPONSE_MODE_SYN;
         //soap->user = RESPONSE_MODE_SYN;
         _plugin = NULL;
     }

     Response::Response(Request& req, int mod)
     {
         _soap = NULL;

         BeginResponse(req, mod);
     }

     Response::~Response()
     {
         EndResponse();
     }

     void Response::SetContentType(const char* conttype)
     {
         _soap->http_content = conttype;
     }

     int Response::Send(const char* data)
     {
         return Send(data, strlen(data));
     }

     int Response::Send(const char* data, std::size_t len)
     {
         return soap_send_raw(_soap, data, len);
     }

     int Response::BeginResponse(Request& req, int mod)
     {
         EndResponse();

         _soap = req.soap;
         _mod = mod;
         _soap->user = (void*)_mod;
         _plugin = req._plugin;

         return soap_response(_soap ,SOAP_FILE);
     }

     int Response::EndResponse(void)
     {
         int ret = SOAP_OK;
         if (_soap == NULL)
         {
             return SOAP_OK;
         }

         ret = soap_end_send(_soap);

         if (_mod == RESPONSE_MODE_ASYN)
         {//如果是异步模式,需要释放
             soap_destroy(_soap);
             soap_end(_soap);
             if (_plugin->_funFreeSoap)
             {
                 _plugin->_funFreeSoap(_soap);
             }
             else
             {
                 soap_done(_soap);
                 soap_free(_soap);
             }
         }

         _soap = NULL;
         _mod = RESPONSE_MODE_SYN;
         _plugin = NULL;

         return ret;
     }

 }//namespace Http

8.使用例子

 #include "./web/SoapWebServer.h"
 #include "cJSON.h"

 #include <thread>

 bool static copy_file(Response* res, const char *name)
 {
     FILE *fd;
     size_t r;
     fd = fopen(name, "rb"); /* open file to copy */
     if (!fd)
         return false; /* return HTTP not found */

     int tmpbuf_len = ;
     char *tmpbuf = new char[tmpbuf_len];

     for (;;)
     {
         r = fread(tmpbuf, , tmpbuf_len, fd);
         if (!r)
             break;
         if (res->Send(tmpbuf, r))
         {//发送失败
             fclose(fd);
             return false;
         }
         //Sleep(70);
     }
     delete []tmpbuf;
     fclose(fd);

     return true;
 }

 void ThreadResponseImg(Response* res)
 {
     bool bret = false;

     res->SetContentType("image/jpeg");
     bret = copy_file(res, "E:\\test\\testimage\\v1.jpg");

     //printf("发送文件 %s\n", bret?"成功":"失败");

     delete res;
 }

 static int api_login(Request &req, void *user)
 {
     char * body = NULL;
     if (req.GetBody(&body))
     {
         printf("request login=%s\n", body);
     }

     cJSON *jsonRes = NULL;
     jsonRes = cJSON_CreateObject();
     cJSON_AddNumberToObject(jsonRes, "errorCode", );
     cJSON_AddStringToObject(jsonRes, "token", "fd90bba04662411f86d8936900131936");
     char * str = cJSON_Print(jsonRes);

     Response resp(req);
     resp.Send(str);

     cJSON_Delete(jsonRes);
     free(str);

     return ;
 }

 class print_json
 {
 public:
     print_json()
     {
         //printf("cons print_json \n");
     }
     ~print_json()
     {
         printf("des print_json\n");
     }
     int print_person(Request &req)
     {
         Response res(req);
         res.SetContentType("application/json; charset=utf-8");
         res.Send("{\"print_person\" : 10}");

         return ;
     }

     int print_query(Request &req)
     {
         Response res(req);
         res.SetContentType("application/json; charset=utf-8");
         res.Send("{\"print_query\" : 10}");

         /*for (rest_query_t *q = req.GetQuery(); q->key; ++q)
         {
             printf("key-%s,val-%s", q->key, q->value);
         }*/
         printf("\n");

         return ;
     }

     int print_img(Request &req)
     {
         Response *res = new Response;
         res->BeginResponse(req, RESPONSE_MODE_SYN);

         ThreadResponseImg(res); //同步

         //这里可以开启线程进行异步发送RESPONSE_MODE_ASYN
         //std::thread t1(ThreadResponseImg, res);
         //t1.detach();

         return ;
     }

 protected:
 private:
 };

 int main(int argc, char* argv[])
 {
     print_json pt;
     CSoapWebServer web;
     const char* host = "0.0.0.0";
     unsigned port = ;
     web.StartService(host, port);
     printf("start listen %s:%u\n", host, port);

     //tr1 bug 不能把bind作为参数传递
     //web.SetURI("/json", std::tr1::bind(&print_json::print, &pt, std::tr1::placeholders::_1));
     web.SetURI("/json", (RequestProcessFunction)std::tr1::bind(
         &print_json::print_person, &pt, std::tr1::placeholders::_1));
     web.SetURI("/json1", (RequestProcessFunction)std::tr1::bind(
         &print_json::print_query, &pt, std::tr1::placeholders::_1));

     web.SetURI("/img", (RequestProcessFunction)std::tr1::bind(
         &print_json::print_img, &pt, std::tr1::placeholders::_1));

     web.SetURI("/login", api_login, NULL);

     getchar();

     web.StopService();

     return ;
 }

在浏览器中访问接口：
http://127.0.0.1:56789/json
这个接口返回json内容：

{"print_person" : 10}

http://127.0.0.1:56789/img
这个接口返回的是一张图片