3

大家好，我是 asio 和 boost 的新手，我一直在尝试实现 TCP 服务器和客户端，以便我可以传输 std::vector - 但到目前为止我失败了。我发现 Asio 的 boost 文档缺乏（至少可以说）并且难以理解（英语不是我的主要语言）。

无论如何，我一直在查看 iostreams 示例，并且一直在尝试实现面向对象的解决方案 - 但我失败了。

我尝试实现的服务器应该能够接受来自多个客户端的连接（我该怎么做？）

服务器应该接收到 std::vector, /* Do something */ 然后将其返回给客户端，以便客户端可以告诉服务器接收到完整的数据。

*.h 文件

class TCP_Server : private boost::noncopyable
        {
            typedef boost::shared_ptr<TCP_Connection> tcp_conn_pointer;

            public :
                TCP_Server(ba::io_service &io_service, int port);
                virtual ~TCP_Server() {}
                virtual void Start_Accept();
            private:
                virtual void Handle_Accept(const boost::system::error_code& e);
            private :
                int                 m_port;
                ba::io_service&     m_io_service;               // IO Service
                bi::tcp::acceptor   m_acceptor;         // TCP Connections acceptor
                tcp_conn_pointer    m_new_tcp_connection;   // New connection pointer
        };

*.cpp 文件

TCP_Server::TCP_Server(boost::asio::io_service &io_service, int port) : 
            m_io_service(io_service), 
            m_acceptor(io_service, bi::tcp::endpoint(bi::tcp::v4(), port)), 
            m_new_tcp_connection(TCP_Connection::Create(io_service))
        {
            m_port = port;
            Start_Accept();
        }

        void TCP_Server::Start_Accept()
        {
            std::cout << "[TCP_Server][Start_Accept] => Listening on port : " << m_port << std::endl;
            //m_acceptor.async_accept(m_new_tcp_connection->Socket(),
            //                        boost::bind(&TCP_Server::Handle_Accept, this,
            //                                    ba::placeholders::error));


                m_acceptor.async_accept(*m_stream.rdbuf(),
                boost::bind(&TCP_Server::Handle_Accept, 
                this,
                ba::placeholders::error));
        }

        void TCP_Server::Handle_Accept(const boost::system::error_code &e)
        {
            if(!e)
            {

                /*boost::thread T(boost::bind(&TCP_Connection::Run, m_new_tcp_connection));
                std::cout << "[TCP_Server][Handle_Accept] => Accepting incoming connection. Launching Thread " << std::endl;
                m_new_tcp_connection = TCP_Connection::Create(m_io_service);
                m_acceptor.async_accept(m_new_tcp_connection->Socket(), 
                                        boost::bind(&TCP_Server::Handle_Accept, 
                                                    this, 
                                                    ba::placeholders::error));*/
                m_stream << "Server Response..." << std::endl;
            }
        }

客户应该怎么看？如何在两个应用程序“通话”时保持连接？

4

3 回答 3

3

AFAIK ASIO iostreams 仅用于同步 I/O。但是你的例子给了我一个提示，你想使用异步 I/O。这是一个使用异步 I/O 读取请求的服务器的小示例，该请求由整数数组组成，请求中的整数前面是 4 字节计数。所以实际上我将整数向量序列化为 count(4 bytes) int int ... 等如果读取 ints 向量成功，服务器将写入 4 字节响应代码（=1）然后发出读取来自客户端的新请求。话不多说，代码如下。

#include <iostream>
#include <vector>
#include <boost/bind.hpp>
#include <boost/function.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/thread.hpp>
#include <boost/asio.hpp>

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

class Connection
{
public:
    Connection(tcp::acceptor& acceptor)
        : acceptor_(acceptor), socket_(acceptor.get_io_service(), tcp::v4())
    {
    }
    void start()
    {
        acceptor_.get_io_service().post(boost::bind(&Connection::start_accept, this));
    }
private:
    void start_accept()
    {
        acceptor_.async_accept(socket_,boost::bind(&Connection::handle_accept, this, 
            placeholders::error));
    }
    void handle_accept(const boost::system::error_code& err)
    {
        if (err)
        {
            //Failed to accept the incoming connection.
            disconnect();
        }
        else
        {
            count_ = 0;
            async_read(socket_, buffer(&count_, sizeof(count_)),
                boost::bind(&Connection::handle_read_count,
                this, placeholders::error, placeholders::bytes_transferred));
        }
    }
    void handle_read_count(const boost::system::error_code& err, std::size_t bytes_transferred)
    {
        if (err || (bytes_transferred != sizeof(count_))
        {
            //Failed to read the element count.
            disconnect();
        }
        else
        {
            elements_.assign(count_, 0);
            async_read(socket_, buffer(elements_), 
                boost::bind(&Connection::handle_read_elements, this,
                placeholders::error, placeholders::bytes_transferred));
        }
    }

    void handle_read_elements(const boost::system::error_code& err, std::size_t bytes_transferred)
    {
        if (err || (bytes_transferred != count_ * sizeof(int)))
        {
            //Failed to read the request elements.
            disconnect();
        }
        else
        {
            response_ = 1;
            async_write(socket_, buffer(&response_, sizeof(response_)),
                boost::bind(&Connection::handle_write_response, this,
                placeholders::error, placeholders::bytes_transferred));
        }
    }
    void handle_write_response(const boost::system::error_code& err, std::size_t bytes_transferred)
    {
        if (err)
            disconnect();
        else
        {
            //Start a fresh read 
            count_ = 0;
            async_read(socket_, buffer(&count_, sizeof(count_)),
                boost::bind(&Connection::handle_read_count,
                this, placeholders::error, placeholders::bytes_transferred));
        }
    }
    void disconnect()
    {
        socket_.shutdown(tcp::socket::shutdown_both);
        socket_.close();
        socket_.open(tcp::v4());
        start_accept();
    }
    tcp::acceptor& acceptor_;
    tcp::socket socket_;
    std::vector<int> elements_;
    long count_;
    long response_;
};

class Server : private boost::noncopyable
{
public:
    Server(unsigned short port, unsigned short thread_pool_size, unsigned short conn_pool_size)
        : acceptor_(io_service_, tcp::endpoint(tcp::v4(), port), true)
    {
        unsigned short i = 0;
        for (i = 0; i < conn_pool_size; ++i)
        {
            ConnectionPtr conn(new Connection(acceptor_));
            conn->start();
            conn_pool_.push_back(conn);
        }

        // Start the pool of threads to run all of the io_services.
        for (i = 0; i < thread_pool_size; ++i)
        {
            thread_pool_.create_thread(boost::bind(&io_service::run, &io_service_));
        }
    }   
    ~Server()
    {
        io_service_.stop();
        thread_pool_.join_all();
    }

private:
    io_service io_service_;
    tcp::acceptor acceptor_;
    typedef boost::shared_ptr<Connection> ConnectionPtr;
    std::vector<ConnectionPtr> conn_pool_;
    boost::thread_group thread_pool_;
};

boost::function0<void> console_ctrl_function;

BOOL WINAPI console_ctrl_handler(DWORD ctrl_type)
{
  switch (ctrl_type)
  {
  case CTRL_C_EVENT:
  case CTRL_BREAK_EVENT:
  case CTRL_CLOSE_EVENT:
  case CTRL_SHUTDOWN_EVENT:
    console_ctrl_function();
    return TRUE;
  default:
    return FALSE;
  }
}

void stop_server(Server* pServer)
{
    delete pServer;
    pServer = NULL;
}

int main()
{
    Server *pServer = new Server(10255, 4, 20);
    console_ctrl_function = boost::bind(stop_server, pServer);
    SetConsoleCtrlHandler(console_ctrl_handler, TRUE);
    while(true)
    {
        Sleep(10000);
    }
}
于 2009-07-13T14:28:58.537 回答
1

我相信您发布的代码有点不完整/不正确。尽管如此，这里有一些指导..

1）您的 async_accept() 调用似乎是错误的。它应该是这样的，

m_acceptor.async_accept(m_new_tcp_connection->socket(),...)

2）注意，Handle_Accept()函数会在socket被接受后被调用。换句话说，当控制到达 Handle_Accept() 时，您只需写入套接字即可。就像是

void TCP_Server::Handle_Accept(const system::error_code& error)
{
  if(!error)
  {
    //send data to the client
    string message = "hello there!\n";

    //Write data to the socket and then call the handler AFTER that
    //Note, you will need to define a Handle_Write() function in your TCP_Connection class.
async_write(m_new_tcp_connection->socket(),buffer(message),bind(&TCP_Connection::Handle_Write, this,placeholders::error,placeholders::bytes_transferred)); 

    //accept the next connection
    Start_Accept();
  }
}

3）至于客户端，你应该看看这里： http: //www.boost.org/doc/libs/1_39_0/doc/html/boost_asio/tutorial/tutdaytime1.html

于 2009-06-29T23:32:27.740 回答
1

如果两端的通信是用 C++ 实现的，则可以使用 Boost Serialization 库将向量 sezilize 为字节并将它们传输到另一台机器。在另一端，您将使用 boost 序列化库来反序列化对象。我看到至少有两种方法这样做。

Boost Serialization 的优点：这种方法也适用于在 32 位和 64 位系统之间传输对象。

以下是链接：
代码项目文章
提升邮件列表想法

问候，
欧文斯

于 2009-07-11T11:45:28.817 回答