基于 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 }

秒客网

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

相关文章