Question

我的代码如下：

boost::asio::streambuf b1;

boost::asio::async_read_until(upstream_socket_, b1, '@',
           boost::bind(&bridge::handle_upstream_read, shared_from_this(),
           boost::asio::placeholders::error,
           boost::asio::placeholders::bytes_transferred));


void handle_upstream1_read(const boost::system::error_code& error,
                            const size_t& bytes_transferred)
  {
     if (!error)
     {

       async_write(downstream_socket_,
          b2,
          boost::bind(&bridge::handle_downstream_write,
          shared_from_this(),
          boost::asio::placeholders::error));  
     }
     else
        close();
  }

根据async_read_until的文档http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference/async_read_until/overload1.html，在成功执行async_read_until操作后，streambuf可能包含分隔符之外的其他数据。应用程序通常会将该数据留在streambuf中，以便后续的async_read_until操作进行检查。

我知道streambuf可能包含除分隔符之外的其他数据，但在我的情况下，它是否会将这些附加数据（char'@'之外的数据）写入async_write操作中的upstream_socket_？或者，async_write函数是否足够聪明，直到下次调用handle_upstream1_read函数时才会写入这些附加数据？

根据文档中的方法，streambuf中的数据首先存储在istream中（std :: istream response_stream（＆amp; streambuf）;）然后使用std :: getline（）函数将其放入一个字符串中。

我是否真的需要首先在istream中存储streambuf然后将其转换为字符串然后将其转换回char arrary（以便我可以将char数组发送到downstream_socket_）而不是仅使用async_write来编写对于upstream_socket_？

的数据（最多但不包括分隔符'@'）

我更喜欢第二种方法，因此我不需要对数据进行多次转换。但是，当我尝试第二种方法时，似乎出现了问题。

我的理想情况是：

upstream_socket_使用async_read_until
xxxx @被写入downstream_socket _
upstream_socket_使用async_read_until
yyyyzzzz @被写入downstream_socket _

似乎async_write操作仍然将数据超出分隔符写入downstream_socket_。（但我不是100％肯定这个）

如果有人能提供一点帮助，我感激不尽！

Answer 1

当所有async_write()的数据（其输入序列）已写入WriteStream（套接字）时，认为正在使用的streambuf重载已完成。它相当于调用：

boost::asio::async_write(stream, streambuf,
    boost::asio::transfer_all(), handler);

通过使用async_write()完成条件调用boost::asio::transfer_exactly重载，可以限制从streambuf对象写入和使用的字节数：

boost::asio::async_write(stream, streambuf, 
    boost::asio::transfer_exactly(n), handler);

或者，可以直接从streambuf的输入序列中写入。但是，需要明确使用streambuf。

boost::asio::async_write(stream,
    boost::asio::buffer(streambuf.data(), n), handler);
// Within the completion handler...
streambuf.consume(n);

请注意，当async_read_until()操作完成时，完成处理程序的bytes_transferred参数包含streambuf输入序列中包含分隔符的字节数，如果出现错误，则包含0发生。

以下是使用这两种方法的完整示例demonstrating。该示例使用同步操作编写，以简化流程：

#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>

// This example is not interested in the handlers, so provide a noop function
// that will be passed to bind to meet the handler concept requirements.
void noop() {}

/// @brief Helper function that extracts a string from a streambuf.
std::string make_string(
  boost::asio::streambuf& streambuf,
  std::size_t n)
{
  return std::string(
      boost::asio::buffers_begin(streambuf.data()),
      boost::asio::buffers_begin(streambuf.data()) + n);
}

int main()
{
  using boost::asio::ip::tcp;
  boost::asio::io_service io_service;

  // Create all I/O objects.
  tcp::acceptor acceptor(io_service, tcp::endpoint(tcp::v4(), 0));
  tcp::socket server_socket(io_service);
  tcp::socket client_socket(io_service);

  // Connect client and server sockets.
  acceptor.async_accept(server_socket, boost::bind(&noop));
  client_socket.async_connect(acceptor.local_endpoint(), boost::bind(&noop));
  io_service.run();

  // Mockup write_buffer as if it read "xxxx@yyyy" with read_until()
  // using '@' as a delimiter.
  boost::asio::streambuf write_buffer;
  std::ostream output(&write_buffer);
  output << "xxxx@yyyy";
  assert(write_buffer.size() == 9);
  auto bytes_transferred = 5;

  // Write to server.
  boost::asio::write(server_socket, write_buffer,
      boost::asio::transfer_exactly(bytes_transferred));
   // Verify write operation consumed part of the input sequence.
  assert(write_buffer.size() == 4);

  // Read from client.
  boost::asio::streambuf read_buffer;
  bytes_transferred = boost::asio::read(
      client_socket, read_buffer.prepare(bytes_transferred));
  read_buffer.commit(bytes_transferred);

  // Copy from the read buffers input sequence.
  std::cout << "Read: " << 
               make_string(read_buffer, bytes_transferred) << std::endl;
  read_buffer.consume(bytes_transferred);

  // Mockup write_buffer as if it read "zzzz@kkkk" with read_until()
  // using '@' as a delimiter.
  output << "zzzz@kkkk";
  assert(write_buffer.size() == 13); 
  bytes_transferred = 9; // yyyyzzzz@

  // Write to server.
  boost::asio::write(server_socket, buffer(write_buffer.data(),
      bytes_transferred));
  // Verify write operation did not consume the input sequence.
  assert(write_buffer.size() == 13);
  write_buffer.consume(bytes_transferred);

  // Read from client.
  bytes_transferred = boost::asio::read(
      client_socket, read_buffer.prepare(bytes_transferred));
  read_buffer.commit(bytes_transferred);

  // Copy from the read buffers input sequence.
  std::cout << "Read: " << 
               make_string(read_buffer, bytes_transferred) << std::endl;
  read_buffer.consume(bytes_transferred);
}

输出：

Read: xxxx@
Read: yyyyzzzz@

其他几点说明：

streambuf拥有内存，std::istream和std::ostream使用内存。当需要提取格式化输入或插入格式化输出时，使用流可能是个好主意。例如，当希望将字符串"123"读为整数123时。
可以直接访问streambuf的输入序列并迭代它。在上面的示例中，我使用boost::asio::buffers_begin()通过迭代streambuf的输入序列来帮助构造std::string。
```
std::string(
    boost::asio::buffers_begin(streambuf.data()),
    boost::asio::buffers_begin(streambuf.data()) + n);
```
正在使用基于流的传输协议，因此将传入数据作为流处理。请注意，即使中间服务器重新构造消息并在一次写入操作中发送"xxxx@"并在后续写入操作中发送"yyyyzzzz@"，下游也可能在单次读取操作中读取"xxxx@yyyy"。

有关在async_read_until之后立即使用async_write的问题

1 个答案: