基于 C++ POCO 库封装的异步多线程的 CHttpClient 类

用惯了 Jetty 的 基于事件的 HttpClient 类，在C++平台上也没找到这样调用方式的类库，只好自己写一个了。

目前版本 1.0，朋友们看了给点建议。（注：Kylindai原创，转载请注明出处）

Feature: 基于C++跨平台的 POCO 库实现，支持线程池 Poco::ThreadPool， 异步 HttpClient， 支持Http事件回调处理。

 

基本思路，核心方法：

/**

 * 创建多线程支持的HttpClient,

 * nTimeout 超时

 * nMaxThreads 最大线程数

 * pLogFileName 日志文件

 */

CHttpClient.Create(int nTimeout, int nMaxThreads, char * pLogFileName = NULL);

 

/**

 * 发送请求，此方法会创建一个 CHttpTask 放到线程池里，然后由线程发起 HTTPClientSession 请求，

 * 收到响应后，回调 CHttpExchange.GetHandler().OnResponseComplate() 方法。

 * 类似 Java Jetty的 HttpClient.send(HttpExchange exchange)

 * pExchange CHttpExchange HTTP 交换类

 */

CHttpClient.Send(CHttpExchange * pExchange); 

 1  void  CHttpClient::Send(CHttpExchange  *  pExchange)
 2  {
 3       try  
 4      {
 5          CHttpTask  *  pHttpTask  =   new  CHttpTask(pExchange, m_timeout, m_pLogger);
 6          ThreadPool::defaultPool().start( *  pHttpTask);
 7      } 
 8       catch  (Exception &  ex)
 9      {
10           if  (m_pLogger  !=  NULL)
11          {
12              m_pLogger -> error(ex.displayText());
13          }
14      }
15  }

 

 

/**

 * 线程池中任务 CHttpTask.run 处理Http请求及响应

 */

CHttpTask : public Runnable

 1  void  CHttpTask::run()
 2  {
 3      CHttpHandler  *  pHandler  =  m_pExchange -> GetHandler();
 4 
 5       try
 6      {
 7          HTTPClientSession httpClientSession;
 8          httpClientSession.setHost(m_pExchange -> GetHost());
 9          httpClientSession.setTimeout(m_timeout);
10          httpClientSession.sendRequest(m_pExchange -> GetHttpRequest());
11 
12          HTTPResponse response;
13          istream &  rs  =  httpClientSession.receiveResponse(response);
14 
15           if  (pHandler  !=  NULL)
16          {
17               const   string &  contentType  =  response.getContentType();
18               if  (contentType.find( " text/ " )  >=   0 )
19              {
20                  stringstream responseStream;
21                  StreamCopier::copyStream(rs, responseStream);
22 
23                   string  responseContent;
24                  responseStream  >>  responseContent;
25 
26                  pHandler -> OnResponseComplete(response.getStatus(), responseContent);
27              }
28          }
29      }
30       catch  (Exception &  ex)
31      {
32           if  (m_pLogger  !=  NULL)
33          {
34              m_pLogger -> error(ex.displayText());
35          }
36      }
37 
38       if  (pHandler  !=  NULL)
39      {
40          delete pHandler;
41      }
42 
43      delete  this ;
44  }

 

/**

 * 为HttpExchange 设置 Handler 处理回调类，以后具体的逻辑由 CHttpHandler 继承的具体业务处理逻辑类完成。

 * pHandler CHttpHandler HTTP 事件处理类

 */

CHttpExchange.SetHandler(CHttpHandler * pHandler);

 

/**

 * 当收到响应完成时的事件回调函数，传入 HttpStatus 和 文本的Response，

 * 目前仅支持文本 Response，即：Resonse.getContentType() 为 text 类型

 */

CHttpHandler.OnResponseComplate(HTTPResponse::HTTPStatus status, const string& responseContent);

CCheckVersionHandler : public CHttpHandler

 

 1  void  CCheckVersionHandler::OnResponseComplete(HTTPResponse::HTTPStatus status,  const   string &  responseContent)
 2  {
 3      CHttpHandler::OnResponseComplete(status, responseContent);
 4 
 5       if  (status  ==  HTTPResponse::HTTP_OK)
 6      {
 7           const   string &  version  =  responseContent;
 8 
 9          m_pMainWnd -> ShowVersionMessage(version);
10      }
11  }

 

（一）CHttpClient CHttpExchange CHttpHandler 类图：

 

（二）代码：

HttpClient.h

  1  //////////////////////////////////////////////////////////////////////// //
  2  //   HttpClient.h
  3  //   Author: Kylin.dai @kylindai
  4  //   Date: 2011-05-21
  5  //////////////////////////////////////////////////////////////////////// //
  6 
  7  #pragma  once
  8 
  9  #include  " Poco/AutoPtr.h "
 10  #include  " Poco/Logger.h "
 11  #include  " Poco/PatternFormatter.h "
 12  #include  " Poco/FormattingChannel.h "
 13  #include  " Poco/ConsoleChannel.h "
 14  #include  " Poco/FileChannel.h "
 15  #include  " Poco/Message.h "
 16  #include  " Poco/Exception.h "
 17  #include  " Poco/StreamCopier.h "
 18  #include  " Poco/ThreadPool.h "
 19  #include  " Poco/Thread.h "
 20  #include  " Poco/Mutex.h "
 21  #include  " Poco/Runnable.h "
 22  #include  " Poco/Stopwatch.h "
 23  #include  " Poco/Net/HTTPClientSession.h "
 24  #include  " Poco/Net/HTTPRequest.h "
 25  #include  " Poco/Net/HTTPResponse.h "
 26 
 27  #include  < string >
 28  #include  < iostream >
 29  #include  < sstream >
 30  #include  < fstream >
 31  #include  < map >
 32 
 33  using   namespace  std;
 34  using   namespace  Poco;
 35  using   namespace  Poco::Net;
 36 
 37  //////////////////////////////////////////////////////////////////////// //
 38  //  CHttpHandler Class
 39  //////////////////////////////////////////////////////////////////////// //
 40  class  CHttpHandler
 41  {
 42  public :
 43      CHttpHandler( char   *  pLogFileName  =  NULL);
 44       ~ CHttpHandler();
 45 
 46  private :
 47      map < const   string , LPVOID >  m_attributeMap;
 48 
 49  protected :
 50      Logger  *  m_pLogger;
 51 
 52  public :
 53       void  SetAttribute( const   string &  name, LPVOID value);
 54      LPVOID GetAttribute( const   string &  name);
 55 
 56       virtual   void  OnException();
 57       virtual   void  OnExpire();
 58       virtual   void  OnRequestComplete();
 59       virtual   void  OnResponseComplete(HTTPResponse::HTTPStatus status,  const   string &  responseContent);
 60  };
 61 
 62  //////////////////////////////////////////////////////////////////////// //
 63  //  CHttpExchange Class
 64  //////////////////////////////////////////////////////////////////////// //
 65  class  CHttpExchange
 66  {
 67  public :
 68      CHttpExchange();
 69       ~ CHttpExchange();
 70 
 71  private :
 72       int  m_timeout;
 73      HTTPRequest  *  m_pRequest;
 74      CHttpHandler  *  m_pHandler;
 75 
 76  public :
 77      HTTPRequest &  GetHttpRequest();
 78 
 79       void  SetMethod( const   string &  strMethod);
 80       const   string &  GetMethod()  const ;
 81 
 82       void  SetContentType( const   string &  strContentType);
 83       const   string &  GetContentType()  const ;
 84 
 85       void  SetHost( const   string &  strHost);
 86       const   string &  GetHost()  const ;
 87 
 88       void  SetUri( const   string &  strUri);
 89       const   string &  GetUri()  const ;
 90 
 91       void  SetHandler(CHttpHandler  *  pHandler);
 92      CHttpHandler  *  GetHandler();
 93  };
 94 
 95  //////////////////////////////////////////////////////////////////////// //
 96  //  CHttpTask Class
 97  //////////////////////////////////////////////////////////////////////// //
 98  class  CHttpTask :  public  Runnable
 99  {
100  public :
101      CHttpTask(CHttpExchange  *  pExchange,  int  timeout  =   15000 , Logger  *  pLogger  =  NULL);
102       ~ CHttpTask();
103 
104  private :
105      CHttpExchange  *  m_pExchange;
106       int  m_timeout;
107 
108  protected :
109      Logger  *  m_pLogger;
110 
111  public :
112       void  run();
113  };
114 
115  //////////////////////////////////////////////////////////////////////// //
116  //  CHttpClient Class
117  //////////////////////////////////////////////////////////////////////// //
118  class  CHttpClient
119  {
120  public :
121      CHttpClient();
122       ~ CHttpClient();
123 
124  private :
125       int  m_timeout;
126       int  m_threads;
127       char   *  m_pLogFileName;
128 
129  protected :
130      Logger  *  m_pLogger;
131 
132  public :
133       void  Create( int  timeout  =   15000 ,  int  threads  =   20 ,  char   *  pLogFileName  =  NULL);
134       void  Start();
135       void  Stop();
136       void  Send(CHttpExchange  *  pExchange);
137  };

 

 

HttpClient.cpp

  1  //////////////////////////////////////////////////////////////////////// //
  2  //   HttpClient.cpp
  3  //   Author: Kylin.dai @kylindai
  4  //   Date: 2011-05-21
  5  //////////////////////////////////////////////////////////////////////// //
  6 
  7  #include  " HttpClient.h "
  8 
  9  //////////////////////////////////////////////////////////////////////// //
 10  //  CHttpHandler Methods
 11  //////////////////////////////////////////////////////////////////////// //
 12  CHttpHandler::CHttpHandler( char   *  pLogFileName)
 13  {
 14      m_pLogger  =  NULL;
 15 
 16       //  create logger
 17       if  (pLogFileName  !=  NULL) 
 18      {
 19           try
 20          {
 21               string  logFileName(pLogFileName);
 22 
 23              FormattingChannel *  pFCFile  =   new  FormattingChannel( new  PatternFormatter( " %Y-%m-%d %H:%M:%S.%c %N[%P]:%s:%q:%t " ));
 24              pFCFile -> setChannel( new  FileChannel(logFileName));
 25              pFCFile -> open();
 26 
 27              m_pLogger  =   &  Logger::create( " HttpHandler " , pFCFile, Message::PRIO_DEBUG);  // Message::PRIO_WARNING);
 28          }
 29           catch  (Exception &  ex)
 30          {
 31          }
 32      } 
 33  }
 34 
 35  CHttpHandler:: ~ CHttpHandler()
 36  {
 37       if  (m_pLogger  !=  NULL)
 38      {
 39          m_pLogger -> getChannel() -> close();
 40      }
 41  }
 42 
 43  void  CHttpHandler::SetAttribute( const   string &  name, LPVOID value)
 44  {
 45      m_attributeMap[name]  =  value;
 46  }
 47 
 48  LPVOID CHttpHandler::GetAttribute( const   string &  name)
 49  {
 50       return  m_attributeMap[name];
 51  }
 52 
 53  void  CHttpHandler::OnException()
 54  {
 55 
 56  }
 57 
 58  void  CHttpHandler::OnExpire()
 59  {
 60 
 61  }
 62 
 63  void  CHttpHandler::OnRequestComplete()
 64  {
 65 
 66  }
 67 
 68  void  CHttpHandler::OnResponseComplete(HTTPResponse::HTTPStatus status,  const   string &  responseContent)
 69  {
 70       if  (m_pLogger  !=  NULL)
 71      {
 72          stringstream messageStream;
 73          messageStream  <<   " HTTP STATUS: "   <<  status  <<   "  :  "   <<  responseContent  <<  endl;
 74 
 75          m_pLogger -> debug(messageStream.str());
 76      }
 77  }
 78 
 79  //////////////////////////////////////////////////////////////////////// //
 80  //  CHttpExchange Methods
 81  //////////////////////////////////////////////////////////////////////// //
 82  CHttpExchange::CHttpExchange() 
 83  {
 84      m_pRequest  =   new  HTTPRequest();
 85      m_pRequest -> setVersion(HTTPRequest::HTTP_1_1);
 86  }
 87 
 88  CHttpExchange:: ~ CHttpExchange()
 89  {
 90       if  (m_pRequest  !=  NULL)
 91      {
 92  //         delete m_pRequest;
 93      }
 94  }
 95 
 96  HTTPRequest &  CHttpExchange::GetHttpRequest()
 97  {
 98       return   *  m_pRequest;
 99  }
100 
101  void  CHttpExchange::SetMethod( const   string &  strMethod)
102  {
103      m_pRequest -> setMethod(strMethod);
104  }
105 
106  const   string &  CHttpExchange::GetMethod()  const
107  {
108       return  m_pRequest -> getMethod();
109  }
110 
111  void  CHttpExchange::SetContentType( const   string &  strContentType)
112  {
113      m_pRequest -> setContentType(strContentType);
114  }
115 
116  const   string &  CHttpExchange::GetContentType()  const
117  {
118       return  m_pRequest -> getContentType();
119  }
120 
121  void  CHttpExchange::SetHost( const   string &  strHost)
122  {
123      m_pRequest -> setHost(strHost);
124  }
125 
126  const   string &  CHttpExchange::GetHost()  const
127  {
128       return  m_pRequest -> getHost();
129  }
130 
131  void  CHttpExchange::SetUri( const   string &  strUri)
132  {
133      m_pRequest -> setURI(strUri);
134  }
135 
136  const   string &  CHttpExchange::GetUri()  const
137  {
138       return  m_pRequest -> getURI();
139  }
140 
141  void  CHttpExchange::SetHandler(CHttpHandler  *  pHandler)
142  {
143      m_pHandler  =  pHandler;
144  }
145 
146  CHttpHandler  *  CHttpExchange::GetHandler()
147  {
148       return  m_pHandler;
149  }
150 
151  //////////////////////////////////////////////////////////////////////// //
152  //  CHttpTask Methods
153  //////////////////////////////////////////////////////////////////////// //
154  CHttpTask::CHttpTask(CHttpExchange  *  pExchange,  int  timeout, Logger  *  pLogger):
155      m_pExchange(pExchange),
156      m_timeout(timeout),
157      m_pLogger(pLogger)
158  {
159      
160  }
161 
162  CHttpTask:: ~ CHttpTask()
163  {
164       if  (m_pExchange  !=  NULL)
165      {
166          delete m_pExchange;
167      }
168  }
169 
170  void  CHttpTask::run()
171  {
172      CHttpHandler  *  pHandler  =  m_pExchange -> GetHandler();
173 
174       try
175      {
176          HTTPClientSession httpClientSession;
177          httpClientSession.setHost(m_pExchange -> GetHost());
178          httpClientSession.setTimeout(m_timeout);
179          httpClientSession.sendRequest(m_pExchange -> GetHttpRequest());
180 
181          HTTPResponse response;
182          istream &  rs  =  httpClientSession.receiveResponse(response);
183 
184           if  (pHandler  !=  NULL)
185          {
186               const   string &  contentType  =  response.getContentType();
187               if  (contentType.find( " text/ " )  >=   0 )
188              {
189                  stringstream responseStream;
190                  StreamCopier::copyStream(rs, responseStream);
191 
192                   string  responseContent;
193                  responseStream  >>  responseContent;
194 
195                  pHandler -> OnResponseComplete(response.getStatus(), responseContent);
196              }
197          }
198      }
199       catch  (Exception &  ex)
200      {
201           if  (m_pLogger  !=  NULL)
202          {
203              m_pLogger -> error(ex.displayText());
204          }
205      }
206 
207       if  (pHandler  !=  NULL)
208      {
209          delete pHandler;
210      }
211 
212      delete  this ;
213  }
214 
215  //////////////////////////////////////////////////////////////////////// //
216  //  CHttpClient Methods
217  //////////////////////////////////////////////////////////////////////// //
218  CHttpClient::CHttpClient()
219  {
220      m_pLogger  =  NULL;
221  }
222 
223  CHttpClient:: ~ CHttpClient()
224  {
225       if  (m_pLogger  !=  NULL)
226      {
227          m_pLogger -> getChannel() -> close();
228      }
229  }
230 
231  void  CHttpClient::Create( int  timeout,  int  threads,  char   *  pLogFileName)
232  {
233      m_timeout  =  timeout;
234      m_threads  =  threads;
235      m_pLogFileName  =  pLogFileName;
236 
237      ThreadPool::defaultPool().addCapacity(threads);
238 
239       //  create logger
240       if  (pLogFileName  !=  NULL) 
241      {
242           try
243          {
244               string  logFileName(pLogFileName);
245 
246              FormattingChannel *  pFCFile  =   new  FormattingChannel( new  PatternFormatter( " %Y-%m-%d %H:%M:%S.%c %N[%P]:%s:%q:%t " ));
247              pFCFile -> setChannel( new  FileChannel(logFileName));
248              pFCFile -> open();
249 
250              m_pLogger  =   &  Logger::create( " fileLogger " , pFCFile, Message::PRIO_WARNING);
251          }
252           catch  (Exception &  ex)
253          {
254          }
255      } 
256       /*
257      else 
258      {
259          FormattingChannel* pFCConsole = new FormattingChannel(new PatternFormatter("%s: %p: %t"));
260          pFCConsole->setChannel(new ConsoleChannel);
261          pFCConsole->open();
262 
263          m_pLogger = & Logger::create("ConsoleLogger", pFCConsole, Message::PRIO_DEBUG);
264      }
265       */
266  }
267 
268  void  CHttpClient::Start()
269  {
270 
271  }
272 
273  void  CHttpClient::Stop()
274  {
275  //     ThreadPool::defaultPool().joinAll();
276  }
277 
278  void  CHttpClient::Send(CHttpExchange  *  pExchange)
279  {
280       try  
281      {
282          CHttpTask  *  pHttpTask  =   new  CHttpTask(pExchange, m_timeout, m_pLogger);
283          ThreadPool::defaultPool().start( *  pHttpTask);
284      } 
285       catch  (Exception &  ex)
286      {
287           if  (m_pLogger  !=  NULL)
288          {
289              m_pLogger -> error(ex.displayText());
290          }
291      }
292  }

 

 

转载于:https://www.cnblogs.com/kylindai/archive/2011/05/22/2053173.html