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

使用boots 实现服务端,要求运行于独立线程异步通信,支持解包

  1. User

    使用boots 实现服务端,要求运行于独立线程异步通信,支持解包

  2. Assistant

    和封装网络数据,可以考虑以下步骤:

    1. 引入boots网络框架依赖
    <dependency>
        <groupId>com.github.safrain</groupId>
        <artifactId>boots</artifactId>
        <version>0.9.9</version>
    </dependency>
    
    1. 创建服务端启动类
    public class ServerBoot {
        public static void main(String[] args) {
            // 创建 BootConfig 对象并设置相关属性
            BootConfig config = new BootConfig();
            // 设置服务端IP和端口号
            config.setListenAddress("127.0.0.1", 9999);
            // 设置IO线程数和工作线程数
            config.setIoThreadPoolSize(2);
            config.setWorkerThreadPoolSize(4);
            // 设置包解析处理器
            config.setMessageHandler(new YourMessageHandler());
            
            // 创建 BootServer 对象并启动服务
            BootServer server = new BootServer(config);
            server.start();
        }
    }
    
    1. 实现包解析处理器
    public class YourMessageHandler implements MessageHandler {
        @Override
        public void handle(IoSession session, Object message) {
            // 解析并处理收到的数据包
            if (message instanceof YourPacket) {
                YourPacket packet = (YourPacket) message;
                // 操作包数据并返回结果给客户端
                session.write(new YourResultPacket(...));
            }
        }
    
        @Override
        public void onException(Throwable throwable) {
            // 处理异常
        }
    }
    
    1. 创建数据包类
    public class YourPacket implements Packet {
        // 实现数据包结构和序列化方法
    }
    
    public class YourResultPacket implements Packet {
        // 实现结果数据包结构和序列化方法
    }
    

    以上代码仅为示例,具体实现需要根据业务需求进行调整和优化。另外,服务端代码应该放在单独的模块中,以便复用和扩展。

  3. User

    使用boost 实现服务端,要求运行于独立线程异步通信,支持解包

  4. Assistant

    Boost C++库提供了网络编程库Asio,可以使用它来实现服务端。具体步骤如下:

    1. 引入Asio库

    如果没有安装Asio库,则需要先安装。在CMakeLists.txt中添加以下代码:

    find_package(Boost REQUIRED COMPONENTS system thread)
    include_directories(${Boost_INCLUDE_DIRS})
    
    add_executable(your_server main.cpp)
    target_link_libraries(your_server ${Boost_LIBRARIES})
    
    1. 创建服务端启动类
    #include <iostream>
    #include <boost/bind/bind.hpp>
    #include <boost/asio.hpp>
    #include <boost/thread/thread.hpp>
    
    using boost::asio::ip::tcp;
    
    void handle_client(tcp::socket &socket) {
        try {
            while (true) {
                // 从客户端接收数据
                boost::asio::streambuf buf;
                boost::asio::read_until(socket, buf, "\n");
                
                // 处理接收到的数据
                std::istream input(&buf);
                std::string request;
                std::getline(input, request);
                std::cout << "Received: " << request << std::endl;
                
                // 向客户端发送数据
                boost::asio::write(socket, boost::asio::buffer("OK\n"));
            }
        } catch (std::exception &e) {
            std::cerr << "Exception in thread: " << e.what() << std::endl;
        }
    }
    
    void start_server(boost::asio::io_context &io_context, unsigned short port) {
        tcp::acceptor acceptor(io_context, tcp::endpoint(tcp::v4(), port));
        std::cout << "Server started on port " << port << std::endl;
    
        while (true) {
            // 等待连接
            tcp::socket socket(io_context);
            acceptor.accept(socket);
    
            // 创建新线程处理客户端请求
            boost::thread t(boost::bind(handle_client, boost::ref(socket)));
            t.detach();
        }
    }
    
    int main() {
        try {
            boost::asio::io_context io_context;
            start_server(io_context, 9999);
            io_context.run();
        } catch (std::exception &e) {
            std::cerr << "Exception: " << e.what() << std::endl;
        }
        return 0;
    }
    
    1. 编译并运行服务端

    使用以下命令编译服务端程序:

    mkdir build && cd build
    cmake ..
    make
    

    运行服务端程序:

    ./your_server
    

    以上代码仅为示例,具体实现需要根据业务需求进行调整和优化。另外,服务端代码应该放在单独的模块中,以便复用和扩展。

  5. User

    使用boost 实现tcp服务,要求运行于独立线程异步通信,支持解包

  6. Assistant

    Boost C++库提供了网络编程库Asio,可以使用它来实现TCP服务,并支持解包。具体步骤如下:

    1. 引入Asio库

    如果没有安装Asio库,则需要先安装。在CMakeLists.txt中添加以下代码:

    find_package(Boost REQUIRED COMPONENTS system thread)
    include_directories(${Boost_INCLUDE_DIRS})
    
    add_executable(your_server main.cpp)
    target_link_libraries(your_server ${Boost_LIBRARIES})
    
    1. 创建数据包类
    #include <vector>
    #include <iostream>
    
    class Packet {
    public:
        Packet() = default;
    
        virtual ~Packet() = default;
    
        void encode(std::vector<char> &buffer) {
            buffer.reserve(this->size());
            this->doEncode(buffer);
        }
    
        void decode(const std::vector<char> &buffer) {
            if (buffer.size() != this->size()) {
                throw std::runtime_error("Packet size mismatch");
            }
            this->doDecode(buffer);
        }
    
        virtual unsigned int size() const = 0;
    
    protected:
        virtual void doEncode(std::vector<char> &buffer) const = 0;
    
        virtual void doDecode(const std::vector<char> &buffer) = 0;
    };
    

    其中,Packet类是基础数据包类,实现了数据包的编解码方法。具体的数据包类可以继承Packet类,并根据业务需求进行扩展。

    1. 实现异步读写回调函数
    class Session : public std::enable_shared_from_this<Session> {
    public:
        typedef std::shared_ptr<Session> Ptr;
    
        Session(boost::asio::io_context &io_context)
                : socket_(io_context), buffer_(1024) {}
    
        tcp::socket &socket() {
            return socket_;
        }
    
        void start() {
            // 异步读取数据
            auto self(shared_from_this());
            socket_.async_read_some(
                    boost::asio::buffer(buffer_),
                    [self](boost::system::error_code ec, std::size_t bytes_transferred) {
                        if (!ec) {
                            // 处理收到的数据
                            try {
                                Packet packet;
                                std::vector<char> msg(self->buffer_.begin(),
                                                      self->buffer_.begin() + bytes_transferred);
                                packet.decode(msg);
                                std::cout << "Received: " << packet << std::endl;
    
                                // 向客户端发送回复
                                boost::asio::write(self->socket_,
                                                   boost::asio::buffer(Packet("OK")));
                                self->start();
                            } catch (std::exception &e) {
                                std::cerr << "Exception in session: " << e.what() << std::endl;
                            }
                        } else {
                            std::cerr << "Error in session: " << ec.message() << std::endl;
                        }
                    });
        }
    
    private:
        tcp::socket socket_;
        std::vector<char> buffer_;
    };
    

    其中,Session类表示一次连接会话(包含一个socket和读写缓冲区),并以共享指针方式持有。由于需要异步读写数据,故必须使用共享指针,以便在回调函数中使用shared_from_this()方法获取Session对象的引用。

    1. 创建TCP服务类
    class Server {
    public:
        Server(boost::asio::io_context &io_context, unsigned short port)
                : acceptor_(io_context, tcp::endpoint(tcp::v4(), port)) {}
    
        void start() {
            // 接收连接
            do_accept();
        }
    
    private:
        void do_accept() {
            auto new_session = std::make_shared<Session>(acceptor_.get_executor().context());
            acceptor_.async_accept(new_session->socket(),
                                   [this, new_session](boost::system::error_code ec) {
                                       if (!ec) {
                                           new_session->start();
                                       }
                                       // 继续接收
                                       do_accept();
                                   });
        }
    
    private:
        tcp::acceptor acceptor_;
    };
    

    其中,Server类表示TCP服务,负责监听和接收连接,并维护多个Session对象。

    1. 启动服务
    int main() {
        try {
            boost::asio::io_context io_context;
            Server server(io_context, 9999);
            server.start();
            io_context.run();
        } catch (std::exception &e) {
            std::cerr << "Exception: " << e.what() << std::endl;
        }
        return 0;
    }
    
    1. 发送数据包

    可以在客户端使用以下代码发送数据包:

    tcp::socket socket(io_context);
    socket.connect(tcp::endpoint(address::from_string("127.0.0.1"), 9999));
    Packet packet("Hello, world!");
    std::vector<char> buffer;
    packet.encode(buffer);
    boost::asio::write(socket, boost::asio::buffer(buffer));
    

    以上代码仅为示例,具体实现需要根据业务需求进行调整和优化。另外,可以使用工厂模式创建数据包对象,并使用多态来处理各种数据包类型。

  7. User

    使用boost 实现一个tcp服务端类TCPServer,运行于独立线程支持异步,支持会话管理

  8. Assistant

    可以使用boost库中的Asio模块实现一个支持异步、支持会话管理的TCP服务端类TCPServer。具体实现步骤如下:

    1. 引入Asio库

    在CMakeLists.txt文件中添加以下代码:

    find_package(Boost REQUIRED COMPONENTS system thread)
    include_directories(${Boost_INCLUDE_DIRS})
    
    add_library(TCPServer STATIC TCPServer.cpp)
    target_link_libraries(TCPServer ${Boost_LIBRARIES})
    
    1. 实现服务端类
    #include "TCPServer.h"
    
    TCPServer::TCPServer() : ioContext_(), acceptor_(ioContext_) {}
    
    void TCPServer::start(uint16_t port) {
        // 设置监听端口号
        tcp::endpoint endpoint(tcp::v4(), port);
        acceptor_.open(endpoint.protocol());
        acceptor_.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
        acceptor_.bind(endpoint);
        acceptor_.listen();
    
        accept();
    
        std::thread t([this]() { ioContext_.run(); });
        thread_ = std::move(t);
    }
    
    void TCPServer::stop() {
        ioContext_.stop();
        if (thread_.joinable()) {
            thread_.join();
        }
    }
    
    void TCPServer::onConnected(TCPSessionPtr session) {
        std::lock_guard<std::mutex> lock(sessionsMutex_);
        sessions_.insert(session);
    }
    
    void TCPServer::onDisconnected(TCPSessionPtr session) {
        std::lock_guard<std::mutex> lock(sessionsMutex_);
        sessions_.erase(session);
    }
    
    void TCPServer::accept() {
        acceptor_.async_accept(ioContext_, [this](boost::system::error_code ec, tcp::socket socket) {
            if (!ec) {
                TCPSessionPtr session = std::make_shared<TCPSession>(std::move(socket), shared_from_this());
                session->start();
                onConnected(session);
            }
            accept();
        });
    }
    
    1. 实现会话管理类

    会话管理类TCPSession表示一个与客户端建立的TCP连接,并实现对连接的异步读写操作。可以在TCPServer中记录所有建立的会话。

    #include "TCPSession.h"
    #include "TCPServer.h"
    
    TCPSession::TCPSession(tcp::socket socket, TCPServerPtr server) :
            socket_(std::move(socket)), server_(std::move(server)), readBuffer_(), callbackMutex_(),
            readCallback_(), disconnected_(false) {
    
    }
    
    void TCPSession::start() {
        read();
    }
    
    void TCPSession::stop() {
        boost::system::error_code ec;
        socket_.close(ec);
        onDisconnected();
    }
    
    void TCPSession::write(const std::string &message) {
        const char *data = message.data();
        size_t length = message.length();
    
        boost::asio::async_write(socket_, boost::asio::buffer(data, length),
                                 [this](const boost::system::error_code &ec, std::size_t length) {
                                     if (ec) {
                                         std::cerr << "Error in TCPSession::write: " << ec.message() << std::endl;
                                     }
                                 });
    }
    
    void TCPSession::read() {
        auto self(shared_from_this());
        boost::asio::async_read_until(socket_, readBuffer_, '\n', [this, self](const boost::system::error_code &ec,
                                                                                std::size_t bytes_transferred) {
            if (!ec) {
                std::istream input(&readBuffer_);
                std::string message;
                std::getline(input, message);
    
                onRead(message);
    
                self->readBuffer_.consume(bytes_transferred);
                self->read();
            } else {
                onDisconnected();
                std::cerr << "Error in TCPSession::read: " << ec.message() << std::endl;
            }
        });
    }
    
    void TCPSession::onRead(const std::string &message) {
        std::lock_guard<std::mutex> lock(callbackMutex_);
        if (readCallback_) {
            readCallback_(message);
        }
    }
    
    void TCPSession::onDisconnected() {
        if (disconnected_) {
            return;
        }
    
        disconnected_ = true;
        socket_.close();
    
        if (server_) {
            server_->onDisconnected(shared_from_this());
        }
    }
    
    void TCPSession::setReadCallback(ReadCallback callback) {
        std::lock_guard<std::mutex> lock(callbackMutex_);
        readCallback_ = std::move(callback);
    }
    
    1. 定义TCPServer和TCPSession类的头文件
    #ifndef TCP_TCPSERVER_H
    #define TCP_TCPSERVER_H
    
    #include "TCPSession.h"
    
    class TCPServer : public std::enable_shared_from_this<TCPServer> {
    public:
        TCPServer();
    
        void start(uint16_t port);
    
        void stop();
    
        void onConnected(TCPSessionPtr session);
    
        void onDisconnected(TCPSessionPtr session);
    
    private:
        void accept();
    
    private:
        boost::asio::io_context ioContext_;
        tcp::acceptor acceptor_;
        std::set<TCPSessionPtr> sessions_;
        std::mutex sessionsMutex_;
        std::thread thread_;
    };
    
    #endif //TCP_TCPSERVER_H
    
    #ifndef TCP_TCPSESSION_H
    #define TCP_TCPSESSION_H
    
    #include <iostream>
    #include <memory>
    #include <mutex>
    #include <set>
    #include <string>
    #include <boost/asio.hpp>
    
    using boost::asio::ip::tcp;
    
    class TCPSession;
    
    typedef std::shared_ptr<TCPSession> TCPSessionPtr;
    
    typedef std::shared_ptr<class TCPServer> TCPServerPtr;
    
    typedef std::function<void(const std::string &)> ReadCallback;
    
    class TCPSession : public std::enable_shared_from_this<TCPSession> {
    public:
        explicit TCPSession(tcp::socket socket, TCPServerPtr server = nullptr);
    
        void start();
    
        void stop();
    
        void write(const std::string &message);
    
        void read();
    
        void onRead(const std::string &message);
    
        void onDisconnected();
    
        void setReadCallback(ReadCallback callback);
    
    private:
        tcp::socket socket_;
        TCPServerPtr server_;
        boost::asio::streambuf readBuffer_;
        std::mutex callbackMutex_;
        ReadCallback readCallback_;
        bool disconnected_;
    };
    
    #endif //TCP_TCPSESSION_H
    

    以上代码仅为示例,具体实现需要根据业务需求进行调整和优化。同时,也需要注意在TCPSession和TCPServer中加锁,以避免多线程访问导致的竞态条件问题。