2012-01-31 216 views
2

我想用boost進行HTTP客戶端編程。如果我設法執行以下操作,則可以使用異步模型:等待異步請求完成

  • 第一步,將請求發送到服務器。
  • 第二步,讀取已經到達的響應或等待,直到它到達。

這是一個類似於我有什麼產品類:

class HTTPClient { 
public: 
    void sendTheRequest(...) { 
     // Send the HTTP request 
    } 

    std::string getTheResponse(...) { 
     // return the already (asynchronously) received response, or wait for it 
     // in this function 
    } 
} 

有人能指出如何實現這一點?我擔心我缺乏提升的知識。

編輯澄清: sendTheRequest方法將在一個點上被調用。也許直接在getTheResponse之後會被調用,但是這也可能發生在一些(毫秒)之後。這就是爲什麼我想異步發送請求,但同時也需要等待。

+0

並且您還沒有在boost :: asio中找到任何可以幫助您的例子嗎? http://www.boost.org/doc/libs/1_48_0/doc/html/boost_asio/examples.html – stefanB 2012-01-31 21:42:41

回答

4

Mabye有點遲,但我認爲這應該做到這一點。 std::future::get返回send_request_function的值,如果尚未返回,則等待並在完成後返回。

class HTTPClient { 
public: 
    void sendTheRequest(...) { 
     // Send the HTTP request 
     f = std::async(std::launch::async, send_request_function, args ...); 

    } 

    std::string getTheResponse(...) { 
     // return the already (asynchronously) received response, or wait for it 
     // in this function 
     return f.get(); 

    } 
private: 
    std::future<std::string> f; 

} 
+0

太棒了!它是我正在尋找的! – Erik 2012-03-09 09:03:12

+0

@Erik也許你應該在構造函數中產生已經存在的任務,以確保getTheResponse不會在沒有先產生任務的情況下被調用,這將拋出異常。 – inf 2012-03-09 11:12:27

+0

如何在不使用C++ 11的情況下做到這一點? – rank1 2013-06-14 12:01:35

0

爲什麼你不使用這個示例異步HTTP客戶端與提升?

// 
// async_client.cpp 
// ~~~~~~~~~~~~~~~~ 
// 
// Copyright (c) 2003-2011 Christopher M. Kohlhoff (chris at kohlhoff dot com) 
// 
// Distributed under the Boost Software License, Version 1.0. (See accompanying 
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 
// 

#include <iostream> 
#include <istream> 
#include <ostream> 
#include <string> 
#include <boost/asio.hpp> 
#include <boost/bind.hpp> 

using boost::asio::ip::tcp; 

class client 
{ 
public: 
    client(boost::asio::io_service& io_service, 
     const std::string& server, const std::string& path) 
    : resolver_(io_service), 
     socket_(io_service) 
    { 
    // Form the request. We specify the "Connection: close" header so that the 
    // server will close the socket after transmitting the response. This will 
    // allow us to treat all data up until the EOF as the content. 
    std::ostream request_stream(&request_); 
    request_stream << "GET " << path << " HTTP/1.0\r\n"; 
    request_stream << "Host: " << server << "\r\n"; 
    request_stream << "Accept: */*\r\n"; 
    request_stream << "Connection: close\r\n\r\n"; 

    // Start an asynchronous resolve to translate the server and service names 
    // into a list of endpoints. 
    tcp::resolver::query query(server, "http"); 
    resolver_.async_resolve(query, 
     boost::bind(&client::handle_resolve, this, 
      boost::asio::placeholders::error, 
      boost::asio::placeholders::iterator)); 
    } 

private: 
    void handle_resolve(const boost::system::error_code& err, 
     tcp::resolver::iterator endpoint_iterator) 
    { 
    if (!err) 
    { 
     // Attempt a connection to each endpoint in the list until we 
     // successfully establish a connection. 
     boost::asio::async_connect(socket_, endpoint_iterator, 
      boost::bind(&client::handle_connect, this, 
      boost::asio::placeholders::error)); 
    } 
    else 
    { 
     std::cout << "Error: " << err.message() << "\n"; 
    } 
    } 

    void handle_connect(const boost::system::error_code& err) 
    { 
    if (!err) 
    { 
     // The connection was successful. Send the request. 
     boost::asio::async_write(socket_, request_, 
      boost::bind(&client::handle_write_request, this, 
      boost::asio::placeholders::error)); 
    } 
    else 
    { 
     std::cout << "Error: " << err.message() << "\n"; 
    } 
    } 

    void handle_write_request(const boost::system::error_code& err) 
    { 
    if (!err) 
    { 
     // Read the response status line. The response_ streambuf will 
     // automatically grow to accommodate the entire line. The growth may be 
     // limited by passing a maximum size to the streambuf constructor. 
     boost::asio::async_read_until(socket_, response_, "\r\n", 
      boost::bind(&client::handle_read_status_line, this, 
      boost::asio::placeholders::error)); 
    } 
    else 
    { 
     std::cout << "Error: " << err.message() << "\n"; 
    } 
    } 

    void handle_read_status_line(const boost::system::error_code& err) 
    { 
    if (!err) 
    { 
     // Check that response is OK. 
     std::istream response_stream(&response_); 
     std::string http_version; 
     response_stream >> http_version; 
     unsigned int status_code; 
     response_stream >> status_code; 
     std::string status_message; 
     std::getline(response_stream, status_message); 
     if (!response_stream || http_version.substr(0, 5) != "HTTP/") 
     { 
     std::cout << "Invalid response\n"; 
     return; 
     } 
     if (status_code != 200) 
     { 
     std::cout << "Response returned with status code "; 
     std::cout << status_code << "\n"; 
     return; 
     } 

     // Read the response headers, which are terminated by a blank line. 
     boost::asio::async_read_until(socket_, response_, "\r\n\r\n", 
      boost::bind(&client::handle_read_headers, this, 
      boost::asio::placeholders::error)); 
    } 
    else 
    { 
     std::cout << "Error: " << err << "\n"; 
    } 
    } 

    void handle_read_headers(const boost::system::error_code& err) 
    { 
    if (!err) 
    { 
     // Process the response headers. 
     std::istream response_stream(&response_); 
     std::string header; 
     while (std::getline(response_stream, header) && header != "\r") 
     std::cout << header << "\n"; 
     std::cout << "\n"; 

     // Write whatever content we already have to output. 
     if (response_.size() > 0) 
     std::cout << &response_; 

     // Start reading remaining data until EOF. 
     boost::asio::async_read(socket_, response_, 
      boost::asio::transfer_at_least(1), 
      boost::bind(&client::handle_read_content, this, 
      boost::asio::placeholders::error)); 
    } 
    else 
    { 
     std::cout << "Error: " << err << "\n"; 
    } 
    } 

    void handle_read_content(const boost::system::error_code& err) 
    { 
    if (!err) 
    { 
     // Write all of the data that has been read so far. 
     std::cout << &response_; 

     // Continue reading remaining data until EOF. 
     boost::asio::async_read(socket_, response_, 
      boost::asio::transfer_at_least(1), 
      boost::bind(&client::handle_read_content, this, 
      boost::asio::placeholders::error)); 
    } 
    else if (err != boost::asio::error::eof) 
    { 
     std::cout << "Error: " << err << "\n"; 
    } 
    } 

    tcp::resolver resolver_; 
    tcp::socket socket_; 
    boost::asio::streambuf request_; 
    boost::asio::streambuf response_; 
}; 

int main(int argc, char* argv[]) 
{ 
    try 
    { 
    if (argc != 3) 
    { 
     std::cout << "Usage: async_client <server> <path>\n"; 
     std::cout << "Example:\n"; 
     std::cout << " async_client www.boost.org /LICENSE_1_0.txt\n"; 
     return 1; 
    } 

    boost::asio::io_service io_service; 
    client c(io_service, argv[1], argv[2]); 
    io_service.run(); 
    } 
    catch (std::exception& e) 
    { 
    std::cout << "Exception: " << e.what() << "\n"; 
    } 

    return 0; 
} 
+0

謝謝,我也發現了這一點。但是,如何等待請求完成? – Erik 2012-01-31 21:44:08

+0

所以你想同步或異步處理?我有點困惑。您發送請求並等待同一線程中的答案? – Damian 2012-01-31 21:50:13

+0

對不起,我感到困惑。如果你看看我的示例代碼,它可能會變得更清晰。 sendTheRequest方法將在某個點被調用。可能會在調用getTheResponse之後直接調用,但這也可能會在幾秒(毫秒)後發生。這就是爲什麼我想異步發送請求,但同時也需要等待。 – Erik 2012-01-31 21:55:45