webSocket模块组件

对应的头文件

#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
#include <nlohmann/json.hpp>
#include <boost/asio.hpp>
#include <queue>
#include <functional>
#include <memory>
#include <mutex>

using json = nlohmann::json;
using namespace websocketpp;

namespace asio = boost::asio;
using asio::io_context;

WebSocketServer类的实现

// WebSocket服务器类
class WebSocketServer {
public:
    using server_type = server<config::asio>;
    WebSocketServer(asio::io_context& io_context)
        : m_server(io_context),
          m_io_context(io_context) {}

    void start(uint16_t port);
    void stop();
    void handle_message(server_type::connection_hdl hdl, server_type::message_ptr msg);

private:
    server_type m_server;
    asio::io_context& m_io_context;
};

MessageHandler类的实现：

// 消息处理器类
class MessageHandler {
public:
    static void process_message(const json& message, std::function<void(json)> callback);
};

ConnectionManager类的实现：

// 连接管理器类
class ConnectionManager {
public:
    void on_open(server_type::connection_hdl hdl);
    void on_close(server_type::connection_hdl hdl);

private:
    std::mutex m_mutex;
    std::unordered_map<server_type::connection_hdl, bool> m_connections;
};

TaskQueue类的实现：

// 异步任务队列类
class TaskQueue {
public:
    void enqueue(std::function<void()> task);
    void run();

private:
    std::queue<std::function<void()>> m_queue;
    std::mutex m_mutex;
    std::condition_variable m_condition;
};

类函数的定义

void WebSocketServer::start(uint16_t port) {
    m_server.init_asio();
    m_server.set_access_channels(websocketpp::log::alevel::all);
    m_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
    m_server.listen(port);
    m_server.set_open_handler(std::bind(&ConnectionManager::on_open, &m_connection_manager, std::placeholders::_1));
    m_server.set_close_handler(std::bind(&ConnectionManager::on_close, &m_connection_manager, std::placeholders::_1));
    m_server.set_message_handler(std::bind(&WebSocketServer::handle_message, this, std::placeholders::_1, std::placeholders::_2));
    m_server.start_accept();
    m_io_context.run();
}

void WebSocketServer::stop() {
    m_io_context.stop();
}

void WebSocketServer::handle_message(server_type::connection_hdl hdl, server_type::message_ptr msg) {
    try {
        auto j = json::parse(msg->get_payload());
        MessageHandler::process_message(j, [this, hdl](const json& response) {
            m_server.send(hdl, response.dump(), websocketpp::frame::opcode::text);
        });
    } catch (std::exception& e) {
        // 错误处理
    }
}

void MessageHandler::process_message(const json& message, std::function<void(json)> callback) {
    // 根据消息类型处理消息
    if (message["type"] == "request") {
        // 调用相应的业务逻辑
        // ...

        // 假设我们得到了响应数据
        json response = {{"type", "response"}, {"data", "Hello World!"}};
        callback(response);
    }
}

void ConnectionManager::on_open(server_type::connection_hdl hdl) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_connections[hdl] = true;
}

void ConnectionManager::on_close(server_type::connection_hdl hdl) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_connections.erase(hdl);
}

void TaskQueue::enqueue(std::function<void()> task) {
    std::lock_guard<std::mutex> lock(m_mutex);
    m_queue.push(task);
    m_condition.notify_one();
}

void TaskQueue::run() {
    std::unique_lock<std::mutex> lock(m_mutex);
    while (true) {
        if (!m_queue.empty()) {
            auto task = std::move(m_queue.front());
            m_queue.pop();
            lock.unlock();
            task();
            lock.lock();
        } else {
            m_condition.wait(lock);
        }
    }
}