当前位置：首页 > news >正文

MFC集成WebSocket++实现实时通信：线程安全架构与工程实践

news 2026/7/27 4:29:13

1. 项目概述：为什么要在MFC里折腾WebSocket？

如果你是一个长期在Windows桌面端开发领域摸爬滚打的C++程序员，对MFC（Microsoft Foundation Classes）一定又爱又恨。爱它的成熟稳定、与Windows系统深度集成，恨它那套略显陈旧的文档/视图架构和消息映射机制，尤其是在面对现代实时交互需求时。当你的客户或产品经理提出“我要一个能实时显示服务器数据、能双向通信、像网页聊天室一样流畅”的需求时，传统的WinSock异步套接字、或者基于定时器轮询HTTP的方式，就显得捉襟见肘，代码会迅速变得复杂且难以维护。

这正是WebSocket登场的时候。它本质上是一个基于TCP的全双工通信协议，通过一次HTTP握手建立连接后，就形成了一条持久的通道，服务器可以随时主动推送数据到客户端，客户端也可以随时发送请求，延迟极低。把它引入MFC项目，相当于给这位“老将”配上了一把“现代兵器”，让基于对话框或单文档的C/S架构程序，也能轻松实现股票行情、即时通讯、监控大屏、在线协作等实时功能。

我最近就在一个工业数据采集监控项目中用了这一套。现场有上百台设备，需要将状态参数实时推送到中控室的MFC客户端上显示。最初用TCP长连接自己管理心跳、重连、粘包，代码写得痛苦不堪。后来将后端服务改造成了WebSocket服务，MFC客户端连接上去，整个世界都清净了。服务器有数据就推，客户端收到消息直接更新UI，逻辑清晰，性能也好。这个项目我会把核心思路和踩过的坑都分享出来，并附上完整的、可编译的源码，你拿过去改改就能用。

2. 核心思路与方案选型：在MFC中集成WebSocket的几种姿势

在MFC里实现WebSocket客户端，本质上是要找一个可靠的C++ WebSocket库，并解决其在MFC消息循环中的集成问题。你不能直接阻塞UI线程去等待网络消息，也不能让网络库的回调函数直接去操作MFC的控件，那会引发线程安全问题。

2.1 主流C++ WebSocket库横向对比

市面上常见的C++ WebSocket客户端库主要有以下几个，我们得根据MFC的环境（通常是Windows， VS编译）来选型：

WebSocket++：一个只有头文件的、跨平台的C++ WebSocket库，基于Asio。非常轻量，功能强大，是很多人的首选。但它的异步模型需要你理解Asio的io_context和事件循环，集成到MFC的主消息泵里需要一些技巧。
libwebsockets：一个用C写的、轻量且高性能的库，被广泛用于嵌入式和高并发场景。C的API对于C++项目来说稍显繁琐，但非常稳定。它自带事件循环，也可以集成到外部的事件循环中。
Boost.Beast：Boost库的一部分，提供了低级的HTTP和WebSocket抽象，同样基于Asio。它非常灵活，但学习曲线陡峭，需要你对网络编程有较深理解。
Poco库中的WebSocket：Poco是一个全面的C++类库，其Net模块包含了WebSocket实现。它封装得比较好，使用起来相对简单，但会引入整个Poco库，可能有点重。
Qt的QWebSocket：如果你的MFC项目本身就混合了Qt，或者不介意引入Qt的依赖，QWebSocket是最好用的选择，信号槽机制与异步UI更新天生契合。但对于纯MFC项目，引入Qt成本过高。

我的选择与理由：对于大多数以简洁、稳定、易于集成为目标的MFC项目，我推荐WebSocket++。原因如下：

头文件库：只需包含头文件，无需编译复杂的第三方库，避免MFC项目在链接时可能遇到的运行时库冲突问题。
基于Asio：Asio是行业标准的异步I/O库，模型成熟，性能有保障。
活跃的社区：遇到问题，网上能找到的案例和讨论相对较多。
清晰的层次：它区分了客户端、服务端、连接、消息等概念，与我们MFC中对象化的思维模式匹配。

当然，它的缺点就是需要手动处理Asio的io_context与MFC消息循环的“共处”问题，这也是本项目的技术关键点之一。

2.2 架构设计：网络线程与UI线程的通信

这是整个项目的核心架构思想，必须理解透彻。我们不能在MFC的主线程（UI线程）里执行阻塞式的网络等待或运行Asio的事件循环，这会导致界面卡死。反之，也不能在WebSocket库的网络回调线程里直接调用MFC控件的方法（如SetWindowText），这可能导致程序崩溃。

因此，标准的做法是：

分离线程：创建一个独立的工作线程（std::thread），在这个线程中运行Asio的io_context.run()。所有WebSocket的网络事件（连接、收消息、断开）都在这个线程中触发。
线程间通信：当工作线程中的WebSocket收到消息或状态改变时，通过线程安全的方式通知UI线程。在MFC中，最自然、最安全的方式就是使用自定义Windows消息(PostMessage/SendMessage)。
UI线程响应：MFC的主窗口（对话框或主框架窗口）捕获这些自定义消息，在其消息处理函数中安全地更新控件、改变界面状态。

这个“网络线程 -> (消息队列) -> UI线程”的模型，是Windows桌面程序处理异步任务的经典模式，稳定可靠。

3. 环境准备与工程配置

3.1 获取WebSocket++

我们不使用NuGet或vcpkg（对于老版本VS可能支持不好），而是直接下载源码，最简单可控。

访问WebSocket++在GitHub的仓库（https://github.com/zaphoyd/websocketpp），下载最新的Release版本源码包（比如.zip格式）。
解压后，我们只需要websocketpp这个文件夹里的所有头文件。在你的MFC解决方案目录下，新建一个third_party文件夹，把websocketpp文件夹拷贝进去。这样，你的项目结构里就包含了third_party\websocketpp\。

3.2 创建MFC项目并配置

打开Visual Studio（我用的是VS2019，VS2015/2017/2022同理），创建一个新的MFC应用程序。项目类型选择基于对话框的，这样最简洁。给项目起个名字，比如MfcWebsocketClient。
项目创建好后，需要配置包含目录，让编译器能找到WebSocket++和Asio。
- 右键项目 -> 属性 ->C/C++->常规->附加包含目录。
- 添加两项：
  - $(ProjectDir)third_party（指向我们刚才放的WebSocket++头文件）
  - $(ProjectDir)third_party\websocketpp\vendor\asio\asio\include（WebSocket++包里自带了Asio，路径就在这）
配置字符集：为了省事，避免字符串转换的麻烦，建议将项目字符集设置为使用多字节字符集。虽然Unicode是趋势，但很多老MFC代码和示例是多字节的，WebSocket++内部处理字符串也更方便。
- 属性 ->高级->字符集-> 选择使用多字节字符集。
由于我们使用了C++11的线程(std::thread)，需要开启C++11支持（VS2015及以上默认是开启的）。确保属性 ->C/C++->语言->C++语言标准至少是ISO C++14 Standard或ISO C++17 Standard。

3.3 对话框界面设计

打开资源视图里的主对话框(IDD_MFCWEBSOCKETCLIENT_DIALOG)，我们设计一个简单的客户端界面：

添加一个Edit Control文本框，ID设为IDC_EDIT_SERVER_URL，用于输入WebSocket服务器地址，如ws://127.0.0.1:8080。可以给它一个默认提示文本。
添加一个Button，ID设为IDC_BTN_CONNECT，标题为“连接”。
添加一个Button，ID设为IDC_BTN_DISCONNECT，标题为“断开”，初始状态设为禁用(Disabled)。
添加一个Edit Control文本框，ID设为IDC_EDIT_SEND_MSG，用于输入要发送的消息。
添加一个Button，ID设为IDC_BTN_SEND，标题为“发送”，初始状态设为禁用。
添加一个ListBox或Edit Control（设置Multiline,Readonly,Vertical scroll属性），ID设为IDC_EDIT_LOG，用于显示连接状态和收到的消息日志。用ListBox显示条目更清晰，我这里用CEdit并设置为多行只读。
再添加一个Static Text静态文本，显示“状态：”，旁边跟一个Edit Control，ID设为IDC_EDIT_STATUS，设置为只读，用于显示当前的连接状态（如“未连接”、“已连接”）。

布局可以自由调整，让界面看起来整洁即可。设计器大致如下图（描述性）：

[WebSocket 服务器: [ws://127.0.0.1:8080] ] [连接] [断开] [发送消息: [在这里输入文本...] ] [发送] [日志输出：] [---------------------------------------------] [状态：[未连接] ]

4. 核心代码实现与详解

接下来是重头戏，我们将把WebSocket++集成到MFC的对话框类中。

4.1 定义自定义消息与连接管理器类

首先，在stdafx.h或对话框头文件的开头，定义我们用于线程间通信的自定义消息：

// 自定义消息，用于从工作线程通知UI线程 #define WM_WEBSOCKET_MSG (WM_USER + 100) // 收到文本消息 #define WM_WEBSOCKET_STATUS (WM_USER + 101) // 连接状态改变

然后，我们创建一个关键的WebSocketClientManager类，它负责封装所有WebSocket++的逻辑，并运行在独立线程中。在项目中新增一个头文件WebSocketClientManager.h和源文件WebSocketClientManager.cpp。

WebSocketClientManager.h

#pragma once #include <websocketpp/config/asio_no_tls_client.hpp> #include <websocketpp/client.hpp> #include <string> #include <thread> #include <mutex> #include <functional> typedef websocketpp::client<websocketpp::config::asio_client> client; typedef websocketpp::connection_hdl connection_hdl; // 前向声明MFC对话框类，避免循环包含 class CMfcWebsocketClientDlg; class WebSocketClientManager { public: WebSocketClientManager(); ~WebSocketClientManager(); // 设置UI回调窗口 void SetNotifyWindow(HWND hWnd); // 连接服务器 bool Connect(const std::string& uri); // 断开连接 void Disconnect(); // 发送文本消息 bool SendTextMessage(const std::string& message); // 获取当前连接状态 bool IsConnected() const; private: // Asio io_context 和 客户端实例 client m_client; std::unique_ptr<asio::io_context> m_io_context; std::unique_ptr<std::thread> m_network_thread; // 连接句柄和状态 connection_hdl m_connection_hdl; mutable std::mutex m_connection_mutex; // 保护连接句柄的访问 bool m_is_connected; // 用于通知UI的窗口句柄 HWND m_hNotifyWnd; // WebSocket++ 事件处理器 void OnOpen(connection_hdl hdl); void OnFail(connection_hdl hdl); void OnClose(connection_hdl hdl); void OnMessage(connection_hdl hdl, client::message_ptr msg); // 运行网络IO循环 void RunIOContext(); // 内部工具函数：发送消息到UI线程 void PostStatusToUI(const std::string& status); void PostMessageToUI(const std::string& msg); };

这个类是整个WebSocket客户端的引擎。它封装了client对象、IO上下文、网络线程，并提供了连接、断开、发送等接口。SetNotifyWindow用于接收MFC主窗口的句柄，以便回调时能PostMessage。

4.2 实现连接管理器

WebSocketClientManager.cpp的实现是核心，我们一步步看：

#include "stdafx.h" // 如果需要 #include "WebSocketClientManager.h" #include "MfcWebsocketClientDlg.h" // 为了使用自定义消息常量，需要包含对话框头文件 WebSocketClientManager::WebSocketClientManager() : m_is_connected(false) , m_hNotifyWnd(NULL) { // 初始化Asio io_context m_io_context = std::make_unique<asio::io_context>(); // 设置客户端日志策略（可选，调试时开启） m_client.clear_access_channels(websocketpp::log::alevel::all); m_client.set_access_channels(websocketpp::log::alevel::connect | websocketpp::log::alevel::disconnect); // 初始化Asio m_client.init_asio(m_io_context.get()); // 绑定事件处理器 m_client.set_open_handler(std::bind(&WebSocketClientManager::OnOpen, this, std::placeholders::_1)); m_client.set_fail_handler(std::bind(&WebSocketClientManager::OnFail, this, std::placeholders::_1)); m_client.set_close_handler(std::bind(&WebSocketClientManager::OnClose, this, std::placeholders::_1)); m_client.set_message_handler(std::bind(&WebSocketClientManager::OnMessage, this, std::placeholders::_1, std::placeholders::_2)); } WebSocketClientManager::~WebSocketClientManager() { Disconnect(); // 确保析构时断开连接 if (m_network_thread && m_network_thread->joinable()) { // 停止io_context，让线程退出 m_io_context->stop(); m_network_thread->join(); } } void WebSocketClientManager::SetNotifyWindow(HWND hWnd) { m_hNotifyWnd = hWnd; } bool WebSocketClientManager::Connect(const std::string& uri) { if (m_is_connected) { return false; } websocketpp::lib::error_code ec; client::connection_ptr con = m_client.get_connection(uri, ec); if (ec) { PostStatusToUI("连接失败: " + ec.message()); return false; } // 保存连接句柄（注意：此时连接尚未建立） { std::lock_guard<std::mutex> lock(m_connection_mutex); m_connection_hdl = con->get_handle(); } // 启动网络线程（如果还没启动） if (!m_network_thread) { // 注意：必须先启动线程，再调用connect，否则io_context没有run，连接无法进行 m_network_thread = std::make_unique<std::thread>(&WebSocketClientManager::RunIOContext, this); } // 发起连接（异步操作） m_client.connect(con); PostStatusToUI("正在连接..."); return true; } void WebSocketClientManager::Disconnect() { if (!m_is_connected) { return; } websocketpp::lib::error_code ec; m_client.close(m_connection_hdl, websocketpp::close::status::normal, "Client disconnect", ec); if (ec) { // 记录错误，但继续执行断开逻辑 } m_is_connected = false; PostStatusToUI("连接已断开"); } bool WebSocketClientManager::SendTextMessage(const std::string& message) { if (!m_is_connected) { return false; } websocketpp::lib::error_code ec; m_client.send(m_connection_hdl, message, websocketpp::frame::opcode::text, ec); if (ec) { PostStatusToUI("发送失败: " + ec.message()); return false; } return true; } bool WebSocketClientManager::IsConnected() const { return m_is_connected; } // --- 事件处理器 --- void WebSocketClientManager::OnOpen(connection_hdl hdl) { m_is_connected = true; PostStatusToUI("连接成功"); } void WebSocketClientManager::OnFail(connection_hdl hdl) { m_is_connected = false; PostStatusToUI("连接失败"); // 可以尝试获取错误信息，这里简化处理 } void WebSocketClientManager::OnClose(connection_hdl hdl) { m_is_connected = false; PostStatusToUI("连接关闭"); } void WebSocketClientManager::OnMessage(connection_hdl hdl, client::message_ptr msg) { if (msg->get_opcode() == websocketpp::frame::opcode::text) { PostMessageToUI(msg->get_payload()); } else { // 二进制消息，这里简单处理为十六进制字符串显示 // 实际项目可根据需要处理 const auto& payload = msg->get_payload(); std::string hexStr = "Binary Msg: "; for (auto c : payload) { char buf[4]; sprintf_s(buf, "%02X ", static_cast<unsigned char>(c)); hexStr += buf; } PostMessageToUI(hexStr); } } // --- 网络线程函数 --- void WebSocketClientManager::RunIOContext() { try { // 运行io_context，这个调用会阻塞，直到io_context被stop m_io_context->run(); } catch (const std::exception& e) { PostStatusToUI(std::string("IO Context异常: ") + e.what()); } catch (...) { PostStatusToUI("IO Context未知异常"); } } // --- 工具函数：向UI线程投递消息 --- void WebSocketClientManager::PostStatusToUI(const std::string& status) { if (m_hNotifyWnd != NULL) { // 使用CString方便MFC处理 CString strStatus(status.c_str()); // 注意：PostMessage是异步的，不会阻塞网络线程 ::PostMessage(m_hNotifyWnd, WM_WEBSOCKET_STATUS, (WPARAM)new CString(strStatus), 0); } } void WebSocketClientManager::PostMessageToUI(const std::string& msg) { if (m_hNotifyWnd != NULL) { CString strMsg(msg.c_str()); ::PostMessage(m_hNotifyWnd, WM_WEBSOCKET_MSG, (WPARAM)new CString(strMsg), 0); } }

关键点解析：

初始化顺序：必须在启动网络线程RunIOContext之前调用m_client.init_asio()，并且m_io_context->run()必须在独立线程中调用。
连接句柄管理：connection_hdl是一个轻量级的连接标识，需要保存下来用于后续的发送和关闭操作。对其的访问（特别是在多线程环境下）需要用互斥锁保护。
内存管理：注意PostStatusToUI和PostMessageToUI中，我们new了一个CString对象并通过WPARAM传递。必须在UI线程的消息处理函数中delete这个对象，否则会造成内存泄漏。这是跨线程传递动态字符串的常用技巧。
异常处理：io_context->run()可能会抛出异常，必须用try-catch包裹，防止线程意外崩溃导致整个程序不稳定。

4.3 在MFC对话框类中集成管理器

现在，回到我们的主对话框类CMfcWebsocketClientDlg。

在MfcWebsocketClientDlg.h中：

#pragma once #include "WebSocketClientManager.h" // 包含管理器头文件 class CMfcWebsocketClientDlg : public CDialogEx { // ... 其他MFC生成的代码 ... public: // 重写消息映射，添加我们自定义消息的处理函数声明 afx_msg LRESULT OnWebSocketMessage(WPARAM wParam, LPARAM lParam); afx_msg LRESULT OnWebSocketStatus(WPARAM wParam, LPARAM lParam); private: WebSocketClientManager m_wsManager; // WebSocket客户端管理器实例 // ... 其他成员变量和控件关联变量 ... };

在MfcWebsocketClientDlg.cpp中：首先，在消息映射表(BEGIN_MESSAGE_MAP)中添加自定义消息的映射：

BEGIN_MESSAGE_MAP(CMfcWebsocketClientDlg, CDialogEx) ON_WM_SYSCOMMAND() ON_WM_PAINT() ON_WM_QUERYDRAGICON() ON_BN_CLICKED(IDC_BTN_CONNECT, &CMfcWebsocketClientDlg::OnBnClickedBtnConnect) ON_BN_CLICKED(IDC_BTN_DISCONNECT, &CMfcWebsocketClientDlg::OnBnClickedBtnDisconnect) ON_BN_CLICKED(IDC_BTN_SEND, &CMfcWebsocketClientDlg::OnBnClickedBtnSend) // 添加自定义消息映射 ON_MESSAGE(WM_WEBSOCKET_MSG, &CMfcWebsocketClientDlg::OnWebSocketMessage) ON_MESSAGE(WM_WEBSOCKET_STATUS, &CMfcWebsocketClientDlg::OnWebSocketStatus) END_MESSAGE_MAP()

然后，在对话框初始化(OnInitDialog)中，设置通知窗口句柄：

BOOL CMfcWebsocketClientDlg::OnInitDialog() { CDialogEx::OnInitDialog(); // ... 其他初始化代码 ... // 设置WebSocket管理器的UI通知窗口 m_wsManager.SetNotifyWindow(this->GetSafeHwnd()); // 初始化控件状态 GetDlgItem(IDC_BTN_DISCONNECT)->EnableWindow(FALSE); GetDlgItem(IDC_BTN_SEND)->EnableWindow(FALSE); SetDlgItemText(IDC_EDIT_STATUS, _T("未连接")); return TRUE; }

实现自定义消息的处理函数。这里是内存管理的关键！

LRESULT CMfcWebsocketClientDlg::OnWebSocketMessage(WPARAM wParam, LPARAM lParam) { // wParam 传递过来的是 new 出来的 CString* 指针 CString* pStrMsg = reinterpret_cast<CString*>(wParam); if (pStrMsg != nullptr) { // 将收到的消息追加到日志编辑框 CString strLog; CEdit* pEditLog = (CEdit*)GetDlgItem(IDC_EDIT_LOG); if (pEditLog) { pEditLog->GetWindowText(strLog); if (!strLog.IsEmpty()) { strLog += _T("\r\n"); } CString strTime; CTime tm = CTime::GetCurrentTime(); strTime.Format(_T("[%02d:%02d:%02d] "), tm.GetHour(), tm.GetMinute(), tm.GetSecond()); strLog += strTime + _T("Recv: ") + *pStrMsg; pEditLog->SetWindowText(strLog); // 滚动到最后一行 pEditLog->LineScroll(pEditLog->GetLineCount()); } // ！！！重要：删除由网络线程创建的对象，避免内存泄漏 ！！！ delete pStrMsg; } return 0; } LRESULT CMfcWebsocketClientDlg::OnWebSocketStatus(WPARAM wParam, LPARAM lParam) { CString* pStrStatus = reinterpret_cast<CString*>(wParam); if (pStrStatus != nullptr) { // 更新状态编辑框 SetDlgItemText(IDC_EDIT_STATUS, *pStrStatus); // 根据状态更新按钮 CString strStatus = *pStrStatus; if (strStatus.Find(_T("成功")) != -1) { GetDlgItem(IDC_BTN_CONNECT)->EnableWindow(FALSE); GetDlgItem(IDC_BTN_DISCONNECT)->EnableWindow(TRUE); GetDlgItem(IDC_BTN_SEND)->EnableWindow(TRUE); // 连接成功，清空日志？或者添加连接成功提示 CString strLog; CEdit* pEditLog = (CEdit*)GetDlgItem(IDC_EDIT_LOG); if (pEditLog) { pEditLog->GetWindowText(strLog); strLog += _T("\r\n--- 连接已建立 ---\r\n"); pEditLog->SetWindowText(strLog); } } else if (strStatus.Find(_T("断开")) != -1 || strStatus.Find(_T("失败")) != -1) { GetDlgItem(IDC_BTN_CONNECT)->EnableWindow(TRUE); GetDlgItem(IDC_BTN_DISCONNECT)->EnableWindow(FALSE); GetDlgItem(IDC_BTN_SEND)->EnableWindow(FALSE); } // 将状态信息也记录到日志 CString strLog; CEdit* pEditLog = (CEdit*)GetDlgItem(IDC_EDIT_LOG); if (pEditLog) { pEditLog->GetWindowText(strLog); CString strTime; CTime tm = CTime::GetCurrentTime(); strTime.Format(_T("[%02d:%02d:%02d] "), tm.GetHour(), tm.GetMinute(), tm.GetSecond()); strLog += _T("\r\n") + strTime + _T("Status: ") + *pStrStatus; pEditLog->SetWindowText(strLog); pEditLog->LineScroll(pEditLog->GetLineCount()); } // ！！！重要：删除由网络线程创建的对象 ！！！ delete pStrStatus; } return 0; }

最后，实现按钮的点击事件处理函数：

void CMfcWebsocketClientDlg::OnBnClickedBtnConnect() { CString strUrl; GetDlgItemText(IDC_EDIT_SERVER_URL, strUrl); if (strUrl.IsEmpty()) { AfxMessageBox(_T("请输入服务器地址！")); return; } // 转换为std::string (因为我们的管理器接口用的是std::string) CT2CA urlConverted(strUrl); std::string serverUri(urlConverted); if (!m_wsManager.Connect(serverUri)) { AfxMessageBox(_T("连接请求失败，请检查地址格式或网络。")); } } void CMfcWebsocketClientDlg::OnBnClickedBtnDisconnect() { m_wsManager.Disconnect(); } void CMfcWebsocketClientDlg::OnBnClickedBtnSend() { if (!m_wsManager.IsConnected()) { AfxMessageBox(_T("未连接，无法发送消息。")); return; } CString strMsg; GetDlgItemText(IDC_EDIT_SEND_MSG, strMsg); if (strMsg.IsEmpty()) { return; } CT2CA msgConverted(strMsg); std::string message(msgConverted); if (m_wsManager.SendTextMessage(message)) { // 发送成功，将消息显示在日志中 CString strLog; CEdit* pEditLog = (CEdit*)GetDlgItem(IDC_EDIT_LOG); if (pEditLog) { pEditLog->GetWindowText(strLog); CString strTime; CTime tm = CTime::GetCurrentTime(); strTime.Format(_T("[%02d:%02d:%02d] "), tm.GetHour(), tm.GetMinute(), tm.GetSecond()); strLog += _T("\r\n") + strTime + _T("Send: ") + strMsg; pEditLog->SetWindowText(strLog); pEditLog->LineScroll(pEditLog->GetLineCount()); } // 清空发送框 SetDlgItemText(IDC_EDIT_SEND_MSG, _T("")); } }

至此，一个完整的、支持双向实时通信的MFC WebSocket客户端就搭建完成了。你可以编译运行，输入一个可用的WebSocket服务器地址（例如，可以用在线的WebSocket Echo测试服务ws://echo.websocket.org，或者自己用Node.js、Python等快速搭建一个简单的WebSocket服务器）进行测试。

5. 进阶优化与生产环境考量

上面的代码是一个可工作的原型，但在实际生产项目中，还需要考虑更多细节。

5.1 连接稳定性与重连机制

工业级应用要求连接稳定。网络波动、服务器重启都可能导致连接断开。我们需要实现自动重连逻辑。

思路：在WebSocketClientManager::OnClose或OnFail事件中，不要立即清理资源，而是启动一个定时器（可以用Asio的deadline_timer），在延迟几秒后尝试重新连接。重连逻辑需要记录最初的URI，并可能包含重试次数上限和递增延迟（退避算法）。

代码片段示例（在Manager类中添加）：

class WebSocketClientManager { private: std::string m_targetUri; int m_reconnectAttempts; int m_maxReconnectAttempts; asio::steady_timer m_reconnectTimer; void ScheduleReconnect(); void DoReconnect(); }; void WebSocketClientManager::OnClose(connection_hdl hdl) { m_is_connected = false; PostStatusToUI("连接关闭"); if (m_maxReconnectAttempts > 0) { ScheduleReconnect(); } } void WebSocketClientManager::ScheduleReconnect() { if (m_reconnectAttempts >= m_maxReconnectAttempts) { PostStatusToUI("重连次数已达上限，停止重连"); return; } m_reconnectAttempts++; int delaySeconds = std::min(30, m_reconnectAttempts * 5); // 退避算法，最多30秒 m_reconnectTimer.expires_after(std::chrono::seconds(delaySeconds)); m_reconnectTimer.async_wait([this](const std::error_code& ec) { if (!ec) { DoReconnect(); } }); } void WebSocketClientManager::DoReconnect() { PostStatusToUI("尝试第" + std::to_string(m_reconnectAttempts) + "次重连..."); Connect(m_targetUri); // 调用原有的Connect函数 }

在Connect函数成功发起连接时，需要重置m_reconnectAttempts为0。

5.2 心跳机制与连接保活

WebSocket协议本身没有规定心跳。长时间空闲的连接可能被中间的路由器、防火墙或服务器主动断开。为了保持连接活跃，需要客户端定期向服务器发送Ping（或自定义的心跳包），服务器回复Pong。

WebSocket++支持发送Ping帧。我们可以在Manager类中设置一个定时器，定期发送Ping。

// 在OnOpen成功后，启动心跳定时器 void WebSocketClientManager::OnOpen(connection_hdl hdl) { m_is_connected = true; m_reconnectAttempts = 0; // 重置重连计数 PostStatusToUI("连接成功"); StartHeartbeat(); // 开始心跳 } void WebSocketClientManager::StartHeartbeat() { m_heartbeatTimer.expires_after(std::chrono::seconds(30)); // 每30秒一次 m_heartbeatTimer.async_wait([this](const std::error_code& ec) { if (!ec && m_is_connected) { websocketpp::lib::error_code send_ec; m_client.ping(m_connection_hdl, "heartbeat", send_ec); if (send_ec) { // Ping失败，可能连接已失效，触发重连逻辑 PostStatusToUI("心跳发送失败，连接可能已断开"); // 可以在这里主动调用Disconnect，触发OnClose和重连 } else { // 继续下一次心跳 StartHeartbeat(); } } }); }

5.3 消息队列与流量控制

在高频消息场景下（如实时行情），网络线程收到消息的速度可能快于UI线程处理（显示）的速度。直接PostMessage可能会导致消息堆积，最终内存耗尽。

解决方案：引入一个线程安全的队列（如std::queue配合互斥锁和条件变量）。网络线程收到消息后，将其推入队列，然后PostMessage通知UI线程“有新消息”。UI线程在处理自定义消息时，不是只处理一条，而是从队列中批量取出多条（例如最多10条）一起处理、更新UI。这样可以平滑消息流，避免UI卡顿。

5.4 资源清理与程序退出

程序退出时，必须确保网络线程安全结束。对话框的OnDestroy或OnClose事件中，需要先调用m_wsManager.Disconnect()，然后等待网络线程结束（join）。我们在管理器的析构函数中已经做了这个工作，但确保对话框关闭时能调用到析构函数是关键。最好在OnCancel或OnClose中显式调用Disconnect。

void CMfcWebsocketClientDlg::OnClose() { // 确保断开连接并停止网络线程 m_wsManager.Disconnect(); CDialogEx::OnClose(); }

6. 常见问题与调试技巧

在实际集成和开发过程中，你肯定会遇到各种问题。这里记录几个我踩过的坑和解决方法。

6.1 编译错误：“无法打开包括文件: ‘asio.hpp’”

问题：配置包含目录时路径不对。WebSocket++自带的Asio头文件路径是websocketpp/vendor/asio/asio/include，确保你的附加包含目录正确指向了third_party\websocketpp\vendor\asio\asio\include，而不是third_party\websocketpp或third_party。

6.2 运行时崩溃：访问冲突（Access Violation）

问题：最常见的原因是在错误的线程中操作了MFC对象。例如，在WebSocket++的网络回调函数（运行在网络线程）中，直接调用了SetDlgItemText或操作了CString等MFC/ATL对象。这些对象不是线程安全的。解决：严格遵守“网络线程只发消息，UI线程处理消息并更新界面”的原则。所有对UI的更新，必须通过PostMessage到主窗口，在主窗口的消息处理函数中执行。

6.3 连接失败，错误码10060或10061

问题：10060是连接超时，10061是连接被拒绝。

10060：检查服务器地址和端口是否正确，服务器是否真的在运行，以及客户端网络是否能访问到服务器。
10061：服务器端口未监听。确保你的WebSocket服务器程序已经启动并在指定端口监听。可以用浏览器插件（如“Simple WebSocket Client”）或命令行工具（如wscat）先测试服务器是否正常。

6.4 程序退出时卡住或报错

问题：网络线程没有正确结束。io_context->run()是阻塞调用，如果还有异步操作未完成（比如定时器、未关闭的连接），线程就不会退出。解决：

在Disconnect函数中，确保调用了m_client.close()关闭WebSocket连接。
在管理器的析构函数中，先调用Disconnect，然后调用m_io_context->stop()，最后再join网络线程。顺序很重要。
检查是否所有Asio的定时器（如心跳、重连定时器）在不需要时都正确取消了（cancel()）。

6.5 如何调试WebSocket通信内容？

方法：

启用WebSocket++日志：在管理器构造函数中，不要clear_access_channels，或者设置更多的日志级别，如m_client.set_access_channels(websocketpp::log::alevel::all);。日志会输出到控制台（如果项目是控制台程序）或VS的输出窗口。注意，生产环境要关闭详细日志。
使用抓包工具：最有效的是Wireshark。它可以过滤WebSocket流量（ws或wss），直接查看握手过程和每一帧的数据，对于排查协议层面的问题（如握手失败、掩码键错误）非常有用。
使用现成的测试服务器：在开发初期，使用公网的WebSocket Echo服务器（如ws://echo.websocket.org）来验证你的客户端基本功能是否正确，排除服务器端的问题。

6.6 如何处理WSS（SSL/TLS加密连接）？

WebSocket++支持SSL。你需要：

使用websocketpp::config::asio_tls_client作为模板参数。
链接OpenSSL库（libeay32.lib,ssleay32.lib）。
在连接前，可能需要配置SSL上下文（如忽略证书验证用于测试）。这会让配置复杂一些，但流程与非SSL基本一致。对于内部系统或可信环境，初期可以先使用WS（非加密）简化开发。

将WebSocket引入MFC，就像是给一辆可靠的旧卡车装上了卫星导航和实时通信系统。它没有改变MFC作为UI框架的本质，却极大地扩展了其能力边界，让你能轻松应对现代化的实时数据交互需求。这套架构——分离的网络线程、基于消息的UI更新、稳定的重连和心跳——是一个经过实践检验的模式，你可以在此基础上，根据具体业务需求，增加消息编解码（如JSON、Protobuf）、连接池管理、更复杂的UI交互等功能。希望这份详细的介绍和完整的源码能为你节省大量摸索的时间，让你能更专注于业务逻辑的实现。

查看全文

http://www.cnnetsun.cn/news/3675445.html