http://www.gamedev.net/blog/950/entry-2249317-a-guide-to-getting-
started-with-boostasio?pg=9
8. Networking basics: binary protocol sending and receiving (TCP)
现在我们了解了boost::asio库和一些简单的tcp网络知识。现在进行一些简单的网路底层封装.通过使用这些分装。我们能重复使用并且将
注意力集中在程序逻辑而不是一再编写网络通讯代码。
重要注意事项:代码完全是出于教育目的。不要在商业系统中使用。
另外 使用这个网络封装代码的开销是需要考虑的。比如说，大量的vector与list的分配。bind与shared_ptr指针的开销。这也是这个代码
仅用来作为教育用途的原因。
有多重类型的函数用来发送和接收。我们基于协议选择不同的类型。
我们的例子中使用async_write and async_read_some.
使用async_write的原因是函数写入所有的数据，而无需担心部分发送的问题。同样的，我们使用async_read_some作为通用函数去读取数
据因为我们没有特定的协议用来接收。
现在我们学习一个完整的使用IO函数的例子。我们扩展7-C的例子。
#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/cstdint.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <iostream>
#include <string>
boost::mutex global_stream_lock;
void WorkerThread( boost::shared_ptr< boost::asio::io_service > io_service )
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Thread Start" << std::endl;
global_stream_lock.unlock();
while( true )
{
try
{
boost::system::error_code ec;
io_service->run( ec );
if( ec )
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Error: " << ec << std::endl;
global_stream_lock.unlock();
}
break;
}
catch( std::exception & ex )
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Exception: " << ex.what() << std::endl;
global_stream_lock.unlock();
}
}
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Thread Finish" << std::endl;
global_stream_lock.unlock();
}
struct ClientContext : public boost::enable_shared_from_this< ClientContext >
{
boost::asio::ip::tcp::socket m_socket;
std::vector< boost::uint8_t > m_recv_buffer;
size_t m_recv_buffer_index;
std::list< std::vector< boost::uint8_t > > m_send_buffer;
ClientContext( boost::asio::io_service & io_service )
: m_socket( io_service ), m_recv_buffer_index( 0 )
{
m_recv_buffer.resize( 4096 );
}
~ClientContext()
{
}
void Close()
{
boost::system::error_code ec;
m_socket.shutdown( boost::asio::ip::tcp::socket::shutdown_both, ec );
m_socket.close( ec );
}
void OnSend( const boost::system::error_code & ec, std::list< std::vector< boost::uint8_t > >::iterator itr )
{
if( ec )
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Error: " << ec << std::endl;
global_stream_lock.unlock();
Close();
}
else
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Sent " << (*itr).size() << " bytes." << std::endl;
global_stream_lock.unlock();
}
m_send_buffer.erase( itr );
// Start the next pending send
if( !m_send_buffer.empty() )
{
boost::asio::async_write(
m_socket,
boost::asio::buffer( m_send_buffer.front() ),
boost::bind(
&ClientContext::OnSend,
shared_from_this(),
boost::asio::placeholders::error,
m_send_buffer.begin()
)
);
}
}
void Send( const void * buffer, size_t length )
{
bool can_send_now = false;
std::vector< boost::uint8_t > output;
std::copy( (const boost::uint8_t *)buffer, (const boost::uint8_t *)buffer + length, std::back_inserter(
output ) );
// Store if this is the only current send or not
can_send_now = m_send_buffer.empty();
// Save the buffer to be sent
m_send_buffer.push_back( output );
// Only send if there are no more pending buffers waiting!
if( can_send_now )
{
// Start the next pending send
boost::asio::async_write(
m_socket,
boost::asio::buffer( m_send_buffer.front() ),
boost::bind(
&ClientContext::OnSend,
shared_from_this(),
boost::asio::placeholders::error,
m_send_buffer.begin()
)
);
}
}
void OnRecv( const boost::system::error_code & ec, size_t bytes_transferred )
{
if( ec )
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Error: " << ec << std::endl;
global_stream_lock.unlock();
Close();
}
else
{
// Increase how many bytes we have saved up
m_recv_buffer_index += bytes_transferred;
// Debug information
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Recv " << bytes_transferred << " bytes." << std::endl;
global_stream_lock.unlock();
// Dump all the data
global_stream_lock.lock();
for( size_t x = 0; x < m_recv_buffer_index; ++x )
{
std::cout << std::hex << std::setfill( '0' ) <<
std::setw( 2 ) << (int)m_recv_buffer[ x ] << " ";
if( ( x + 1 ) % 16 == 0 )
{
std::cout << std::endl;
}
}
std::cout << std::endl << std::dec;
global_stream_lock.unlock();
// Discard all the data (virtually, not physically!)
m_recv_buffer_index = 0;
// Start the next recv cycle
Recv();
}
}
void Recv()
{
m_socket.async_read_some(
boost::asio::buffer(
&m_recv_buffer[ m_recv_buffer_index ],
m_recv_buffer.size() - m_recv_buffer_index ),
boost::bind( &ClientContext::OnRecv, shared_from_this(), _1, _2 )
);
}
};
void OnAccept( const boost::system::error_code & ec, boost::shared_ptr< ClientContext > client )
{
if( ec )
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Error: " << ec << std::endl;
global_stream_lock.unlock();
}
else
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Accepted!" << std::endl;
global_stream_lock.unlock();
// 2 bytes message size, followed by the message
client->Send( "\x02\x00Hi", 6 );
client->Recv();
}
}
int main( int argc, char * argv[] )
{
boost::shared_ptr< boost::asio::io_service > io_service(
new boost::asio::io_service
);
boost::shared_ptr< boost::asio::io_service::work > work(
new boost::asio::io_service::work( *io_service )
);
boost::shared_ptr< boost::asio::io_service::strand > strand(
new boost::asio::io_service::strand( *io_service )
);
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Press [return] to exit." << std::endl;
global_stream_lock.unlock();
// 1 worker thread so we do not have to deal with thread safety issues
boost::thread_group worker_threads;
for( int x = 0; x < 1; ++x )
{
worker_threads.create_thread( boost::bind( &WorkerThread, io_service ) );
}
boost::shared_ptr< boost::asio::ip::tcp::acceptor > acceptor(
new boost::asio::ip::tcp::acceptor( *io_service )
);
boost::shared_ptr< ClientContext > client(
new ClientContext( *io_service )
);
try
{
boost::asio::ip::tcp::resolver resolver( *io_service );
boost::asio::ip::tcp::resolver::query query(
"127.0.0.1",
boost::lexical_cast< std::string >( 7777 )
);
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve( query );
acceptor->open( endpoint.protocol() );
acceptor->set_option( boost::asio::ip::tcp::acceptor::reuse_address( false ) );
acceptor->bind( endpoint );
acceptor->listen( boost::asio::socket_base::max_connections );
acceptor->async_accept( client->m_socket, boost::bind( OnAccept, _1, client ) );
global_stream_lock.lock();
std::cout << "Listening on: " << endpoint << std::endl;
global_stream_lock.unlock();
}
catch( std::exception & ex )
{
global_stream_lock.lock();
std::cout << "[" << boost::this_thread::get_id()
<< "] Exception: " << ex.what() << std::endl;
global_stream_lock.unlock();
}
std::cin.get();
boost::system::error_code ec;
acceptor->close( ec );
io_service->stop();
worker_threads.join_all();
return 0;
}
这个例子中，我们添加了ClientContext 类。它用来存储所有传入连接的上下文的具体结构。类封装了必须的io接收发送的函数。例子中
，服务器将发送一个具体的信息给传入连接。我们没配置一个具体的客户端去测试，仅仅使用简单的telnet即可。任意数据发送到服务器
将被输出到命令行。
同上一个例子不同的是，每个连接都需要自己的上下文。上下文应包含socket 发送接收缓存以及其他用户数据。另外，例子不是线程安装
的，所以我们限制在一个线程运行。我们将稍后讨论这个问题。现在，对于socket的读写将选择正确的api函数以避免发生问题.
为了正确的使用，我们必须确认上下文和缓存在函数的生存的整个期间都是有效的。这个例子中，我们使用一个vector list来发送，使用一个vector来接收缓存。根据我们实现的协议，我们可能需要做一些小小的改动。比如说，如果我们想处理流中的包。这种情况下，我们将希望使用async_read读取头结构然后使用async_read读取具体尺寸的数据。
在大型程序中，一次只处理一个包的缺点就是效率低下。假设我们有1003字节信息在流中。我们将执行读取包这个逻辑100次。而我们使用async_read_some，效率会更高。
1600
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
