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

DWQY

发布时间 2024.02.10阅读数 432 评论数 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);
        static void initlization(std::string IP);
        static void initlization1(std::string IP);
};
#endif

服务端——server.cpp

#include "server.h"

std::string send_message("server to client");

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) {
    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");
        }));
        ws.accept();//等待客户端连接
        for (;;)
        {
            if (send_message != "")
                ws.write(net::buffer(ansi_to_utf8(send_message)));

            beast::flat_buffer buffer;// 这个缓冲区将保存传入的消息
            ws.read(buffer);// 读取一条消息
            auto out = beast::buffers_to_string(buffer.cdata());
            if (out != "") {
                std::cout << utf8_to_ansi(out) << std::endl;
            }
            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 } };
        for (;;)
        {
            tcp::socket socket{ ioc };
            acceptor.accept(socket);
            // 开启线程等待客户端的连接请求
            std::thread{ std::bind(&do_session,std::move(socket)) }.detach();
        }
    }
    catch (const std::exception & e) {
        std::cerr << "Error: " << e.what() << std::endl;
        return ;
    }
}

客户端调用——main_client.cpp

#include "client.h"

Client client1_listen;
Client client1_send;
Client client;
std::string listen_message = "";
std::string IP_server("192.168.1.116");
std::string send_message("client to server");
const char *port = "20000";

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

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

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

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

服务端调用——main_server.cpp

#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;
}

执行步骤

g++ main_client.cpp client.cpp client.h -o client -std=c++11 -lpthread
g++ main_server.cpp server.cpp server.h -o server -std=c++11 -lpthread

必须先server再client
./server
./client

收发使用20000端口(可自行更改)

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

转载原出处：

打赏 0

上一篇：C++实现websocket两server两client半双工通信(基于boost！！！)

下一篇：MQTT传输JSON数据实例

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

DWQY

环境配置

示例源码

客户端——client.h

客户端——client.cpp

服务端——server.h

服务端——server.cpp

客户端调用——main_client.cpp

服务端调用——main_server.cpp

执行步骤

为你推荐

【Spring源码】SpringBoot中Spring容器bean的创建与刷新

处女篇

精选Linux系统下imx6ull QT编程—— C++类和对象（三）

用树莓派+Python+OpenCV制作计算机视觉机器人2

精选Psins代码解析之粗对准(test_align_methods_compare.m)&精对准

概率基础：贝叶斯滤波

评论（0）

关于作者

DWQY

42

0

300

2

（九）演员-评论员算法

Intel Realsense D435i各类标定教程

（九）演员-评论员算法

相关推荐

无人机飞行模式（Ardupilot和MAVLink协议）（STABILIZE、ALTITUDE HOLD、LOITER、GUIDE、AUTO、LAND、RTL）

5.MySQL匹配条件和操作查询结果

【STM32】SPI 实验代码详解

【Spring源码】SpringBoot默认组件扫描

第三讲：三维空间的刚体运动

Pytorch张量升维

热门泡泡

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

ros学习路线

30积分 TF_REPEATED_DATA ignoring data错误

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

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

5积分 ros中启动gazebo时报错

给作者打赏

忘记密码

修改头像

添加你感兴趣的标签

举报类型（必选）

举报详情（选填）

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

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