websocketpp实例

最新推荐文章于 2024-09-17 10:20:03 发布
最新推荐文章于 2024-09-17 10:20:03 发布
阅读量748 收藏 4
点赞数
分类专栏： websocket
原文链接：https://blog.csdn.net/byxdaz/article/details/84769707
版权

//服务端

//WebSocketServerOpreate.h

#pragma once
 
#include <boost/algorithm/string.hpp>
#include <string>
#include <vector>
#include <iostream>
#include <boost/thread.hpp>
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
 
#define			Base_Uri_Length			128
 
//名称与值数据对
struct NameAndValue
{
	std::string strName;
	std::string strValue;
};
 
typedef websocketpp::server<websocketpp::config::asio> server;
 
using websocketpp::lib::placeholders::_1;
using websocketpp::lib::placeholders::_2;
using websocketpp::lib::bind;
 
// pull out the type of messages sent by our config
typedef server::message_ptr message_ptr;
 
 
class WebSocketServerOpreate
{
public:
	WebSocketServerOpreate();
	~WebSocketServerOpreate();
 
	int Init(unsigned short usPort,char *pBaseUri="/ws");
	int Uninit();
	int StartWork();
	int StopWork();
 
protected:
	int ThreadProccess();
	void InsertClientConnection(websocketpp::connection_hdl hdl);
	void DeleteClientConnection(websocketpp::connection_hdl hdl);
 
public:
	bool validate(server *s, websocketpp::connection_hdl hdl);
	void on_http(server* s, websocketpp::connection_hdl hdl);
	void on_fail(server* s, websocketpp::connection_hdl hdl);
	//连接打开回调函数
	void on_open(server* s, websocketpp::connection_hdl hdl);
	//连接关闭回调函数
	void on_close(server *s, websocketpp::connection_hdl hdl);
	//接收websocket数据回调函数
	void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg);
 
public:
	// 字符串分割
	static int StringSplit(std::vector<std::string>& dst, const std::string& src, const std::string& separator);
	//去前后空格
	static std::string& StringTrim(std::string &str);
	//获取请求命令与参数
	static bool GetReqeustCommandAndParmeter(std::string strUri, std::string & strRequestOperateCommand, std::vector<NameAndValue> & listRequestOperateParameter);
 
protected:
	unsigned short m_usPort;
	char m_szBaseUri[Base_Uri_Length];
	server m_server;
	boost::thread * m_threadMain;
	bool m_bThreadExit;
	std::list<websocketpp::connection_hdl> m_listClientConnection;
};

//WebSocketServerOpreate.cpp


```cpp
#include "stdafx.h"
#include "WebSocketServerOpreate.h"
 
#include "jsoncpp/include/json/json.h"
 
#ifdef _DEBUG
#pragma comment(lib,"jsoncpp/lib/debug/lib_json.lib")
#else
#pragma comment(lib,"jsoncpp/lib/release/lib_json.lib")
#endif
 
WebSocketServerOpreate::WebSocketServerOpreate()
{
	m_usPort = 9100;
	memset(m_szBaseUri, 0, sizeof(m_szBaseUri));
	m_bThreadExit = true;
	m_threadMain = NULL;
	m_listClientConnection.clear();
}
 
WebSocketServerOpreate::~WebSocketServerOpreate()
{
	if (m_threadMain != NULL)
	{
		delete m_threadMain;
		m_threadMain = NULL;
	}
}
 
bool WebSocketServerOpreate::validate(server * s, websocketpp::connection_hdl hdl) {
	//sleep(6);
	return true;
}
 
void WebSocketServerOpreate::on_http(server* s, websocketpp::connection_hdl hdl) {
	server::connection_ptr con = s->get_con_from_hdl(hdl);
 
	std::string res = con->get_request_body();
 
	std::stringstream ss;
	ss << "got HTTP request with " << res.size() << " bytes of body data.";
 
	con->set_body(ss.str());
	con->set_status(websocketpp::http::status_code::ok);
}
 
void WebSocketServerOpreate::on_fail(server* s, websocketpp::connection_hdl hdl) {
	server::connection_ptr con = s->get_con_from_hdl(hdl);
 
	std::cout << "Fail handler: " << con->get_ec() << " " << con->get_ec().message() << std::endl;
}
 
void WebSocketServerOpreate::on_open(server* s, websocketpp::connection_hdl hdl) {
	//申请websocket upgrade成功之后，调用open_handler函数，回调on_open。
	//在这里，可以获取http请求的地址、参数信息。
	std::cout << "open handler" << std::endl;
	InsertClientConnection(hdl);
	server::connection_ptr con = s->get_con_from_hdl(hdl);
	websocketpp::config::core::request_type requestClient = con->get_request();
	std::string strMethod = requestClient.get_method();		//请求方法
	std::string strUri = requestClient.get_uri();			//请求uri地址，可以解析参数
	std::string strRequestOperateCommand = "";				//操作类型
	std::vector<NameAndValue> listRequestOperateParameter;	//操作参数列表	
	GetReqeustCommandAndParmeter(strUri, strRequestOperateCommand, listRequestOperateParameter);
	std::cout << "command:" << strRequestOperateCommand << std::endl;
	if (strcmp(strRequestOperateCommand.c_str(), m_szBaseUri) == 0)
	{
		if (listRequestOperateParameter.size() >= 2)
		{
			//验证用户和密码，返回登录结果
			if (strcmp(listRequestOperateParameter[0].strValue.c_str(), "admin") == 0 && strcmp(listRequestOperateParameter[1].strValue.c_str(), "admin") == 0)
			{
				Json::Value root;
				root["operatetype"] = 2;					//操作类型，比如登录、登录应答、注销等
				root["ret"] = 0;
				root["sessionid"] = "1110-1111-9999-3333";
				std::string strLoginResponse = root.toStyledString();
				s->send(hdl, strLoginResponse.c_str(), websocketpp::frame::opcode::TEXT);
			}
			else
			{
				Json::Value root;
				root["operatetype"] = 2;					//操作类型，比如登录、登录应答、注销等
				root["ret"] = 1;
				root["sessionid"] = "";
				std::string strLoginResponse = root.toStyledString();
				s->send(hdl, strLoginResponse.c_str(), websocketpp::frame::opcode::TEXT);
			}
		}
		else
		{
			Json::Value root;
			root["operatetype"] = 2;					//操作类型，比如登录、登录应答、注销等
			root["ret"] = 2;
			root["sessionid"] = "";
			std::string strLoginResponse = root.toStyledString();
			s->send(hdl, strLoginResponse.c_str(), websocketpp::frame::opcode::TEXT);
		}
	}
	else
	{
		//error request
	}
}
 
void WebSocketServerOpreate::on_close(server *s, websocketpp::connection_hdl hdl) {
	std::cout << "Close handler" << std::endl;
	DeleteClientConnection(hdl);
}
 
// Define a callback to handle incoming messages
void WebSocketServerOpreate::on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
	/*
	hdl.lock().get() 获得连接标识
	msg->get_payload() 是收到的消息内容
	msg->get_opcode() 是收到消息的类型 ，包含：文本TEXT,二进制BINARY等等
	*/
	std::cout << "on_message called with hdl: " << hdl.lock().get()
		<< " and message: " << msg->get_payload()
		<< std::endl;
 
	try {
		/*
		发送消息
		s->send(
		hdl, //连接
		msg->get_payload(), //消息
		msg->get_opcode());//消息类型
		*/
		s->send(hdl, msg->get_payload(), msg->get_opcode());
	}
	catch (websocketpp::exception const & e) {
		std::cout << "Echo failed because: "
			<< "(" << e.what() << ")" << std::endl;
	}
}
 
int WebSocketServerOpreate::Init(unsigned short usPort, char *pBaseUri)
{
	int nRet = 0;
	m_usPort = usPort;
	strcpy_s(m_szBaseUri, pBaseUri);
	try {
		// Set logging settings
		m_server.set_access_channels(websocketpp::log::alevel::all);
		m_server.set_error_channels(websocketpp::log::elevel::all);
		//m_server.clear_access_channels(websocketpp::log::alevel::frame_payload);
 
		// Register our message handler
		m_server.set_message_handler(bind(&WebSocketServerOpreate::on_message,this, &m_server, ::_1, ::_2));
		m_server.set_http_handler(bind(&WebSocketServerOpreate::on_http, this, &m_server, ::_1));
		m_server.set_fail_handler(bind(&WebSocketServerOpreate::on_fail, this, &m_server, ::_1));
		m_server.set_open_handler(bind(&WebSocketServerOpreate::on_open, this, &m_server, ::_1));
		m_server.set_close_handler(bind(&WebSocketServerOpreate::on_close, this, &m_server, ::_1));
		m_server.set_validate_handler(bind(&WebSocketServerOpreate::validate, this, &m_server, ::_1));
 
		// Initialize ASIO
		m_server.init_asio();
		m_server.set_reuse_addr(true);
 
		// Listen on port
		m_server.listen(m_usPort);
		// Start the server accept loop
		m_server.start_accept();
	}
	catch (websocketpp::exception const & e) {
		std::cout << e.what() << std::endl;
		nRet = -1;
	}
	catch (const std::exception & e) {
		std::cout << e.what() << std::endl;
		nRet = -2;
	}
	catch (...) {
		std::cout << "other exception" << std::endl;
		nRet = -3;
	}
	
	return nRet;
}
int WebSocketServerOpreate::Uninit()
{
	return 0;
}
int WebSocketServerOpreate::StartWork()
{
	m_bThreadExit = false;
	m_threadMain = new boost::thread(boost::bind(&WebSocketServerOpreate::ThreadProccess, this));
	if (m_threadMain == NULL)
	{
		m_bThreadExit = true;
		return -1;
	}
	else
	{
		return 0;
	}
}
int WebSocketServerOpreate::StopWork()
{
	//stop
	m_bThreadExit = true;
	m_server.stop();
	return 0;
}
 
int WebSocketServerOpreate::ThreadProccess()
{
	while (true)
	{
		if (m_bThreadExit)
		{
			break;
		}
 
		m_server.poll_one();
		Sleep(100);
	}
	return 0;
}
 
void WebSocketServerOpreate::InsertClientConnection(websocketpp::connection_hdl hdl)
{
	m_listClientConnection.push_back(hdl);
}
void WebSocketServerOpreate::DeleteClientConnection(websocketpp::connection_hdl hdl)
{
	std::list<websocketpp::connection_hdl>::iterator iter, iterEnd;
	iter = m_listClientConnection.begin();
	iterEnd = m_listClientConnection.end();
	for (iter; iter != iterEnd; iter++)
	{
		server::connection_ptr conInput = m_server.get_con_from_hdl(hdl);
		server::connection_ptr conSrc = m_server.get_con_from_hdl(*iter);
		if (conInput == conInput)
		{
			m_listClientConnection.erase(iter);
			break;
		}
	}
}
 
// 字符串分割
int WebSocketServerOpreate::StringSplit(std::vector<std::string>& dst, const std::string& src, const std::string& separator)
{
	if (src.empty() || separator.empty())
		return 0;
 
	int nCount = 0;
	std::string temp;
	size_t pos = 0, offset = 0;
 
	// 分割第1~n-1个
	while ((pos = src.find_first_of(separator, offset)) != std::string::npos)
	{
		temp = src.substr(offset, pos - offset);
		if (temp.length() > 0) {
			dst.push_back(temp);
			nCount++;
		}
		offset = pos + 1;
	}
 
	// 分割第n个
	temp = src.substr(offset, src.length() - offset);
	if (temp.length() > 0) {
		dst.push_back(temp);
		nCount++;
	}
 
	return nCount;
}
//去前后空格
 std::string& WebSocketServerOpreate::StringTrim(std::string &str)
{
	 if (str.empty()) {
		 return str;
	 }
	 str.erase(0, str.find_first_not_of(" "));
	 str.erase(str.find_last_not_of(" ") + 1);
	 return str;
}
//获取请求命令与参数
bool WebSocketServerOpreate::GetReqeustCommandAndParmeter(std::string strUri, std::string & strRequestOperateCommand, std::vector<NameAndValue> & listRequestOperateParameter)
{
	bool bRet = false;
	std::vector<std::string> vecRequest;
	int nRetSplit = StringSplit(vecRequest, strUri, "?");
	if (nRetSplit > 0)
	{
		if (vecRequest.size() == 1)
		{
			strRequestOperateCommand = vecRequest[0];
		}
		else if (vecRequest.size() > 1)
		{
			strRequestOperateCommand = vecRequest[0];
			std::string strRequestParameter = vecRequest[1];
			std::vector<std::string> vecParams;
			nRetSplit = StringSplit(vecParams, strRequestParameter, "&");
			if (nRetSplit > 0)
			{
				std::vector<std::string>::iterator iter, iterEnd;
				iter = vecParams.begin();
				iterEnd = vecParams.end();
				for (iter; iter != iterEnd; iter++)
				{
					std::vector<std::string> vecNameOrValue;
					nRetSplit = StringSplit(vecNameOrValue, *iter, "=");
					if (nRetSplit > 0)
					{
						NameAndValue nvNameAndValue;
						nvNameAndValue.strName = vecNameOrValue[0];
						nvNameAndValue.strValue = "";
						if (vecNameOrValue.size() > 1)
						{
							nvNameAndValue.strValue = vecNameOrValue[1];
						}
						//insert
						listRequestOperateParameter.push_back(nvNameAndValue);
					}
				}
			}
		}
		else
		{
 
		}
	}
	return bRet;
}


 

```cpp
//main.cpp
// WebSocketTest.cpp : 定义控制台应用程序的入口点。
//
 
#include "stdafx.h"
#include "WebSocketServerOpreate.h"
 
 
int main() {
	WebSocketServerOpreate serverWebSocketServerOpreate;
	serverWebSocketServerOpreate.Init(9100);
	serverWebSocketServerOpreate.StartWork();
 
	while (true)
	{
		Sleep(200);
	}
 
	serverWebSocketServerOpreate.StopWork();
	serverWebSocketServerOpreate.Uninit();
}

//客户端

//WebSocketClientOperate.h

#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>
#include <iostream>
#include <boost/thread.hpp>
 
typedef websocketpp::client<websocketpp::config::asio_client> client;
 
using websocketpp::lib::placeholders::_1;
using websocketpp::lib::placeholders::_2;
using websocketpp::lib::bind;
 
// pull out the type of messages sent by our config
typedef websocketpp::config::asio_client::message_type::ptr message_ptr;
 
enum LoginStatus
{
	LoginStatus_LoginSuccessed = 0,			//登录成功
	LoginStatus_LoginFail = 1,					//登录失败
	LoginStatus_NotLogin = 2,					//未登录
	LoginStatus_Logining = 3,					//登录中
};
 
class WebSocketClientOperate
{
public:
	WebSocketClientOperate();
	virtual ~WebSocketClientOperate();
 
	int Init(char *pHostname, unsigned short usPort,char *pBaseUri, char *pLoginUsername, char *pLoginPassword);
	int Init(char *pHostname, unsigned short usPort, char *pUri);
	int Uninit();
 
	int StartWork();
	int StopWork();
 
 
protected:
	int login();
	int logout();
 
	int ThreadProccess();
 
protected:
	//消息回调函数
	void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg);
	//连接上服务器回调函数
	void on_open(client* c, websocketpp::connection_hdl hdl);
	//服务器断开连接回调函数
	void on_close(client* c, websocketpp::connection_hdl hdl);
	//无法连接上服务器回调函数，socket在内部已关闭上层无需再关闭
	void on_termination_handler(client* c, websocketpp::connection_hdl hdl);
 
	int closeConnect();
	int  sendTextData(char *pText);
	int  sendBinaryData(unsigned char *pData, int nSize);
 
protected:
	boost::thread * m_threadMain;
	bool m_bThreadExit;
	bool m_bIsConnectedServer;
	bool m_bSubscribeDataSuccess;
	std::string m_strHostname;
	std::string m_strWSUrl;
	std::string m_strUsername;
	client m_client;
	client::connection_ptr m_connection;
	int m_nLoginStatus;
	std::string m_strLoginSessionId;
	DWORD m_dwLoginRequestTime;
};

//WebSocketClientOperate.cpp

#include "stdafx.h"
#include "WebSocketClientOperate.h"
#include "InnerFunction.h"
#include <mmsystem.h>
#include "jsoncpp/include/json/json.h"
 
#ifdef _DEBUG
#pragma comment(lib,"jsoncpp/lib/debug/lib_json.lib")
#else
#pragma comment(lib,"jsoncpp/lib/release/lib_json.lib")
#endif
#pragma comment(lib,"winmm.lib")
 
#define Min_Login_Time				30000
 
WebSocketClientOperate::WebSocketClientOperate()
{
	m_threadMain = NULL;
	m_bThreadExit = true;
	m_bIsConnectedServer = false;
	m_strHostname.clear();
	m_strWSUrl.clear();
	m_strUsername.clear();
	m_strLoginSessionId.clear();
	m_connection = NULL;
	m_nLoginStatus = LoginStatus_NotLogin;
	m_bSubscribeDataSuccess = false;
	m_dwLoginRequestTime = 0;
}
 
WebSocketClientOperate::~WebSocketClientOperate()
{
}
 
int WebSocketClientOperate::Init(char *pHostname, unsigned short usPort, char *pBaseUri, char *pLoginUsername, char *pLoginPassword)
{
	m_strHostname = pHostname;
	m_strUsername = pLoginUsername;
	char szUrl[1024] = { 0 };
	sprintf_s(szUrl, "ws://%s:%d/%s?uid=%s&pwd=%s", pHostname, usPort, pBaseUri, pLoginUsername, pLoginPassword);
	m_strWSUrl = szUrl;
	try {
		// Set logging to be pretty verbose (everything except message payloads)
		m_client.set_access_channels(websocketpp::log::alevel::all);
		m_client.clear_access_channels(websocketpp::log::alevel::frame_payload);
 
		// Initialize ASIO
		m_client.init_asio();
		m_client.set_reuse_addr(true);
 
		// Register our message handler
		m_client.set_message_handler(bind(&WebSocketClientOperate::on_message, this, &m_client, ::_1, ::_2));
		m_client.set_open_handler(bind(&WebSocketClientOperate::on_open, this, &m_client, ::_1));
		m_client.set_close_handler(bind(&WebSocketClientOperate::on_close, this, &m_client, ::_1));
	}
	catch (websocketpp::exception const & e) {
		std::cout << e.what() << std::endl;
		return -2;
	}
 
	return 0;
}
int WebSocketClientOperate::Init(char *pHostname, unsigned short usPort, char *pUri)
{
	m_strHostname = pHostname;
	char szUrl[1024] = { 0 };
	sprintf_s(szUrl, "ws://%s:%d/%s", pHostname, usPort, pUri);
	m_strWSUrl = szUrl;
	try {
		// Set logging to be pretty verbose (everything except message payloads)
		m_client.set_access_channels(websocketpp::log::alevel::all);
		m_client.clear_access_channels(websocketpp::log::alevel::frame_payload);
 
		// Initialize ASIO
		m_client.init_asio();
		m_client.set_reuse_addr(true);
 
		// Register our message handler
		m_client.set_message_handler(bind(&WebSocketClientOperate::on_message, this, &m_client, ::_1, ::_2));
		m_client.set_open_handler(bind(&WebSocketClientOperate::on_open, this, &m_client, ::_1));
		m_client.set_close_handler(bind(&WebSocketClientOperate::on_close, this, &m_client, ::_1));
	}
	catch (websocketpp::exception const & e) {
		std::cout << e.what() << std::endl;
		return -2;
	}
 
	return 0;
}
int WebSocketClientOperate::Uninit()
{
	return 0;
}
 
int WebSocketClientOperate::StartWork()
{
	m_bThreadExit = false;
	m_threadMain = new boost::thread(boost::bind(&WebSocketClientOperate::ThreadProccess, this));
	if (m_threadMain == NULL)
	{
		m_bThreadExit = true;
		return -1;
	}
	else
	{
		return 0;
	}
}
int WebSocketClientOperate::StopWork()
{
	int nRet = 0;
	m_bThreadExit = true;
	m_client.stop();
	if (m_threadMain != NULL)
	{
		m_threadMain->join();
		delete m_threadMain;
		m_threadMain = NULL;
	}
	m_nLoginStatus = LoginStatus_NotLogin;
	return nRet;
}
 
int WebSocketClientOperate::login()
{
	int nRet = 0;
	try {
		//防止频繁登录
		if (m_dwLoginRequestTime != 0 && m_nLoginStatus != LoginStatus_LoginSuccessed)
		{
			DWORD dwCurrentTime = timeGetTime();
			if ((dwCurrentTime - m_dwLoginRequestTime) <= Min_Login_Time)
			{
				return 1;
			}
		}
 
		m_nLoginStatus = LoginStatus_Logining;
		m_dwLoginRequestTime = timeGetTime();
 
		websocketpp::lib::error_code ec;
		m_connection = m_client.get_connection(m_strWSUrl, ec);
		if (ec)
		{
			std::cout << "could not create connection because: " << ec.message() << std::endl;
			m_nLoginStatus = LoginStatus_LoginFail;
			return -1;
		}
 
		// Note that connect here only requests a connection. No network messages are
		// exchanged until the event loop starts running in the next line.
		m_client.connect(m_connection);
		//设置连接断开通知handler
		m_connection->set_termination_handler(bind(&WebSocketClientOperate::on_termination_handler, this, &m_client, ::_1));
	}
	catch (websocketpp::exception const & e) {
		std::cout << e.what() << std::endl;
		m_nLoginStatus = LoginStatus_LoginFail;
		return -2;
	}
	return nRet;
}
 
int WebSocketClientOperate::logout()
{
	m_nLoginStatus = LoginStatus_NotLogin;
	return -1;
}
 
int WebSocketClientOperate::ThreadProccess()
{
	while (true)
	{
		if (m_bThreadExit)
		{
			break;
		}
 
		if (!m_bIsConnectedServer)
		{
			if (m_nLoginStatus == LoginStatus_LoginFail || m_nLoginStatus == LoginStatus_NotLogin)
			{
				login();
			}
		}
		else
		{
			sendTextData("aaaaaa");
		}
		if (m_nLoginStatus == LoginStatus_LoginSuccessed)
		{
			m_client.poll_one();
			Sleep(100);
		}
		else
		{
			//首次连接之后，需要快速握手，不能等待长时间，否则websocket握手失败；websocket握手成功之后，可以等待长时间
			m_client.poll_one();
			Sleep(100);
		}
 
	}
	return 0;
}
 
// This message handler will be invoked once for each incoming message. It
// prints the message and then sends a copy of the message back to the server.
void WebSocketClientOperate::on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
	std::cout << "on_message called with hdl: " << hdl.lock().get()
		<< " and message: " << msg->get_payload()
		<< std::endl;
 
	//不同业务，接收不同数据内容，解析相应的数据并处理
	std::string strRecvice = Utf8toAscii(msg->get_payload());
	Json::Reader reader;
	Json::Value root;
	bool bRet = reader.parse(strRecvice, root);
	if (bRet)
	{
		int nRetErrorCode = root["ret"].asInt();;
		int nOperateType = root["operatetype"].asInt();
		if (nOperateType == 2)									//登录应答
		{
			m_strLoginSessionId = root["sessionid"].asString();
			if (nRetErrorCode == 0)
			{
				//登录成功
				m_nLoginStatus = LoginStatus_LoginSuccessed;
			}
		}
		else
		{
 
		}
	}
}
 
void WebSocketClientOperate::on_open(client* c, websocketpp::connection_hdl hdl) {
	std::cout << "open handler" << std::endl;
	client::connection_ptr con = c->get_con_from_hdl(hdl);
	//websocketpp::config::core_client::request_type requestClient = con->get_request();
	if (con->get_ec().value() != 0)
	{
		m_bIsConnectedServer = false;
	}
	else
	{
		m_bIsConnectedServer = true;
	}
}
 
void WebSocketClientOperate::on_close(client* c, websocketpp::connection_hdl hdl)
{
	closeConnect();
	m_bSubscribeDataSuccess = false;
	m_bIsConnectedServer = false;
	m_nLoginStatus = LoginStatus_NotLogin;
}
 
void WebSocketClientOperate::on_termination_handler(client* c, websocketpp::connection_hdl hdl)
{
	closeConnect();
	m_nLoginStatus = LoginStatus_LoginFail;
	m_bIsConnectedServer = false;
}
 
int WebSocketClientOperate::closeConnect()
{
	int nRet = 0;
	try {
		if (m_connection != NULL && m_connection->get_state() == websocketpp::session::state::value::open)
		{
			websocketpp::close::status::value cvValue = 0;
			std::string strReason = "";
			m_connection->close(cvValue, strReason);
		}
	}
	catch (websocketpp::exception const & e)
	{
		std::cout << e.what() << std::endl;
		nRet = -1;
	}
	return nRet;
}
 
int  WebSocketClientOperate::sendTextData(char *pText)
{
	int nRet = 0;
	try {
		websocketpp::lib::error_code ec;
		ec = m_connection->send(pText);
		if (ec) {
			std::cout << "Echo failed because: " << ec.message() << std::endl;
			nRet = -1;
		}
	}
	catch (websocketpp::exception const & e) {
		std::cout << e.what() << std::endl;
		return -2;
	}
 
	return nRet;
}
 
int  WebSocketClientOperate::sendBinaryData(unsigned char *pData, int nSize)
{
	int nRet = 0;
	try {
		websocketpp::lib::error_code ec;
		ec = m_connection->send(pData, nSize, websocketpp::frame::opcode::binary);
		if (ec) {
			std::cout << "Echo failed because: " << ec.message() << std::endl;
			nRet = -1;
		}
	}
	catch (websocketpp::exception const & e) {
		std::cout << e.what() << std::endl;
		return -2;
	}
 
	return nRet;
}

//main.cpp

#include "stdafx.h"
 
#include "WebSocketClientOperate.h"
 
int main(int argc, char* argv[]) {
	WebSocketClientOperate clientWebSocketClientOperate;
	clientWebSocketClientOperate.Init("127.0.0.1", 9100,"ws", "admin", "admin");
	clientWebSocketClientOperate.StartWork();
 
	while (true)
	{
		Sleep(200);
	}
	return 0;
}

有 0 个人打赏
————————————————
版权声明：本文为CSDN博主「byxdaz」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/byxdaz/article/details/84769707

NBA_1
关注
专栏目录
websocketpp实例代码
11-29
WebSocketpp是一个支持websocket功能的库，C++语言，本身不需要搭建什么环境，只要新建的项目引入相关的库就行。本实例代码包含了服务器，CS客户端、web客户端代码。
html5 websocket c++,C++ websocket库 websocketpp/websocket++例子编译试用
weixin_39864453的博客
06-19 141
转自https://blog.csdn.net/sdsabc2000/article/details/52461181想试试C++的websocket，搜了下，发现websocketpp/websocket++用的人挺多，对主流浏览器都支持；使用也方便，包含头文件即可(再加上boost头文件和库)，没有其他依赖1、搭建好boost2、下载websocket++2、以例子里面的echo_server...
websocketpp服务器搭建
最新发布
2301_77412625的博客
09-17 1138
概念:是一个应用层的tcp长连接协议。搭建一个websocket服务器其实就是搭建了一个tcp服务器，只不过应用层使用websocket协议格式进行数据处理。在IM项目中:客户端 -----HTTP----- 服务器但是在聊天室项目中，不单单是请求-响应的业务处理，还包含了数据的主动推送而这种消息数据的主动推送，是HTTP协议无法实现的。因此需要搭建一个长连接的服务器，用于主动向客户端推送数据。
websocket++简单使用及实例分析
09-02
下面小编就为大家带来一篇websocket++简单使用及实例分析。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Websocketpp实现自己的web服务器
11-04
使用开源Websocketpp实现自己的web服务器，实例代码主要介绍了对客户端基本几种请求的处理。
WebSocketpp
fdsafwagdagadg6576的专栏
06-17 2709
WebSocket是 HTML5 开始提供的一种在单个 TCP 连接上进行全双工通讯的协议。WebSocket 使得 CS 之间的数据交换变得更加简单，允许 S 主动向 C 推送数据。WebSocket 和 HTTP 一样都是应用层的一种协议，可以使用各种编程语言实现之。WebSocketpp 是一个仅仅由头文件构成的 C++库，它实现了 WebSocket 协议(rfc 6455)，可以在项目中方便简洁地实现客户端和服务器。WebSocketpp 底层使用了 C++ 的 iostream 库和基于 Boo
WebsocketPP C++构建Web服务器源代码
08-30
6. **实例解析**：`MyWebTest`可能是项目源代码的主文件，里面包含了服务器的初始化、监听、连接处理和消息处理等逻辑。分析这个文件可以深入理解如何使用WebSocketPP来构建实际的应用。 7. **调试与优化**：在实际...
异步处理websocketpp模型
11-25
在WebSocketpp中，每个连接到服务器的客户端都会创建一个会话实例，用于处理与该客户端的通信。`ServerSessionManager`通常负责会话的创建、管理和销毁，确保服务器能正确地处理来自多个并发连接的异步事件。 在`...
websocketpp应用
weixin_42998150的博客
02-11 263
1、下载boost 2、运行boostrap.bat->bjam.exe运行 3、配置boost根目录为include路径；boost\stage\lib为lib路径 4、boost支持http和websocket。websocket为长连接，可以全双工工作。 5、boost为消息驱动机制，注册hangdle接收消息。包括message（websocket ）、http、open、close...
Websocketpp的使用
weixin_45266730的博客
12-27 3110
Websocketpp的使用
websocketpp.zip
08-27
websocketpp 源代码，方便使用，欢迎大家请大家下载，欢迎大家请大家下载，欢迎大家请大家下载
C/C++编程：WebSocketpp（Linux + Clion + boostAsio）
OceanStar的博客
02-03 8786
WebSocket ++是一个C ++库，可用于实现WebSocket功能。该项目的目标是提供一种可移植，灵活，轻量级，低级和高性能的WebSocket实现。 WebSocket ++并不打算单独用作Web应用程序框架或功能全面的Web服务平台。这样的组件，示例和性能调整都适合作为WebSocket客户端或服务器进行操作。
WebRTC笔记之十八：WebSocketPP
草上爬的博客
12-14 5927
一.WebSocketPP简介 1.WebSocket WebSocket是HTML5 引入的新特性，它通常用 Web端，为构建实时全双工的Web应用提供方便。WebSocket是一个基于TCP的应用层协议，它复用了HTTP握手规范，通过HTTP来建立WebSockt通道，客户端和服务器端都可以通过这条通道主动发起请求，通道建立完成后是持久化的，因而 WebSocket有着“Web 的 TCP”之称。 协议的实现可以是多样化的，除了可以在前端开发的JavaScript中使用WebSocket之外，我们也
websocketpp c++客户端
老衲不出家
05-28 3404
利用websocketpp库编写websocket客户端程序。 一、阻塞方式实例 #include "stdafx.h" #include <websocketpp/config/asio_no_tls_client.hpp> #include <websocketpp/client.hpp> #include <iostream> typed...
使用开源C++项目WebSocketpp构建web服务器
热门推荐
https://github.com/JelinYao
11-30 3万+
1、WebsocketPP简介 最近需要构建一个本地的服务器程序，处理PHP服务器发来的请求，看到微软的一个开源项目内部用到了这个开源库，于是就试着用了下，效果还好，主要是很容易处理Web请求并返回数据。（C++写程序来请求，然后用C++在WebsocketPP构建服务器处理请求，想怎么定义数据怎么加密都可以，因为都是C++程序，也不用学习PHP，想想就很美好）。 WebsocketPP是一个
websocketpp最简单的服务器
qianbo042311的博客
07-21 867
预定义 1 WEBSOCKETPP_CPP11_TYPE_TRAITS 2 ASIO_STANDALONE; 3 SCL_SECURE_NO_WARNINGS; A 不要使用太新的版本 B 不使用boost 就把ASIO_STANDALONE 预定义加上，使用boost库毕竟比较庞大。 set_access_channels 函数定义输出的日志，输出日志太多效率就低了，这个一定要知道。 #define _SCL_SECURE_NO_WARNINGS #define WEBSOCKETPP_CPP11_TYP
使用websocketpp实现websocket服务端
业余玩家
08-09 1628
简介 WebSocket是一种在单个TCP连接上进行全双工通信的协议。WebSocket通信协议于2011年被IETF定为标准RFC 6455，并由RFC7936补充规范。WebSocket API也被W3C定为标准。 WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。 使用 websocketpp，依赖boost库，安装boost yum
搭建WebSocketpp环境
xingxinmanong的博客
03-23 8882
WebSocketpp只是一个库，本身不需要搭建什么环境，只要新建的项目引入相关的库就行。但是WebSocketpp依赖于boost库，因此开发之前还是有点东西要做的。 1、下载boost库和WebSocketpp库 本来直接去对应的官网下载就行，但都是国外网站，有时下载速度真是蛋疼（反正我是下了很久）。因此我把他上传到网盘，有需要的直接下载 点我下载 2、安装boost库 说是安装，其
MSTP配置实践：单实例与多实例详解
本文档主要介绍了MSTP（Multiple Spanning Tree Protocol，多生成树协议）的配置实例，包括单实例和多实例的组网需求，以及相关的配置建议，旨在提高网络的可靠性、收敛速度和带宽利用率。 在MSTP配置实例中，首先...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值