精选C++实现websocket两server两client半双工通信(基于boost！！！)

DWQY

发布时间 2024.02.09阅读数 393 评论数 0

自身环境：ubuntu18.04+gcc7.5.0+boost1.7,3

环境配置

gcc或者g++一般都有，这里主要介绍一下boost的配置方法
执行如下代码：

wget https://boostorg.jfrog.io/artifactory/main/release/1.73.0/source/boost_1_73_0.tar.bz2 --no-check-certificate
tar xvf boost_1_73_0.tar.bz2
cd boost_1_73_0
./bootstrap.sh --prefix=/usr 
./b2 
sudo ./b2 install
cat /usr/include/boost/version.hpp | grep "BOOST_LIB_VERSION"

装完后发现还是会报错：#include ＜boost/beast/core.hpp＞ no such file
这个时候再加一个：

sudo apt-get install libboost-all-dev

然后编译执行代码就可以了，在这里说明下我不太确定是否要执行那个apt-get，理论上前面是源码编译就没问题了，后面估计是默认库的安装，但是我当时没太注意顺序，两个都做了一下才成功、
boost安装参考：https://blog.csdn.net/HandsomeHong/article/details/128813619

顺道提一下Linux下查看boost的版本方法：

dpkg -S /usr/include/boost/version.hpp

示例源码

客户端——client.h

#ifndef WEBSOCKET_CLIENT_H
#define WEBSOCKET_CLIENT_H
#include <boost/beast/core.hpp>
#include <boost/beast/websocket.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#include <thread>
#include <codecvt>
#include <wchar.h>
#include <locale.h>
#include <stdlib.h>

namespace beast = boost::beast;         // from <boost/beast.hpp>
namespace http = beast::http;           // from <boost/beast/http.hpp>
namespace websocket = beast::websocket; // from <boost/beast/websocket.hpp>
namespace net = boost::asio;            // from <boost/asio.hpp>
using tcp = boost::asio::ip::tcp;       // from <boost/asio/ip/tcp.hpp>

class Client {
    public:
        static std::wstring string_to_wstring(const std::string& str);
        static std::string wstring_to_string(const std::wstring& ws);
        static std::string ansi_to_utf8(const std::string& s);
        static std::string utf8_to_ansi(const std::string& s);
        static void connect(std::string IP, const char *port_s);
        static void send(std::string message);
        static void listen(std::string &out);
        static void disconnect();
};

#endif

客户端——client.cpp

#include "client.h"

namespace beast = boost::beast;         // from <boost/beast.hpp>
namespace http = beast::http;           // from <boost/beast/http.hpp>
namespace websocket = beast::websocket; // from <boost/beast/websocket.hpp>
namespace net = boost::asio;            // from <boost/asio.hpp>
using tcp = boost::asio::ip::tcp;       // from <boost/asio/ip/tcp.hpp>

net::io_context ioc;
tcp::resolver resolver{ ioc };
websocket::stream<tcp::socket> ws{ ioc };

std::wstring Client::string_to_wstring(const std::string& str) {
    std::wstring r;
    const char *source = str.c_str();
    wchar_t *dest = NULL;
    int len = 0;
    int ret = 0;
    len = strlen(source) + 1;
    if(len <= 1)
        return 0;
    dest = new wchar_t[len];
    ret = mbstowcs(dest, source, len);
    r = std::wstring(dest);
    delete[] dest;
    return r;
}

std::string Client::wstring_to_string(const std::wstring& ws) {
    std::string r = "";
    const wchar_t *source = ws.c_str();
    char *dest = NULL;
    int len = 0;
    int ret = 0;
    len = wcslen(source) + 1;
    if(len <= 1)
        return 0;
    dest = new char[len*sizeof(wchar_t)];
    ret = wcstombs(dest, source, len*sizeof(wchar_t));
    r = std::string(dest);
    delete[] dest;
    return r;
}

std::string Client::ansi_to_utf8(const std::string& s) {
    static std::wstring_convert<std::codecvt_utf8<wchar_t> > conv;
    return conv.to_bytes(string_to_wstring(s));
}

std::string Client::utf8_to_ansi(const std::string& s) {
    static std::wstring_convert<std::codecvt_utf8<wchar_t> > conv;
    return wstring_to_string(conv.from_bytes(s));
}

void Client::connect(std::string IP, const char *port_s) {
    try {
        auto const address = net::ip::make_address(IP); //服务器地址
        auto const port = static_cast<unsigned short>(std::atoi(port_s));//服务器端口号
        tcp::endpoint endpoint{ address, port };
        auto const results = resolver.resolve(endpoint);
        // 在我们从查找中获得的IP地址上建立连接
        net::connect(ws.next_layer(), results.begin(), results.end());
        ws.set_option(websocket::stream_base::decorator(
            [](websocket::request_type& req)
        {
            req.set(http::field::user_agent,
                std::string(BOOST_BEAST_VERSION_STRING) +
                " websocket-client-coro");
        }));
        std::cout << "The port is:" << port_s << std::endl;
        ws.handshake(IP, "/"); //发送握手消息
        std::cout << "The port:" << port_s << " finish!" << std::endl;
    }    
    catch (std::exception const& e)
    {
        std::cerr << "Error: " << e.what() << std::endl;
        return  ;
    }
}

void Client::send(std::string message) {
    while (1) {
        //std::cout << "log:" << message << std::endl;
        ws.write(net::buffer(ansi_to_utf8(message)));
        sleep(1);
    }
}

void Client::listen(std::string &out) {
    while (1) {
        beast::flat_buffer buffer;//创建一个缓冲区用于存放接收到的消息    
        ws.read(buffer);// 读取一条消息到缓冲区
        out = beast::buffers_to_string(buffer.cdata());
        //std::cout << utf8_to_ansi(out) << std::endl; //输出消息到控制台显示
    }
}

void Client::disconnect() {
    ws.close(websocket::close_code::normal);// 关闭WebSocket连接
}

服务端——server.h

#ifndef WEBSOCKET_SERVER_H
#define WEBSOCKET_SERVER_H
#include <boost/beast/core.hpp>
#include <boost/beast/websocket.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <thread>
#include <codecvt>
#include <wchar.h>
#include <locale.h>
namespace beast = boost::beast;         // from <boost/beast.hpp>
namespace http = beast::http;           // from <boost/beast/http.hpp>
namespace websocket = beast::websocket; // from <boost/beast/websocket.hpp>
namespace net = boost::asio;            // from <boost/asio.hpp>
using tcp = boost::asio::ip::tcp;       // from <boost/asio/ip/tcp.hpp>

class Server {
    public:
        static std::wstring string_to_wstring(const std::string& str);
        static std::string wstring_to_string(const std::wstring& ws);
        static std::string ansi_to_utf8(const std::string& s);
        static std::string utf8_to_ansi(const std::string& s);
        static void do_session(tcp::socket& socket, tcp::socket& socket1);
        static void initlization(std::string IP);
        static void initlization1(std::string IP);
};
#endif

服务端——server.cpp

#include "server.h"

std::wstring Server::string_to_wstring(const std::string& str) {
    std::wstring r;
    const char *source = str.c_str();
    wchar_t *dest = NULL;
    int len = 0;
    int ret = 0;
    len = strlen(source) + 1;
    if(len <= 1)
        return 0;
    dest = new wchar_t[len];
    ret = mbstowcs(dest, source, len);
    r = std::wstring(dest);
    delete[] dest;
    return r;
}

std::string Server::wstring_to_string(const std::wstring& ws) {
    std::string r = "";
    const wchar_t *source = ws.c_str();
    char *dest = NULL;
    int len = 0;
    int ret = 0;
    len = wcslen(source) + 1;
    if(len <= 1)
        return 0;
    dest = new char[len*sizeof(wchar_t)];
    ret = wcstombs(dest, source, len*sizeof(wchar_t));
    r = std::string(dest);
    delete[] dest;
    return r;
}

std::string Server::ansi_to_utf8(const std::string& s) {
    static std::wstring_convert<std::codecvt_utf8<wchar_t> > conv;
    return conv.to_bytes(string_to_wstring(s));
}

std::string Server::utf8_to_ansi(const std::string& s) {
    static std::wstring_convert<std::codecvt_utf8<wchar_t> > conv;
    return wstring_to_string(conv.from_bytes(s));
}

// socket 20000  socket1 19999
void Server::do_session(tcp::socket& socket, tcp::socket& socket1) {
    try
    {
        websocket::stream<tcp::socket> ws{ std::move(socket) };
        ws.set_option(websocket::stream_base::decorator(
            [](websocket::response_type& res)
        {
            res.set(http::field::server,
                std::string(BOOST_BEAST_VERSION_STRING) +
                " websocket-server-sync");
        }));
        websocket::stream<tcp::socket> ws1{ std::move(socket1) };
        ws1.set_option(websocket::stream_base::decorator(
            [](websocket::response_type& res)
        {
            res.set(http::field::server,
                std::string(BOOST_BEAST_VERSION_STRING) +
                " websocket-server-sync");
        }));
        ws.accept();//等待客户端连接
        ws1.accept();
        for (;;)
        {
            beast::flat_buffer buffer;// 这个缓冲区将保存传入的消息
            ws.read(buffer);// 读取一条消息
            auto out = beast::buffers_to_string(buffer.cdata());
            if (out != "") {
                ws1.write(net::buffer(ansi_to_utf8(out)));// 发送消息
            }
            sleep(1); //等待1秒
        }
    }
    catch (beast::system_error const& se)
    {
        if (se.code() != websocket::error::closed)
            std::cerr << "Error: " << se.code().message() << std::endl;
    }
    catch (std::exception const& e)
    {
        std::cerr << "Error: " << e.what() << std::endl;
    }
}
// socket 19999  socket1 20000
// void Server::do_session1(tcp::socket& socket, tcp::socket& socket1) {
//     try
//     {
//         websocket::stream<tcp::socket> ws{ std::move(socket) };
//         ws.set_option(websocket::stream_base::decorator(
//             [](websocket::response_type& res)
//         {
//             res.set(http::field::server,
//                 std::string(BOOST_BEAST_VERSION_STRING) +
//                 " websocket-server-sync");
//         }));
//         websocket::stream<tcp::socket> ws1{ std::move(socket1) };
//         ws1.set_option(websocket::stream_base::decorator(
//             [](websocket::response_type& res)
//         {
//             res.set(http::field::server,
//                 std::string(BOOST_BEAST_VERSION_STRING) +
//                 " websocket-server-sync");
//         }));
//         ws.accept();//等待客户端连接
//         ws1.accept();
//         for (;;)
//         {
//             beast::flat_buffer buffer;// 这个缓冲区将保存传入的消息
//             ws.read(buffer);// 读取一条消息
//             auto out = beast::buffers_to_string(buffer.cdata());
//             if (out != "") {
//                 ws1.write(net::buffer(ansi_to_utf8(out)));// 发送消息
//             }
//             sleep(1); //等待1秒
//         }
//     }
//     catch (beast::system_error const& se)
//     {
//         if (se.code() != websocket::error::closed)
//             std::cerr << "Error: " << se.code().message() << std::endl;
//     }
//     catch (std::exception const& e)
//     {
//         std::cerr << "Error: " << e.what() << std::endl;
//     }
// }

void Server::initlization(std::string IP) {
    try
    {
        auto const address = net::ip::make_address(IP);//绑定ip地址
        auto const port = static_cast<unsigned short>(std::atoi("20000"));//绑定端口号
        net::io_context ioc{ 1 };
        tcp::acceptor acceptor{ ioc,{ address, port } };
        auto const address1 = net::ip::make_address(IP);//绑定ip地址
        auto const port1 = static_cast<unsigned short>(std::atoi("19999"));//绑定端口号
        tcp::acceptor acceptor1{ ioc,{ address1, port1 } };
        for (;;)
        {
            tcp::socket socket{ ioc };
            acceptor.accept(socket);
            tcp::socket socket1{ ioc };
            acceptor1.accept(socket1);
            // 开启线程等待客户端的连接请求
            std::thread{ std::bind(&do_session,std::move(socket), std::move(socket1)) }.detach();
        }
    }
    catch (const std::exception & e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return ;
    }
}

void Server::initlization1(std::string IP) {
    try
    {
        auto const address = net::ip::make_address(IP);//绑定ip地址
        auto const port = static_cast<unsigned short>(std::atoi("8888"));//绑定端口号
        net::io_context ioc{ 1 };
        tcp::acceptor acceptor{ ioc,{ address, port } };
        auto const address1 = net::ip::make_address(IP);//绑定ip地址
        auto const port1 = static_cast<unsigned short>(std::atoi("7777"));//绑定端口号
        tcp::acceptor acceptor1{ ioc,{ address1, port1 } };
        for (;;)
        {
            tcp::socket socket{ ioc };
            acceptor.accept(socket);
            tcp::socket socket1{ ioc };
            acceptor1.accept(socket1);
            // 开启线程等待客户端的连接请求
            std::thread{ std::bind(&do_session,std::move(socket), std::move(socket1)) }.detach();
        }
    }
    catch (const std::exception & e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return ;
    }
}

客户端调用——客户1

#include "client.h"

Client client1_listen;
Client client1_send;
std::string listen_message = "";
std::string IP_server("192.168.1.116");
std::string send_message("client1 to client2");
const char *port_client1_send = "20000";
const char *port_client1_listen = "7777";

void listenThread() {
    client1_listen.connect(IP_server, port_client1_listen);  
    client1_listen.listen(listen_message);
}

void sendThread() {
    client1_send.connect(IP_server, port_client1_send);
    client1_send.send(send_message);
}

void outputThread() {
    while (1) {
        if (listen_message != "") {
            std::cout << listen_message << std::endl;
        }
        sleep(1);
    }
}

int main() { 
    std::thread sendThreadObj(sendThread);
    std::thread listenThreadObj(listenThread);
    std::thread outputThreadObj(outputThread);
    listenThreadObj.join();
    sendThreadObj.join();
    outputThreadObj.join();
    return 0;
}

客户端调用——客户2

#include "client.h"

Client client2_listen;
Client client2_send;
std::string listen_message = "";
std::string send_message("client2 to client1");
std::string IP_server("192.168.1.116");
const char *port_client2_send = "8888";
const char *port_client2_listen = "19999";

void listenThread() {
    client2_listen.connect(IP_server, port_client2_listen); 
    client2_listen.listen(listen_message);
}

void sendThread() {
    client2_send.connect(IP_server, port_client2_send);
    client2_send.send(send_message);
}

void outputThread() {
    while (1) {
        if (listen_message != "") {
            std::cout << listen_message << std::endl;
        }
        sleep(1);
    }
}

int main() { 
    std::thread sendThreadObj(sendThread);
    std::thread listenThreadObj(listenThread);
    std::thread outputThreadObj(outputThread);
    listenThreadObj.join();
    sendThreadObj.join();
    outputThreadObj.join();
    return 0;
}

服务端调用——服务1

#include "server.h"
#include <iostream>
#include <thread>

// 20000      19999
int main() {
    Server server;
    std::string IP("192.168.1.116");
    server.initlization(IP);
    return 0;
}

服务端调用——服务2

#include "server.h"
#include <iostream>
#include <thread>

// 18888 17777
int main() {
    Server server;
    std::string IP("192.168.1.116");
    server.initlization1(IP);
    return 0;
}

操作命令

g++ main_client1.cpp client.cpp client.h -o client1 -std=c++11 -lpthread
g++ main_client2.cpp client.cpp client.h -o client2 -std=c++11 -lpthread

g++ main_server.cpp server.cpp server.h -o server -std=c++11 -lpthread
g++ main_server1.cpp server.cpp server.h -o server1 -std=c++11 -lpthread

必须先server再client
./server
./server1
./client1
./client2

server：端口20000发  端口19999收
server1：端口8888发  端口7777收

websocket C++开发语言 boost配置半双工通信

转载原出处：

打赏 0

上一篇：python实现批量从excel列表显示图片网址中下载图片

下一篇：C++实现websocket单server单client全双工通信(基于boost！！！)

精选C++实现websocket两server两client半双工通信(基于boost！！！)

DWQY

环境配置

示例源码

客户端——client.h

客户端——client.cpp

服务端——server.h

服务端——server.cpp

客户端调用——客户1

客户端调用——客户2

服务端调用——服务1

服务端调用——服务2

操作命令

为你推荐

具有逆运动学的2维轨迹跟踪（翻译--个人学习记录）

精选05-旭日X3派测评——Open Cv &Pangolin等库安装&ORB_SLAM2 安装运行

《视觉SLAM十四讲》 编译报错问题汇总 Ubuntu20.04

小师弟：2022广东省工科赛分享（越障排爆省一，完整项目）

精选C/C++读写文件示例

IMU内参标定以及初始化（9轴IMU，比6轴多三个姿态角信息）

评论（0）

关于作者

DWQY

42

0

300

2

（三）表格型方法

（一）强化学习概述

ROS下用代码指定坐标完成导航任务

相关推荐

C++之文件操作

第四章移动机器人载体

MATLAB —— 曲线拟合

Cerse入门(一)Helloword解析与自动求导

C++之生成器(builder)模式

Arduino极简教程

热门泡泡

30积分 失眠，聊聊自己搞ROS的心得体会吧

ros学习路线

30积分 TF_REPEATED_DATA ignoring data错误

各位大佬，有什么ROS定位算法推荐吗

5积分 想买能用ROS2的开发套件。或者开发板

5积分 ros中启动gazebo时报错

给作者打赏

忘记密码

修改头像

添加你感兴趣的标签

举报类型（必选）

举报详情（选填）

《视觉SLAM十四讲》编译报错问题汇总 Ubuntu20.04

30积分失眠，聊聊自己搞ROS的心得体会吧

5积分想买能用ROS2的开发套件。或者开发板