C++?BoostAsyncSocket實現(xiàn)異步反彈通信的案例詳解
更新時間：2023年03月17日 11:35:19 作者：lyshark
這篇文章主要為大家詳細介紹了C++?BoostAsyncSocket如何實現(xiàn)異步反彈通信，文中的示例代碼講解詳細，具有一定的學習價值，感興趣的可以了解一下
Boost 利用ASIO框架實現(xiàn)一個跨平臺的反向遠控程序，該遠控支持保存套接字，當有套接字連入時，自動存儲到map容器，當客戶下線時自動從map容器中移除，當我們需要與特定客戶端通信時，只需要指定客戶端ID號即可。
AsyncTcpServer
服務端首先定義CEventHandler類并繼承自CAsyncTcpServer::IEventHandler接口，該類內需要我們實現(xiàn)三個方法，方法ClientConnected用于在客戶端連接時觸發(fā)，方法ClientDisconnect則是在登錄客戶端離開時觸發(fā)，而當客戶端有數(shù)據(jù)發(fā)送過來時則ReceiveData方法則會被觸發(fā)。
方法ClientConnected當被觸發(fā)時自動將clientId客戶端Socket套接字放入到tcp_client_id全局容器內存儲起來，而當ClientDisconnect客戶端退出時，則直接遍歷這個迭代容器，找到序列號并通過tcp_client_id.erase將其剔除；
// 客戶端連接時觸發(fā)
virtual void ClientConnected(int clientId)
{
// 將登錄客戶端加入到容器中
tcp_client_id.push_back(clientId);
}
// 客戶端退出時觸發(fā)
virtual void ClientDisconnect(int clientId)
{
// 將登出的客戶端從容器中移除
vector<int>::iterator item = find(tcp_client_id.begin(), tcp_client_id.end(), clientId);
if (item != tcp_client_id.cend())
tcp_client_id.erase(item);
}
而ReceiveData一旦收到數(shù)據(jù)，則直接將其打印輸出到屏幕，即可實現(xiàn)客戶端參數(shù)接收的目的；
// 客戶端獲取數(shù)據(jù)
virtual void ReceiveData(int clientId, const BYTE* data, size_t length)
{
std::cout << std::endl;
PrintLine(80);
std::cout << data << std::endl;
PrintLine(80);
std::cout << "[Shell] # ";
}
相對于接收數(shù)據(jù)而言，發(fā)送數(shù)據(jù)則是通過同步的方式進行，當我們需要發(fā)送數(shù)據(jù)時，只需要將數(shù)據(jù)字符串放入到一個BYTE*字節(jié)數(shù)組中，并在調用tcpServer.Send時將所需參數(shù)，套接字ID，緩沖區(qū)Buf數(shù)據(jù)，以及長度傳遞即可實現(xiàn)將數(shù)據(jù)發(fā)送給指定的客戶端；
// 同步發(fā)送數(shù)據(jù)到指定的線程中
void send_message(CAsyncTcpServer& tcpServer, int clientId, std::string message, int message_size)
{
// 獲取長度
BYTE* buf = new BYTE(message_size + 1);
memset(buf, 0, message_size + 1);
for (int i = 0; i < message_size; i++)
{
buf[i] = message.at(i);
}
tcpServer.Send(clientId, buf, message_size);
}
AsyncTcpClient
客戶端首先我們封裝實現(xiàn)AsyncConnect類，該類內主要實現(xiàn)兩個功能，其中aysnc_connect方法用于實現(xiàn)異步連接到服務端，而port_is_open方法則用于驗證服務器特定端口是否開放，在調用boost::bind綁定套接字時傳入&AsyncConnect::timer_handle設置一個超時等待時間。
進入到main主函數(shù)中，通過while循環(huán)讓程序可以一直運行下去，并通過hander.aysnc_connect(ep, 5000) 每隔5秒驗證是否連接成功，如果連接了則進入內循環(huán)，通過hander.port_is_open("127.0.0.1", 10000, 5000)驗證端口是否開放，這主要是為了保證服務端斷開后客戶端依然能夠跳轉到外部循環(huán)繼續(xù)等待服務端上線。
案例演示
首先運行服務端程序，接著運行多個客戶端，即可實現(xiàn)自動上線；
當用戶需要通信時，只需要指定id序號到指定的Socket套接字編號即可；
源代碼
服務端代碼
// 署名權
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com
#include "AsyncTcpServer.h"
#include <string>
#include <vector>
#include <iostream>
#include <boost/tokenizer.hpp>
using namespace std;
// 存儲當前客戶端的ID號
std::vector<int> tcp_client_id;
// 輸出特定長度的行
void PrintLine(int line)
{
for (int x = 0; x < line; x++)
{
printf("-");
}
printf("\n");
}
class CEventHandler : public CAsyncTcpServer::IEventHandler
{
public:
// 客戶端連接時觸發(fā)
virtual void ClientConnected(int clientId)
{
// 將登錄客戶端加入到容器中
tcp_client_id.push_back(clientId);
}
// 客戶端退出時觸發(fā)
virtual void ClientDisconnect(int clientId)
{
// 將登出的客戶端從容器中移除
vector<int>::iterator item = find(tcp_client_id.begin(), tcp_client_id.end(), clientId);
if (item != tcp_client_id.cend())
tcp_client_id.erase(item);
}
// 客戶端獲取數(shù)據(jù)
virtual void ReceiveData(int clientId, const BYTE* data, size_t length)
{
std::cout << std::endl;
PrintLine(80);
std::cout << data << std::endl;
PrintLine(80);
std::cout << "[Shell] # ";
}
};
// 同步發(fā)送數(shù)據(jù)到指定的線程中
void send_message(CAsyncTcpServer& tcpServer, int clientId, std::string message, int message_size)
{
// 獲取長度
BYTE* buf = new BYTE(message_size + 1);
memset(buf, 0, message_size + 1);
for (int i = 0; i < message_size; i++)
{
buf[i] = message.at(i);
}
tcpServer.Send(clientId, buf, message_size);
}
int main(int argc, char* argv[])
{
CAsyncTcpServer tcpServer(10, 10000);
CEventHandler eventHandler;
tcpServer.AddEventHandler(&eventHandler);
std::string command;
while (1)
{
std::cout << "[Shell] # ";
std::getline(std::cin, command);
if (command.length() == 0)
{
continue;
}
else if (command == "help")
{
printf(" _ ____ _ _ \n");
printf("| | _ _ / ___| ___ ___| | _____| |_ \n");
printf("| | | | | | \\___ \\ / _ \\ / __| |/ / _ \\ __| \n");
printf("| |__| |_| | ___) | (_) | (__| < __/ |_ \n");
printf("|_____\\__, | |____/ \\___/ \\___|_|\\_\\___|\\__| \n");
printf(" |___/ \n\n");
printf("Usage: LySocket \t PowerBy: LyShark.com \n");
printf("Optional: \n\n");
printf("\t ShowSocket 輸出所有Socket容器 \n");
printf("\t GetCPU 獲取CPU數(shù)據(jù) \n");
printf("\t GetMemory 獲取內存數(shù)據(jù) \n");
printf("\t Exit 退出客戶端 \n\n");
}
else
{
// 定義分詞器: 定義分割符號為[逗號,空格]
boost::char_separator<char> sep(", --");
typedef boost::tokenizer<boost::char_separator<char>> CustonTokenizer;
CustonTokenizer tok(command, sep);
// 將分詞結果放入vector鏈表
std::vector<std::string> vecSegTag;
for (CustonTokenizer::iterator beg = tok.begin(); beg != tok.end(); ++beg)
{
vecSegTag.push_back(*beg);
}
// 解析 [shell] # ShowSocket
if (vecSegTag.size() == 1 && vecSegTag[0] == "ShowSocket")
{
PrintLine(80);
printf("客戶ID \t 客戶IP地址 \t 客戶端口 \n");
PrintLine(80);
for (int x = 0; x < tcp_client_id.size(); x++)
{
std::cout << tcp_client_id[x] << " \t "
<< tcpServer.GetRemoteAddress(tcp_client_id[x]) << " \t "
<< tcpServer.GetRemotePort(tcp_client_id[x]) << std::endl;
}
PrintLine(80);
}
// 解析 [shell] # GetCPU --id 100
if (vecSegTag.size() == 3 && vecSegTag[0] == "GetCPU")
{
char *id = (char *)vecSegTag[2].c_str();
send_message(tcpServer, atoi(id), "GetCPU", strlen("GetCPU"));
}
// 解析 [shell] # GetMemory --id 100
if (vecSegTag.size() == 3 && vecSegTag[0] == "GetMemory")
{
char* id = (char*)vecSegTag[2].c_str();
send_message(tcpServer, atoi(id), "GetMEM", strlen("GetMEM"));
}
// 解析 [shell] # Exit --id 100
if (vecSegTag.size() == 3 && vecSegTag[0] == "Exit")
{
char* id = (char*)vecSegTag[2].c_str();
send_message(tcpServer, atoi(id), "Exit", strlen("Exit"));
}
}
}
return 0;
}
客戶端代碼
// 署名權
// right to sign one's name on a piece of work
// PowerBy: LyShark
// Email: me@lyshark.com
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#include <iostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/array.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <boost/noncopyable.hpp>
using namespace std;
using boost::asio::ip::tcp;
// 異步連接地址與端口
class AsyncConnect
{
public:
AsyncConnect(boost::asio::io_service& ios, tcp::socket &s)
:io_service_(ios), timer_(ios), socket_(s) {}
// 異步連接
bool aysnc_connect(const tcp::endpoint &ep, int million_seconds)
{
bool connect_success = false;
// 異步連接,當連接成功后將觸發(fā) connect_handle 函數(shù)
socket_.async_connect(ep, boost::bind(&AsyncConnect::connect_handle, this, _1, boost::ref(connect_success)));
// 設置一個定時器 million_seconds
timer_.expires_from_now(boost::posix_time::milliseconds(million_seconds));
bool timeout = false;
// 異步等待 如果超時則執(zhí)行 timer_handle
timer_.async_wait(boost::bind(&AsyncConnect::timer_handle, this, _1, boost::ref(timeout)));
do
{
// 等待異步操作完成
io_service_.run_one();
// 判斷如果timeout沒超時,或者是連接建立了,則不再等待
} while (!timeout && !connect_success);
timer_.cancel();
return connect_success;
}
// 驗證服務器端口是否開放
bool port_is_open(std::string address, int port, int timeout)
{
try
{
boost::asio::io_service io;
tcp::socket socket(io);
AsyncConnect hander(io, socket);
tcp::endpoint ep(boost::asio::ip::address::from_string(address), port);
if (hander.aysnc_connect(ep, timeout))
{
io.run();
io.reset();
return true;
}
else
{
return false;
}
}
catch (...)
{
return false;
}
}
private:
// 如果連接成功了,則 connect_success = true
void connect_handle(boost::system::error_code ec, bool &connect_success)
{
if (!ec)
{
connect_success = true;
}
}
// 定時器超時timeout = true
void timer_handle(boost::system::error_code ec, bool &timeout)
{
if (!ec)
{
socket_.close();
timeout = true;
}
}
boost::asio::io_service &io_service_;
boost::asio::deadline_timer timer_;
tcp::socket &socket_;
};
int main(int argc, char * argv[])
{
try
{
boost::asio::io_service io;
tcp::socket socket(io);
AsyncConnect hander(io, socket);
boost::system::error_code error;
tcp::endpoint ep(boost::asio::ip::address::from_string("127.0.0.1"), 10000);
// 循環(huán)驗證是否在線
go_: while (1)
{
// 驗證是否連接成功,并定義超時時間為5秒
if (hander.aysnc_connect(ep, 5000))
{
io.run();
std::cout << "已連接到服務端." << std::endl;
// 循環(huán)接收命令
while (1)
{
// 驗證地址端口是否開放,默認等待5秒
bool is_open = hander.port_is_open("127.0.0.1", 10000, 5000);
// 客戶端接收數(shù)據(jù)包
boost::array<char, 4096> buffer = { 0 };
// 如果在線則繼續(xù)執(zhí)行
if (is_open == true)
{
socket.read_some(boost::asio::buffer(buffer), error);
// 判斷收到的命令是否為GetCPU
if (strncmp(buffer.data(), "GetCPU", strlen("GetCPU")) == 0)
{
std::cout << "獲取CPU參數(shù)并返回給服務端." << std::endl;
socket.write_some(boost::asio::buffer("CPU: 15 %"));
}
// 判斷收到的命令是否為GetMEM
if (strncmp(buffer.data(), "GetMEM", strlen("GetMEM")) == 0)
{
std::cout << "獲取MEM參數(shù)并返回給服務端." << std::endl;
socket.write_some(boost::asio::buffer("MEM: 78 %"));
}
// 判斷收到的命令是否為終止程序
if (strncmp(buffer.data(), "Exit", strlen("Exit")) == 0)
{
std::cout << "終止客戶端." << std::endl;
return 0;
}
}
else
{
// 如果連接失敗,則跳轉到等待環(huán)節(jié)
goto go_;
}
}
}
else
{
std::cout << "連接失敗,正在重新連接." << std::endl;
}
}
}
catch (...)
{
return false;
}
std::system("pause");
return 0;
}
項目地址
https://github.com/lyshark/BoostAsyncSocket
到此這篇關于C++ BoostAsyncSocket實現(xiàn)異步反彈通信的案例詳解的文章就介紹到這了,更多相關C++ BoostAsyncSocket異步反彈通信內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
這篇文章主要為大家詳細介紹了C語實現(xiàn)猜數(shù)字小項目，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-01-01
這篇文章主要介紹了C++實現(xiàn)判斷字符串是否回文,其中采用了數(shù)據(jù)結構中棧以及過濾字符等技術,,需要的朋友可以參考下2014-07-07
這篇文章主要介紹了CLion開發(fā)stm32?使用DSP庫的方法,首先需要添加DSP庫文件到工程目錄，修改CMakeLists，添加STM32HAL庫，本文結合實例代碼給大家介紹的非常詳細，需要的朋友可以參考下2022-09-09
在Windows上實現(xiàn)錄音比較簡單的方法是使用winmm,其中的waveIn模塊就可以打開錄音設備,這篇文章主要為大家介紹了C++如何使用waveIn實現(xiàn)聲音采集,需要的可以了解下2023-10-10
這篇文章主要為大家介紹了C語言教程之數(shù)組，具有一定的參考價值，感興趣的小伙伴們可以參考一下，希望能夠給你帶來幫助2022-01-01
這篇文章主要為大家詳細介紹了C語言實現(xiàn)個稅計算器，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-10-10
這篇文章主要為大家詳細介紹了C++如何調用matlab引擎實現(xiàn)三維圖的繪制，文中的示例代碼講解詳細，對我們學習C++和Matlab有一定的幫助，需要的可以參考一下2022-12-12
這篇文章主要介紹了C++98/11/17表達式類別，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2020-05-05
這篇文章主要為大家詳細介紹了如何使用紅黑樹封裝set和map，且必須保證兩種數(shù)據(jù)結構復用同一棵紅黑樹，且滿足set和map的性質，set的value不可被改變，而map的value可以被改變，需要的可以參考一下2023-03-03
這篇文章主要介紹了C++語言中的加法運算符與賦值運算符的用法,是C++入門學習中的基礎知識,需要的朋友可以參考下2016-01-01