睿豐德科技 專注RFID識別技術和條碼識別技術與管理軟件的集成項目。質量追溯系統、MES系統、金蝶與條碼系統對接、用友與條碼系統對接

HTTP協議工作方式首先客戶端發送一個請求(request)給服務器，服務器在接收到這個請求后將生成一個響應(response)返回給客戶端。
在這個通信的過程中HTTP協議在以下4個方面做了規定：
1. Request和Response的格式
Request格式：

HTTP請求行 
（請求）頭 
空行 
可選的消息體 

注：請求行和標題必須以<CR><LF> 作為結尾（也就是，回車然后換行）。空行內必須只有<CR><LF>而無其他空格。在HTTP/1.1 協議中，所有的請求頭，除Host外，都是可選的。

實例：

1. GET / HTTP/1.1  
2.   
3.   
4. Host: gpcuster.cnblogs.com  
5.   
6.   
7. User-Agent: Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.0.10) Gecko/2009042316 Firefox/3.0.10  
8.   
9.   
10. Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8  
11.   
12.   
13. Accept-Language: en-us,en;q=0.5  
14.   
15.   
16. Accept-Encoding: gzip,deflate  
17.   
18.   
19. Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7  
20.   
21.   
22. Keep-Alive: 300  
23.   
24.   
25. Connection: keep-alive  
26.   
27.   
28. If-Modified-Since: Mon, 25 May 2009 03:19:18 GMT  

Response格式：


HTTP狀態行 
（應答）頭 
空行 
可選的消息體


實例：

1. HTTP/1.1 200 OK  
2.   
3.   
4. Cache-Control: private, max-age=30  
5.   
6.   
7. Content-Type: text/html; charset=utf-8  
8.   
9.   
10. Content-Encoding: gzip  
11.   
12.   
13. Expires: Mon, 25 May 2009 03:20:33 GMT  
14.   
15.   
16. Last-Modified: Mon, 25 May 2009 03:20:03 GMT  
17.   
18.   
19. Vary: Accept-Encoding  
20.   
21.   
22. Server: Microsoft-IIS/7.0  
23.   
24.   
25. X-AspNet-Version: 2.0.50727  
26.   
27.   
28. X-Powered-By: ASP.NET  
29.   
30.   
31. Date: Mon, 25 May 2009 03:20:02 GMT  
32.   
33.   
34. Content-Length: 12173  

消息體的內容（略）詳細的信息請參考：RFC 2616。關于HTTP headers的簡要介紹，請查看：Quick reference to HTTP headers


2.建立連接的方式

HTTP支持2中建立連接的方式：非持久連接和持久連接(HTTP1.1默認的連接方式為持久連接)。

1)非持久連接

讓我們查看一下非持久連接情況下從服務器到客戶傳送一個Web頁面的步驟。假設該貝面由1個基本HTML文件和10個JPEG圖像構成，而且所有這些對象都存放在同一臺服務器主機中。再假設該基本HTML文件的URL為：gpcuster.cnblogs.com/index.html。

下面是具體步騾:

1.HTTP客戶初始化一個與服務器主機gpcuster.cnblogs.com中的HTTP服務器的TCP連接。HTTP服務器使用默認端口號80監聽來自HTTP客戶的連接建立請求。

2.HTTP客戶經由與TCP連接相關聯的本地套接字發出—個HTTP請求消息。這個消息中包含路徑名/somepath/index.html。

3.HTTP服務器經由與TCP連接相關聯的本地套接字接收這個請求消息，再從服務器主機的內存或硬盤中取出對象/somepath/index.html，經由同一個套接字發出包含該對象的響應消息。

4.HTTP服務器告知TCP關閉這個TCP連接(不過TCP要到客戶收到剛才這個響應消息之后才會真正終止這個連接)。

5.HTTP客戶經由同一個套接字接收這個響應消息。TCP連接隨后終止。該消息標明所封裝的對象是一個HTML文件。客戶從中取出這個文件，加以分析后發現其中有10個JPEG對象的引用。

6.給每一個引用到的JPEG對象重復步騾1-4。

上述步驟之所以稱為使用非持久連接，原因是每次服務器發出一個對象后，相應的TCP連接就被關閉，也就是說每個連接都沒有持續到可用于傳送其他對象。每個TCP連接只用于傳輸一個請求消息和一個響應消息。就上述例子而言，用戶每請求一次那個web頁面，就產生11個TCP連接。

2)持久連接

非持久連接有些缺點。首先，客戶得為每個待請求的對象建立并維護一個新的連接。對于每個這樣的連接，TCP得在客戶端和服務器端分配TCP緩沖區，并維持TCP變量。對于有可能同時為來自數百個不同客戶的請求提供服務的web服務器來說，這會嚴重增加其負擔。其次，如前所述，每個對象都有2個RTT的響應延長——一個RTT用于建立TCP連接，另—個RTT用于請求和接收對象。最后，每個對象都遭受TCP緩啟動，因為每個TCP連接都起始于緩啟動階段。不過并行TCP連接的使用能夠部分減輕RTT延遲和緩啟動延遲的影響。

在持久連接情況下，服務器在發出響應后讓TCP連接繼續打開著。同一對客戶/服務器之間的后續請求和響應可以通過這個連接發送。整個Web頁面(上例中為包含一個基本HTMLL文件和10個圖像的頁面)自不用說可以通過單個持久TCP連接發送:甚至存放在同一個服務器中的多個web頁面也可以通過單個持久TCP連接發送。通常，HTTP服務器在某個連接閑置一段特定時間后關閉它，而這段時間通常是可以配置的。持久連接分為不帶流水線(without pipelining)和帶流水線(with pipelining)兩個版本。如果是不帶流水線的版本，那么客戶只在收到前一個請求的響應后才發出新的請求。這種情況下，web頁面所引用的每個對象(上例中的10個圖像)都經歷1個RTT的延遲，用于請求和接收該對象。與非持久連接2個RTT的延遲相比，不帶流水線的持久連接已有所改善，不過帶流水線的持久連接還能進一步降低響應延遲。不帶流水線版本的另一個缺點是，服務器送出一個對象后開始等待下一個請求，而這個新請求卻不能馬上到達。這段時間服務器資源便閑置了。

HTTP/1.1的默認模式使用帶流水線的持久連接。這種情況下，HTTP客戶每碰到一個引用就立即發出一個請求，因而HTTP客戶可以一個接一個緊挨著發出各個引用對象的請求。服務器收到這些請求后，也可以一個接一個緊挨著發出各個對象。如果所有的請求和響應都是緊挨著發送的，那么所有引用到的對象一共只經歷1個RTT的延遲(而不是像不帶流水線的版本那樣，每個引用到的對象都各有1個RTT的延遲)。另外，帶流水線的持久連接中服務器空等請求的時間比較少。與非持久連接相比，持久連接(不論是否帶流水線)除降低了1個RTT的響應延遲外，緩啟動延遲也比較小。其原因在于既然各個對象使用同一個TCP連接，服務器發出第一個對象后就不必再以一開始的緩慢速率發送后續對象。相反，服務器可以按照第一個對象發送完畢時的速率開始發送下一個對象。在http1.0協議中每次請求和響應都會創建一個新的tcp連接，http1.1之后才開始支持可以重用第一次請求的http連接， 默認支持長連接形式。 如果client或server端不想支持長連接，則需要在htt的header加上connection:close，如果支持，則設置header為connection:keep-alive。

以上主要是簡要闡述了http請求的流程，需要實現一個簡易的httpclient，需要注意：

1）短連接or長連接。
2）header的解析與構建。
3）body的解析與構建。
4）chunk與content-length的不同解析方式。
5）http method的不同。
....

如下主要是根據實例化的httpRequest生成header，支持POST，GET，OPTIONS三種method。

1. string TC_HttpRequest::encode()  
2. {  
3. //    assert(_requestType == REQUEST_GET || _requestType == REQUEST_POST || !_originRequest.empty());  
4.   
5.   
6.     ostringstream os;  
7.   
8.   
9.     if(_requestType == REQUEST_GET)  
10.     {  
11.         encode(REQUEST_GET, os);  
12.     }  
13.     else if(_requestType == REQUEST_POST)  
14.     {  
15.         setContentLength(_content.length());  
16.         encode(REQUEST_POST, os);  
17.         os << _content;  
18.     }  
19.     else if(_requestType == REQUEST_OPTIONS)  
20.     {  
21.         encode(REQUEST_OPTIONS, os);  
22.     }  
23.   
24.   
25.     return os.str();  
26. }  

header與body之間是兩個\r\n\。

 

 

1. void TC_HttpRequest::encode(int iRequestType, ostream &os)  
2. {  
3.     os << requestType2str(iRequestType) << " " << _httpURL.getRequest() << " HTTP/1.1\r\n";  
4.     os << genHeader();  
5.     os << "\r\n";  
6. }  

 

便利所有的header key，用\r\n進行換行分隔。

 

 

1. string TC_Http::genHeader() const  
2. {  
3.     ostringstream sHttpHeader;  
4.   
5.   
6.     for(http_header_type::const_iterator it = _headers.begin(); it != _headers.end(); ++it)  
7.     {  
8.         if(it->second != "")  
9.         {  
10.             sHttpHeader << it->first << ": " << it->second << "\r\n";  
11.         }  
12.     }  
13.   
14.   
15.     return sHttpHeader.str();  
16. }  

 

如下是一個HttpRequest的解析請求。通過TCP socket將構造的http request header發送至服務器http server端口。構建緩沖區循環接收返回數據，直到客戶端完整的response包接收完畢或者服務器異常關閉。

1. int TC_HttpRequest::doRequest(TC_HttpResponse &stHttpRsp, int iTimeout)  
2. {  
3.     //只支持短連接模式  
4.     setConnection("close");     
5.   
6.   
7.     string sSendBuffer = encode();  
8.   
9.   
10.     string sHost;  
11.     uint32_t iPort;  
12.   
13.   
14.     getHostPort(sHost, iPort);  
15.   
16.   
17.     TC_TCPClient tcpClient;  
18.     tcpClient.init(sHost, iPort, iTimeout);  
19.   
20.   
21.     int iRet = tcpClient.send(sSendBuffer.c_str(), sSendBuffer.length());  
22.     if(iRet != TC_ClientSocket::EM_SUCCESS)  
23.     {  
24.         return iRet;  
25.     }  
26.   
27.   
28.     stHttpRsp.reset();  
29.   
30.   
31.     string sBuffer;  
32.   
33.   
34.     char *sTmpBuffer = new char[10240];  
35.     size_t iRecvLen  = 10240;  
36.   
37.   
38.     while(true)  
39.     {  
40.         iRecvLen = 10240;  
41.   
42.   
43.         iRet = tcpClient.recv(sTmpBuffer, iRecvLen);  
44.   
45.   
46.         if(iRet == TC_ClientSocket::EM_SUCCESS)  
47.             sBuffer.append(sTmpBuffer, iRecvLen);  
48.   
49.   
50.         switch(iRet)  
51.         {  
52.         case TC_ClientSocket::EM_SUCCESS:  
53.             if(stHttpRsp.incrementDecode(sBuffer))  
54.             {  
55.                 delete []sTmpBuffer;  
56.                 return TC_ClientSocket::EM_SUCCESS;  
57.             }  
58.             continue;  
59.         case TC_ClientSocket::EM_CLOSE:  
60.             delete []sTmpBuffer;  
61.             stHttpRsp.incrementDecode(sBuffer);  
62.             return TC_ClientSocket::EM_SUCCESS;  
63.         default:  
64.             delete []sTmpBuffer;  
65.             return iRet;  
66.         }  
67.     }  
68.   
69.   
70.     assert(true);  
71.   
72.   
73.     return 0;  
74. }  

數據接收分為兩部分，第一部分是header，通過header頭的解讀，進一步接收與解析body content，如果解析返回false，表示http response并未接收完成，繼續接收。

1. case TC_ClientSocket::EM_SUCCESS:  
2.            if(stHttpRsp.incrementDecode(sBuffer))  
3.            {  
4.                delete []sTmpBuffer;  
5.                return TC_ClientSocket::EM_SUCCESS;  
6.            }  
7.            continue;  

當數據接收成功，將接收的buffer放入resp中進行解析：

1. bool TC_HttpResponse::incrementDecode(string &sBuffer)  
2. {  
3.     //解析頭部  
4.     if(_headLength == 0)  
5.     {  
6.         string::size_type pos = sBuffer.find("\r\n\r\n");  
7.   
8.   
9.         if(pos == string::npos)  
10.         {  
11.             return false;  
12.         }  
13.   
14.   
15.         parseResponseHeader(sBuffer.c_str());  
16.   
17.   
18.         if(_status == 204)  
19.         {  
20.             return false;  
21.         }  
22.   
23.   
24.         http_header_type::const_iterator it = _headers.find("Content-Length");  
25.         if(it != _headers.end())  
26.         {  
27.             _iTmpContentLength = getContentLength();  
28.         }  
29.         else  
30.         {  
31.             //沒有指明ContentLength, 接收到服務器關閉連接  
32.             _iTmpContentLength = -1;  
33.         }  
34.   
35.   
36.         _headLength = pos + 4;  
37.   
38.   
39.         sBuffer = sBuffer.substr(_headLength);  
40.   
41.   
42.         //重定向就認為成功了  
43.         if((_status == 301 || _status == 302) && !getHeader("Location").empty())  
44.         {  
45.             return true;  
46.         }  
47.   
48.   
49.         //是否是chunk編碼  
50.         _bIsChunked = (getHeader("Transfer-Encoding") == "chunked");  
51.   
52.   
53.         //刪除頭部里面  
54.         eraseHeader("Transfer-Encoding");  
55.     }  
56.   
57.   
58.     if(_bIsChunked)  
59.     {  
60.         while(true)  
61.         {  
62.             string::size_type pos   = sBuffer.find("\r\n");  
63.             if(pos == string::npos)  
64.                 return false;  
65.   
66.   
67.             //查找當前chunk的大小  
68.             string sChunkSize       = sBuffer.substr(0, pos);  
69.             int iChunkSize          = strtol(sChunkSize.c_str(), NULL, 16);  
70.   
71.   
72.             if(iChunkSize <= 0)     break;      //所有chunk都接收完畢  
73.   
74.   
75.             if(sBuffer.length() >= pos + 2 + (size_t)iChunkSize + 2)   //接收到一個完整的chunk了  
76.             {  
77.                 //獲取一個chunk的內容  
78.                 _content += sBuffer.substr(pos + 2, iChunkSize);  
79.   
80.   
81.                 //刪除一個chunk  
82.                 sBuffer   =  sBuffer.substr(pos + 2 + iChunkSize + 2);  
83.             }  
84.             else  
85.             {  
86.                 //沒有接收完整的chunk  
87.                 return false;  
88.             }  
89.   
90.   
91.             setContentLength(getContent().length());  
92.         }  
93.   
94.   
95.         sBuffer = "";  
96.   
97.   
98.         if(_iTmpContentLength == 0 || _iTmpContentLength == (size_t)-1)  
99.         {  
100.             setContentLength(getContent().length());  
101.         }  
102.   
103.   
104.         return true;  
105.     }  
106.     else  
107.     {  
108.         if(_iTmpContentLength == 0)  
109.         {  
110.             _content += sBuffer;  
111.             sBuffer   = "";  
112.   
113.   
114.             //自動填寫content-length  
115.             setContentLength(getContent().length());  
116.   
117.   
118.             return true;  
119.         }  
120.         else if(_iTmpContentLength == (size_t)-1)  
121.         {  
122.             _content += sBuffer;  
123.             sBuffer   = "";  
124.   
125.   
126.             //自動填寫content-length  
127.             setContentLength(getContent().length());  
128.   
129.   
130.             return false;  
131.         }  
132.         else  
133.         {  
134.             //短連接模式, 接收到長度大于頭部為止  
135.             _content += sBuffer;  
136.             sBuffer   = "";  
137.   
138.   
139.             size_t iNowLength = getContent().length();  
140.   
141.   
142.             //頭部的長度小于接收的內容, 還需要繼續增加解析后續的buffer  
143.             if(_iTmpContentLength > iNowLength)  
144.                 return false;  
145.   
146.   
147.             return true;  
148.         }  
149.     }  
150.   
151.   
152.     return true;  
153. }  

該解析if(_headLength == 0)判斷是否header已經開始接收，知道遇見

1. string::size_type pos = sBuffer.find("\r\n\r\n");  
2.   
3.   
4. if(pos == string::npos)  
5. {  
6.     return false;  
7. }  

則表示header接收完成，并解析完整的header,其中HTTP status 204HTTP狀態碼2XX 都表示成功。HTTP的204(no content)響應,表示執行成功,但沒有數據返回,瀏覽器不用刷新頁面,也不用導向新的頁面。

1.        parseResponseHeader(sBuffer.c_str());  
2.   
3.   
4.        if(_status == 204)  
5.        {  
6.            return false;  
7.        }  
8.   
9.   
10.   
11.   
12. void TC_HttpResponse::parseResponseHeader(const char* szBuffer)  
13. {  
14.     const char **ppChar = &szBuffer;  
15.   
16.   
17.     _headerLine = TC_Common::trim(getLine(ppChar));  
18.   
19.   
20.     string::size_type pos = _headerLine.find(' ');  
21.   
22.   
23.     if(pos != string::npos)  
24.     {  
25.     _version    = _headerLine.substr(0, pos);  
26.   
27.   
28.     string left = TC_Common::trim(_headerLine.substr(pos));  
29.   
30.   
31.     string::size_type pos1 = left.find(' ');  
32.   
33.   
34.     if(pos1 != string::npos)  
35.     {  
36.         _status  = TC_Common::strto<int>(left.substr(0, pos));  
37.   
38.   
39.         _about   = TC_Common::trim(left.substr(pos1 + 1));  
40.     }  
41.     else  
42.     {  
43.         _status  = TC_Common::strto<int>(left);  
44.   
45.   
46.         _about   = "";  
47.     }  
48.   
49.   
50.     parseHeader(*ppChar, _headers);  
51.     return;  
52.     }  
53.     else  
54.     {  
55.     _version = _headerLine;  
56.     _status  = 0;  
57.     _about   = "";  
58.     }  
59.   
60.   
61. //    throw TC_HttpResponse_Exception("[TC_HttpResponse_Exception::parseResponeHeader] http response format error : " + _headerLine);  
62. }  

      

接下來判斷http response的content-length，如果明確返回則body字段確定，如果沒有，則需要接收服務器直至關閉。


      

1. http_header_type::const_iterator it = _headers.find("Content-Length");         
2. if(it != _headers.end())  
3. {  
4.     _iTmpContentLength = getContentLength();  
5. }  
6. else  
7. {  
8.     //沒有指明ContentLength, 接收到服務器關閉連接  
9.     _iTmpContentLength = -1;  
10. }  
11.   
12.   
13. _headLength = pos + 4;  
14.   
15.   
16.  _headLength = pos + 4;  
17.   
18.   
19. sBuffer = sBuffer.substr(_headLength);  //把body提取出來  
20.   
21.   
22.   
23.   
24. //重定向就認為成功了  
25. if((_status == 301 || _status == 302) && !getHeader("Location").empty())  
26. {  
27.     return true;  
28. }  
29.   
30.   
31. //是否是chunk編碼  
32. _bIsChunked = (getHeader("Transfer-Encoding") == "chunked");  
33.   
34.   
35. //刪除頭部里面  
36. eraseHeader("Transfer-Encoding");  
37. if(it != _headers.end())  
38. {  
39.     _iTmpContentLength = getContentLength();  
40. }  
41. else  
42. {  
43.     //沒有指明ContentLength, 接收到服務器關閉連接  
44.     _iTmpContentLength = -1;  
45. }  
46.   
47.   
48. _headLength = pos + 4;  
49.   
50.   
51.  _headLength = pos + 4;  
52.   
53.   
54. sBuffer = sBuffer.substr(_headLength);  //把body提取出來  
55.   
56.   
57.   
58.   
59. //重定向就認為成功了  
60. if((_status == 301 || _status == 302) && !getHeader("Location").empty())  
61. {  
62.     return true;  
63. }  
64.   
65.   
66. //是否是chunk編碼  
67. _bIsChunked = (getHeader("Transfer-Encoding") == "chunked");  
68.   
69.   
70. //刪除頭部里面  
71. eraseHeader("Transfer-Encoding");  

接下來將開始循環接收數據，如果非chunk，分為三種情況0（沒有body，即可就可以停止接收），-1（一直接收，知道服務器關閉），確定長度（接收完成即可以停止）：

1. {  
2.         if(_iTmpContentLength == 0)  
3.         {  
4.             _content += sBuffer;   //將整體內容保存下來  
5.             sBuffer   = "";     //清空接收緩存  
6.   
7.   
8.             //自動填寫content-length  
9.             setContentLength(getContent().length());  
10.   
11.   
12.             return true;  
13.         }  
14.         else if(_iTmpContentLength == (size_t)-1)  
15.         {  
16.             _content += sBuffer;  
17.             sBuffer   = "";  
18.   
19.   
20.             //自動填寫content-length  
21.             setContentLength(getContent().length());  
22.   
23.   
24.             return false;  
25.         }  
26.     //有明確的content-length長度  
27.         else  
28.         {  
29.             //短連接模式, 接收到長度大于頭部為止  
30.             _content += sBuffer;  
31.             sBuffer   = "";  
32.   
33.   
34.             size_t iNowLength = getContent().length();  
35.   
36.   
37.             //頭部的長度小于接收的內容, 還需要繼續增加解析后續的buffer  
38.             if(_iTmpContentLength > iNowLength)  
39.                 return false;   //如果接收的字節大于content-length就可以停止了，否則繼續接收下去  
40.   
41.   
42.             return true;  
43.         }  
44. }  

如果是chunk分片，則更加復雜一些：

1. while(true)  
2. {  
3.     string::size_type pos   = sBuffer.find("\r\n");  
4.     if(pos == string::npos)  
5.         return false;  
6.   
7.   
8.     //查找當前chunk的大小  
9.     string sChunkSize       = sBuffer.substr(0, pos);  
10.     int iChunkSize          = strtol(sChunkSize.c_str(), NULL, 16);  
11.   
12.   
13.     if(iChunkSize <= 0)     break;      //所有chunk都接收完畢  
14.   
15.   
16.     if(sBuffer.length() >= pos + 2 + (size_t)iChunkSize + 2)   //接收到一個完整的chunk了  
17.     {  
18.         //獲取一個chunk的內容  
19.         _content += sBuffer.substr(pos + 2, iChunkSize);  
20.   
21.   
22.         //刪除一個chunk  
23.         sBuffer   =  sBuffer.substr(pos + 2 + iChunkSize + 2);  
24.     }  
25.     else  
26.     {  
27.         //沒有接收完整的chunk  
28.         return false;  
29.     }  
30.   
31.   
32.     setContentLength(getContent().length());  
33. }  
34.   
35.   
36. sBuffer = "";  
37.   
38.   
39. if(_iTmpContentLength == 0 || _iTmpContentLength == (size_t)-1)  
40. {  
41.     setContentLength(getContent().length());  
42. }  
43.   
44.   
45. return true;  

每一個chunk前兩個字段為chunk的zise，用16進制標識，如果chunk size為0，表示沒有chunk了，否則則接收完成一個chunk，如果當前chunk沒有完成，則繼續接收完成這個chunk后處理，
如果當前chunk完成了，則將這個chunk在buffer里面刪除，放到content內容中來。

RFID管理系統集成商 RFID中間件 條碼系統中間層 物聯網軟件集成