Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

使用boost 写一个tcp 客户端类 ,类使用异步通信并运行于独立线程,能够根据包头包场解包,同时支持断线重连。

  1. User

    使用boost 写一个tcp 客户端类 ,类使用异步通信并运行于独立线程,能够根据包头包场解包,同时支持断线重连。

  2. Assistant

    以下是一个使用boost库实现的TCP客户端类,可以处理异步通信,独立线程,根据包头包长解包以及断线重连:

    #pragma once
    #include <boost/asio.hpp>
    #include <boost/bind.hpp>
    #include <boost/thread.hpp>
    #include <boost/shared_ptr.hpp>
    #include <boost/enable_shared_from_this.hpp>
    #include <iostream>
    #include <vector>
    
    class TcpClient
        : public boost::enable_shared_from_this<TcpClient>
    {
    public:
        typedef boost::shared_ptr<TcpClient> pointer;
    
        TcpClient(boost::asio::io_service& io_service,
                  const std::string& server_ip,
                  uint16_t port_num)
            : io_service_(io_service)
            , socket_(io_service)
            , server_ip_(server_ip)
            , port_num_(port_num)
            , timer_(io_service)
            , reconnect_(true)
        {
        }
    
        virtual ~TcpClient()
        {
            Close();
        }
    
        void Connect()
        {
            boost::asio::ip::tcp::endpoint endpoint(
                boost::asio::ip::address::from_string(server_ip_),
                port_num_);
    
            socket_.async_connect(
                endpoint,
                boost::bind(&TcpClient::HandleConnect,
                shared_from_this(),
                boost::asio::placeholders::error));
        }
    
        void AsyncRead()
        {
            boost::asio::async_read(
                socket_,
                read_buffer_,
                boost::asio::transfer_exactly(kPacketHeaderSize),
                boost::bind(&TcpClient::HandleReadHeader,
                shared_from_this(),
                boost::asio::placeholders::error,
                boost::asio::placeholders::bytes_transferred));
        }
    
        void AsyncWrite(const char* data, std::size_t length)
        {
            boost::asio::async_write(
                socket_,
                boost::asio::buffer(data, length),
                boost::bind(&TcpClient::HandleWrite,
                shared_from_this(),
                boost::asio::placeholders::error,
                boost::asio::placeholders::bytes_transferred));
        }
    
        void Close()
        {
            reconnect_ = false;
            socket_.close();
        }
    
        void SetPacketHandler(std::function<void(const char*, std::size_t)> handler)
        {
            packet_handler_ = handler;
        }
    
    private:
        void HandleConnect(const boost::system::error_code& error)
        {
            if (!error)
            {
                std::cout << "Connected to " << server_ip_ << ":" << port_num_ << std::endl;
    
                AsyncRead();
            }
            else
            {
                std::cerr << "Connect error: " << error.message() << std::endl;
    
                if (reconnect_)
                {
                    timer_.expires_from_now(boost::posix_time::seconds(kReconnectInterval));
                    timer_.async_wait(
                        boost::bind(&TcpClient::HandleTimer,
                        shared_from_this(),
                        boost::asio::placeholders::error));
                }
            }
        }
    
        void HandleReadHeader(const boost::system::error_code& error,
                              std::size_t bytes_transferred)
        {
            if (!error)
            {
                uint32_t packet_size = ParsePacketHeader(read_buffer_.data());
    
                boost::asio::async_read(
                    socket_,
                    read_buffer_,
                    boost::asio::transfer_exactly(packet_size),
                    boost::bind(&TcpClient::HandleReadBody,
                    shared_from_this(),
                    boost::asio::placeholders::error,
                    boost::asio::placeholders::bytes_transferred));
            }
            else
            {
                std::cerr << "Read header error: " << error.message() << std::endl;
    
                if (reconnect_)
                {
                    timer_.expires_from_now(boost::posix_time::seconds(kReconnectInterval));
                    timer_.async_wait(
                        boost::bind(&TcpClient::HandleTimer,
                        shared_from_this(),
                        boost::asio::placeholders::error));
                }
            }
        }
    
        void HandleReadBody(const boost::system::error_code& error,
                            std::size_t bytes_transferred)
        {
            if (!error)
            {
                std::vector<char> packet_data(
                    boost::asio::buffers_begin(read_buffer_.data()),
                    boost::asio::buffers_begin(read_buffer_.data()) + bytes_transferred);
    
                read_buffer_.consume(bytes_transferred);
    
                if (packet_handler_)
                {
                    packet_handler_(packet_data.data(), packet_data.size());
                }
    
                AsyncRead();
            }
            else
            {
                std::cerr << "Read body error: " << error.message() << std::endl;
    
                if (reconnect_)
                {
                    timer_.expires_from_now(boost::posix_time::seconds(kReconnectInterval));
                    timer_.async_wait(
                        boost::bind(&TcpClient::HandleTimer,
                        shared_from_this(),
                        boost::asio::placeholders::error));
                }
            }
        }
    
        void HandleWrite(const boost::system::error_code& error,
                         std::size_t bytes_transferred)
        {
            if (error)
            {
                std::cerr << "Write error: " << error.message() << std::endl;
    
                if (reconnect_)
                {
                    timer_.expires_from_now(boost::posix_time::seconds(kReconnectInterval));
                    timer_.async_wait(
                        boost::bind(&TcpClient::HandleTimer,
                        shared_from_this(),
                        boost::asio::placeholders::error));
                }
            }
        }
    
        void HandleTimer(const boost::system::error_code& error)
        {
            if (!error)
            {
                Connect();
            }
        }
    
        uint32_t ParsePacketHeader(const char* data)
        {
            uint32_t size = 0;
            memcpy(&size, data, kPacketHeaderSize);
            return ntohl(size);
        }
    
    private:
        boost::asio::io_service& io_service_;
        boost::asio::ip::tcp::socket socket_;
        std::string server_ip_;
        uint16_t port_num_;
        boost::asio::streambuf read_buffer_;
        boost::asio::deadline_timer timer_;
        bool reconnect_;
        std::function<void(const char*, std::size_t)> packet_handler_;
    
        static const uint32_t kPacketHeaderSize = sizeof(uint32_t);
        static const uint32_t kReconnectInterval = 5; // seconds
    };
    

    该类的主要成员函数说明如下:

    • void Connect():连接到指定的服务器。如果连接失败,会在一段时间后自动重新连接。
    • void AsyncRead():异步读取的方法,该方法首先会异步读取包头,读取成功之后会继续异步读取包体,并将读取到的完整数据包交给用户指定的回调函数进行处理。
    • void AsyncWrite(const char* data, std::size_t length):异步写的方法,用于将数据异步写入TCP连接的发送缓冲区。
    • void Close():关闭TCP连接,停止自动重连。
    • void SetPacketHandler(std::function<void(const char*, std::size_t)> handler):设置用户指定的数据包处理函数,该函数会在异步读取到完整的数据包后进行调用。

    另外,该类还定义了一些常量:

    • static const uint32_t kPacketHeaderSize = sizeof(uint32_t):数据包的包头大小,这里使用4个字节。
    • static const uint32_t kReconnectInterval = 5:断线重连的时间间隔,单位是秒。

    使用该类的示例代码如下:

    #include "TcpClient.h"
    
    void PrintPacket(const char* data, std::size_t length)
    {
        std::cout << "Received packet size: " << length << std::endl;
    }
    
    int main(int argc, char* argv[])
    {
        boost::asio::io_service io_service;
        TcpClient::pointer client =
            boost::make_shared<TcpClient>(io_service, "127.0.0.1", 12345);
    
        client->SetPacketHandler(boost::bind(PrintPacket, _1, _2));
        client->Connect();
    
        boost::thread thread(
            boost::bind(&boost::asio::io_service::run, &io_service));
    
        while (true)
        {
            std::string input;
            std::cin >> input;
    
            if (input == "quit")
            {
                break;
            }
    
            std::vector<char> packet_data(input.begin(), input.end());
            uint32_t packet_size = packet_data.size();
            packet_size = htonl(packet_size);
    
            client->AsyncWrite((const char*)&packet_size, TcpClient::kPacketHeaderSize);
            client->AsyncWrite(packet_data.data(), packet_data.size());
        }
    
        client->Close();
        thread.join();
    
        return 0;
    }
    

    在这个示例代码中,首先创建了一个TcpClient对象,并通过SetPacketHandler方法指定了一个回调函数来处理读取到的数据包。接着使用Connect方法进行连接,之后在独立的线程中调用io_service的run方法以处理异步事件。

    主线程中使用循环从标准输入中读取用户输入,并将输入打包成一个数据包发送到服务器端。其中通过htonl函数将数据包大小从主机字节序转换成网络字节序。如果用户输入了"quit",则退出循环,关闭TCP连接,等待io_service线程结束。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.