boost asio非同步讀寫網路聊天室【官方示例】

阿新 • • 發佈：2019-01-01

//
// chat_message.hpp
// ~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#pragma warning(disable:4996)
#ifndef CHAT_MESSAGE_HPP
#define CHAT_MESSAGE_HPP

#include <cstdio>
#include <cstdlib>
#include <cstring>

class chat_message
{
public:
	enum { header_length = 4 };
	enum { max_body_length = 512 };

	chat_message()
		: body_length_(0)
	{
	}

	const char* data() const
	{
		return data_;
	}

	char* data()
	{
		return data_;
	}

	size_t length() const
	{
		return header_length + body_length_;
	}

	const char* body() const
	{
		return data_ + header_length;
	}

	char* body()
	{
		return data_ + header_length;
	}

	size_t body_length() const
	{
		return body_length_;
	}

	void body_length(size_t length)
	{
		body_length_ = length;
		if (body_length_ > max_body_length)
			body_length_ = max_body_length;
	}

	bool decode_header()
	{
		using namespace std; // For strncat and atoi.
		char header[header_length + 1] = "";
		strncat(header, data_, header_length);
		body_length_ = atoi(header);
		if (body_length_ > max_body_length)
		{
			body_length_ = 0;
			return false;
		}
		return true;
	}

	void encode_header()
	{
		using namespace std; // For sprintf and memcpy.
		char header[header_length + 1] = "";
		sprintf(header, "%4d", body_length_);
		memcpy(data_, header, header_length);
	}

private:
	char data_[header_length + max_body_length];
	size_t body_length_;
};

#endif // CHAT_MESSAGE_HPP

服務端：server.cpp

// server.cpp : 定義控制檯應用程式的入口點。
// 聊天室程式，支援多個client相互聊天

#include "stdafx.h"

//
// chat_server.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#include <algorithm>
#include <cstdlib>
#include <deque>
#include <iostream>
#include <list>
#include <set>
#include <boost/bind.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/asio.hpp>
#include "chat_message.hpp"

using boost::asio::ip::tcp;
using namespace std;

//----------------------------------------------------------------------

typedef std::deque<chat_message> chat_message_queue;

//----------------------------------------------------------------------

// 一個抽象類，用於提供聊天室成員的介面
class chat_participant //  聊天參與者
{
public:
	virtual ~chat_participant() {}
	virtual void deliver(const chat_message& msg) = 0; // 發言
};

typedef boost::shared_ptr<chat_participant> chat_participant_ptr;

//----------------------------------------------------------------------

class chat_room // 聊天室
{
public:
	void join(chat_participant_ptr participant) // 6
	{
		cout<<__FUNCTION__<<endl;
		participants_.insert(participant);

		// 把聊天室內快取的訊息傳送給新加入的成員,相當於：
// 		chat_message_queue::const_iterator it;
// 		for(it = recent_msgs_.begin(); it!=recent_msgs_.end(); ++it)
// 			participant->deliver(*it); 
		std::for_each(recent_msgs_.begin(), recent_msgs_.end(),
			boost::bind(&chat_participant::deliver, participant, _1)); // 12 動態繫結
	}

	void leave(chat_participant_ptr participant)
	{
		cout<<__FUNCTION__<<endl;
		participants_.erase(participant);
	}

	// 存入msg到緩衝區佇列
	void deliver(const chat_message& msg) // 11 發言
	{
		cout<<__FUNCTION__<<endl;
		recent_msgs_.push_back(msg);
		while (recent_msgs_.size() > max_recent_msgs)
			recent_msgs_.pop_front(); // 將過時發言清出緩衝區

		// 將新訊息發給每個聊天室成員，相當於：
// 		std::set<chat_participant_ptr>::iterator it;
// 		for(it=participants_.begin(); it!=participants_.end(); ++it)
// 			(*it)->deliver(msg);
		std::for_each(participants_.begin(), participants_.end(),
			boost::bind(&chat_participant::deliver, _1, boost::ref(msg))); // 12
	}

private:
	std::set<chat_participant_ptr> participants_; // 當前聊天室的n個參與者：set，不能重複
	enum { max_recent_msgs = 100 }; // 最大最近訊息：緩衝區最多儲存最近100條發言
	chat_message_queue recent_msgs_; // 訊息佇列：deque,先到先出
};

//----------------------------------------------------------------------

// 在聊天室環境下，一個session就是一個成員
class chat_session
	: public chat_participant, // 繼承
	public boost::enable_shared_from_this<chat_session> // 可以使用shared_from_this()(即shared_ptr<chat_session>)
{
public:
	chat_session(boost::asio::io_service& io_service, chat_room& room) // 2 7
		: socket_(io_service),
		room_(room)
	{
		cout<<__FUNCTION__<<endl;
	}

	tcp::socket& socket() // 3 8
	{
		cout<<__FUNCTION__<<endl;
		return socket_;
	}

	void start() // 5
	{
		cout<<__FUNCTION__<<endl;
		room_.join(shared_from_this());  // 6 room_.join(shared_ptr<chat_session>);
		// async_read是事件處理一個機制，使用回撥函式從而實現事件處理器方法
		// 本示例大量採用這個機制，也就是非同步機制
		// 通過回撥函式可以形成一個事件鏈，即在回撥函式中設定一個新的事件與新回撥函式
		boost::asio::async_read(socket_,
			boost::asio::buffer(read_msg_.data(), chat_message::header_length), // 取buffer頭部，正文字元數到read_msg_
			boost::bind(
			&chat_session::handle_read_header, shared_from_this(), // 9 呼叫:shared_from_this()->handle_read_header(boost::asio::placeholders::error);
			boost::asio::placeholders::error));
	}

	// 存buffer中的資料到read_msg_：header部分
	void handle_read_header(const boost::system::error_code& error) // 9
	{
		cout<<__FUNCTION__<<endl;
		if (!error && read_msg_.decode_header())
		{
			boost::asio::async_read(socket_,
				boost::asio::buffer(read_msg_.body(), read_msg_.body_length()),// 取buffer文字部分到read_msg_
				boost::bind(&chat_session::handle_read_body, shared_from_this(), // 10 呼叫:shared_from_this()->handle_read_body(boost::asio::placeholders::error);
				boost::asio::placeholders::error));
		}
		else
		{
			room_.leave(shared_from_this()); // 14
		}
	}

	// 存buffer中的資料到read_msg_：body部分
	void handle_read_body(const boost::system::error_code& error) // 10
	{
		cout<<__FUNCTION__<<endl;
		if (!error)
		{
			room_.deliver(read_msg_); // 11
			boost::asio::async_read(socket_,
				boost::asio::buffer(read_msg_.data(), chat_message::header_length), // 取buffer頭部，正文字元數到read_msg_
				boost::bind(&chat_session::handle_read_header, shared_from_this(),// 呼叫:shared_from_this()->handle_read_header(boost::asio::placeholders::error);
				boost::asio::placeholders::error));
		}
		else
		{
			room_.leave(shared_from_this());
		}
	}

	//存入資料到write_msgs_，送佇列的最開始一條發言到buffer
	void deliver(const chat_message& msg) // 12,有幾個客戶端呼叫幾次
	{
		cout<<__FUNCTION__<<endl;
		bool write_in_progress = !write_msgs_.empty();
		write_msgs_.push_back(msg);
		if (!write_in_progress)
		{
			boost::asio::async_write(socket_,
				boost::asio::buffer(write_msgs_.front().data(),
				write_msgs_.front().length()), // 佇列的最開始一條發言到buffer
				boost::bind(&chat_session::handle_write, shared_from_this(), // 13 shared_from_this()->handle_write(boost::asio::placeholders::error)
				boost::asio::placeholders::error));
		}
	}

	// 把write_msgs_資料送buffer，使客戶端可以得到，遞迴呼叫自身值到write_msgs_為空
	void handle_write(const boost::system::error_code& error) // 13,有幾個客戶端呼叫幾次
	{
		cout<<__FUNCTION__<<endl;
		if (!error)
		{
			write_msgs_.pop_front();
			if (!write_msgs_.empty())
			{
				boost::asio::async_write(socket_,
					boost::asio::buffer(write_msgs_.front().data(),// 佇列的最開始一條發言到buffer
					write_msgs_.front().length()),
					boost::bind(&chat_session::handle_write, shared_from_this(),// 13 shared_from_this()->handle_write(boost::asio::placeholders::error)
					boost::asio::placeholders::error));
			}
		}
		else
		{
			room_.leave(shared_from_this());
		}
	}

private:
	tcp::socket socket_;
	chat_room& room_;
	chat_message read_msg_; // 存從buffer讀出的資料
	chat_message_queue write_msgs_; // 欲寫入buffer的資料佇列，deque
};

typedef boost::shared_ptr<chat_session> chat_session_ptr;

//----------------------------------------------------------------------

class chat_server
{
public:
	chat_server(boost::asio::io_service& io_service, // 1
		const tcp::endpoint& endpoint)
		: io_service_(io_service),
		acceptor_(io_service, endpoint)
	{
		cout<<__FUNCTION__<<endl;
		chat_session_ptr new_session(new chat_session(io_service_, room_)); // 2
		acceptor_.async_accept(new_session->socket(), // 3
			boost::bind(&chat_server::handle_accept, this, new_session, // 4  this->handle_accept(new_session, boost::asio::placeholders::error);
			boost::asio::placeholders::error));
	}
	// 有連線到來時觸發，然後等待下個連線到來
	void handle_accept(chat_session_ptr session, // 4
		const boost::system::error_code& error)
	{
		cout<<__FUNCTION__<<endl;
		if (!error)
		{
			session->start(); // 5 
			chat_session_ptr new_session(new chat_session(io_service_, room_)); // 7
			acceptor_.async_accept(new_session->socket(), // 8
				boost::bind(&chat_server::handle_accept, this, new_session, //this->handle_accept(new_session, boost::asio::placeholders::error);
				boost::asio::placeholders::error));
		}
	}

private:
	boost::asio::io_service& io_service_;
	tcp::acceptor acceptor_;
	chat_room room_;
};

typedef boost::shared_ptr<chat_server> chat_server_ptr;
typedef std::list<chat_server_ptr> chat_server_list;

//----------------------------------------------------------------------

int _tmain(int argc, _TCHAR* argv[])
{
	// 呼叫棧：
	// 開啟服務端並等待連線：1-3，acceptor_.async_accept（）
	// 一個客戶端進入並連線：4-8，然後等待下個客戶端：acceptor_.async_accept（）；又加入一個客戶端：重複呼叫4-8
	// 任意客戶端發言：9-13,12\13呼叫n次；任意客戶發言，重複9-13
	// 聊天中途又新加入一個客戶端：456 12(n) 78 13(n)
	// 一個客戶端斷開連線：9 14
	// 非同步機制：立刻返回，boost提供的非同步函式字首async_要求一個回撥函式，回撥函式只在某一事件觸發時才被呼叫
	// 回撥函式：void your_completion_handler(const boost::system::error_code& ec);
	try
	{
		boost::asio::io_service io_service;

		chat_server_list servers; // server列表：一個server就是一個聊天室
		
		tcp::endpoint endpoint(/*boost::asio::ip::address_v4::from_string("127.0.0.1")*/tcp::v4(), 1000);
		chat_server_ptr server(new chat_server(io_service, endpoint)); // 1
		servers.push_back(server);

		io_service.run();
	}
	catch (std::exception& e)
	{
		std::cerr << "Exception: " << e.what() << "\n";
	}

	return 0;
}

客戶端：client.cpp

// client.cpp : 定義控制檯應用程式的入口點。
//

#include "stdafx.h"

//
// chat_client.cpp
// ~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2010 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//

#include <cstdlib>
#include <deque>
#include <iostream>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
#include "chat_message.hpp"

using boost::asio::ip::tcp;
using namespace std;
typedef std::deque<chat_message> chat_message_queue;

class chat_client
{
public:
	chat_client(boost::asio::io_service& io_service, // 1
		tcp::resolver::iterator endpoint_iterator)
		: io_service_(io_service),
		socket_(io_service)
	{
		cout<<__FUNCTION__<<endl;
		tcp::endpoint endpoint = *endpoint_iterator;
		socket_.async_connect(endpoint,
			boost::bind(&chat_client::handle_connect, this, // 2
			boost::asio::placeholders::error, ++endpoint_iterator));
	}

	void write(const chat_message& msg) // 5
	{
		cout<<__FUNCTION__<<endl;
		io_service_.post(boost::bind(&chat_client::do_write, this, msg));
	}

	void close()
	{
		cout<<__FUNCTION__<<endl;
		io_service_.post(boost::bind(&chat_client::do_close, this));
	}

private:

	void handle_connect(const boost::system::error_code& error, // 2
		tcp::resolver::iterator endpoint_iterator)
	{
		cout<<__FUNCTION__<<endl;
		if (!error)
		{
			boost::asio::async_read(socket_,
				boost::asio::buffer(read_msg_.data(), chat_message::header_length),  //copy buffer to read_msg_'s header
				boost::bind(&chat_client::handle_read_header, this, // 3
				boost::asio::placeholders::error));
		}
		else if (endpoint_iterator != tcp::resolver::iterator())
		{
			socket_.close();
			tcp::endpoint endpoint = *endpoint_iterator;
			socket_.async_connect(endpoint,
				boost::bind(&chat_client::handle_connect, this, // 2
				boost::asio::placeholders::error, ++endpoint_iterator));
		}
	}

	void handle_read_header(const boost::system::error_code& error) // 3
	{
		cout<<__FUNCTION__<<endl;
		if (!error && read_msg_.decode_header())
		{
			boost::asio::async_read(socket_,
				boost::asio::buffer(read_msg_.body(), read_msg_.body_length()), //copy buffer to read_msg_'s body
				boost::bind(&chat_client::handle_read_body, this, // 4
				boost::asio::placeholders::error));
		}
		else
		{
			do_close();
		}
	}

	void handle_read_body(const boost::system::error_code& error) // 4
	{
		cout<<__FUNCTION__<<endl;
		if (!error)
		{
			std::cout.write(read_msg_.body(), read_msg_.body_length()); // print read_msg_'s body
			std::cout << "\n";
			boost::asio::async_read(socket_,
				boost::asio::buffer(read_msg_.data(), chat_message::header_length),
				boost::bind(&chat_client::handle_read_header, this, // 4
				boost::asio::placeholders::error));
		}
		else
		{
			do_close();
		}
	}

	void do_write(chat_message msg) // 6
	{
		cout<<__FUNCTION__<<endl;
		bool write_in_progress = !write_msgs_.empty();
		write_msgs_.push_back(msg);
		if (!write_in_progress)
		{
			boost::asio::async_write(socket_,
				boost::asio::buffer(write_msgs_.front().data(),
				write_msgs_.front().length()), // copy write_msgs_.front() to buffer
				boost::bind(&chat_client::handle_write, this, // 7 send message
				boost::asio::placeholders::error));
		}
	}

	void handle_write(const boost::system::error_code& error) // 7
	{
		cout<<__FUNCTION__<<endl;
		if (!error)
		{
			write_msgs_.pop_front();
			if (!write_msgs_.empty())
			{
				boost::asio::async_write(socket_,
					boost::asio::buffer(write_msgs_.front().data(),
					write_msgs_.front().length()),
					boost::bind(&chat_client::handle_write, this, // 7
					boost::asio::placeholders::error));
			}
		}
		else
		{
			do_close();
		}
	}

	void do_close()
	{
		cout<<__FUNCTION__<<endl;
		socket_.close();
	}

private:
	boost::asio::io_service& io_service_;
	tcp::socket socket_;
	chat_message read_msg_;  // 存從buffer讀出的資料
	chat_message_queue write_msgs_; // 欲寫入buffer的資料佇列，deque
};

int _tmain(int argc, _TCHAR* argv[])
{
	// 呼叫棧：
	// 開啟客戶端並連線（聊天室沒有對話時）：1-2
	// 開啟客戶端並連線（聊天室有對話時）:1-4
	// 自己發言:56734
	// 聊天室內其他成員發言：34
	try
	{
		boost::asio::io_service io_service;

		tcp::resolver resolver(io_service);
		tcp::resolver::query query("127.0.0.1", "1000"); // ip port:本機
		tcp::resolver::iterator iterator = resolver.resolve(query);

		chat_client c(io_service, iterator); // 初始化、連線

		boost::thread t(boost::bind(&boost::asio::io_service::run, &io_service)); // 執行緒

		char line[chat_message::max_body_length + 1];
		while (std::cin.getline(line, chat_message::max_body_length + 1))
		{
			chat_message msg;
			msg.body_length(strlen(line));
			memcpy(msg.body(), line, msg.body_length());// line to msg
			msg.encode_header();
			c.write(msg);
		}

		c.close();
		t.join(); // 執行執行緒
	}
	catch (std::exception& e)
	{
		std::cerr << "Exception: " << e.what() << "\n";
	}

	return 0;
}

在這裡，為了檢視程式的呼叫過程，在每個成員函式中加了一條：

cout<<__FUNCTION__<<endl;

同時，為了測試方便，固定ip與埠為本機，而不是從main引數中傳遞進來

參考資料：http://blog.csdn.net/cyg0810/article/details/36179195

boost asio非同步讀寫網路聊天室【官方示例】

boost asio非同步讀寫網路聊天程式客戶端例項詳解

Golang之寫一個聊天室

gpo 動作 color 字母數信息數據用戶登錄 clas 是否 1. 海量用戶在線聊天系統 2. 點對點聊天 3. 用戶登錄&註冊一、服務端開發 1. 用戶管理用戶id：數字用戶密碼：字母數字組合

C++從零開始區塊鏈：區塊鏈業務模組之基於boost的json讀寫

#include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> std::string BlockChain::GetJsonFromBlock(Bloc

java實戰——網路聊天室

因特網已經成為了人們交流的海洋，上網的使用者越來越多，更多的人願意使用網路來認識別人，瞭解別人，這就是當下諸如qq、微信等聊天工具火熱的原因。我們雖然不能立馬就開發出來一個像上述兩個一樣功能強大的聊天室，但我們可以自己製作一個簡單的聊天室。我們採用傳統的Client/Server結構，功

用API實現串列埠非同步讀寫

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！

C# 讀寫網路上的芳鄰中的共享檔案

讀寫網路上的芳鄰共享的資料夾，和操作本地資料夾類似，只要有許可權讀取寫入即可。分為以下2步： 1.打通共享資料夾許可權 2.操作檔案打通共享資料夾許可權 1 /// <summary> 2 //

swoole之非同步讀寫

// 非同步讀取檔案內容 swoole_async_readfile(__DIR__."/1.txt", function($filename, $content) { echo "$filename: $content"; }); //非同步寫入檔案 $file_co

使用socket.io寫一個聊天室

之前學習了常用的api，以及概念，這裡為了簡單的使用，寫一個demo，為了方便查詢api，這裡給一個傳送門socket.io 準備老規矩，新建一個目錄，一個index.html, app.js index.html 為客戶端 app.js 為服

[原始碼和文件分享]基於java語言的C/S模式網路聊天室軟體

一需求分析採用C/S模式，基於TCP協議程式設計的方式，使得各個使用者通過伺服器轉發實現聊天的功能分為三大模組：客戶端模組、伺服器端模組和公共輔助類模組客戶端模組的主要功能：登陸功能：使用者可以註冊，然後選擇伺服器登入聊天室

Java NIO示例：多人網路聊天室

一個多客戶端聊天室，支援多客戶端聊天，有如下功能：功能1：客戶端通過Java NIO連線到服務端，支援多客戶端的連線功能2：客戶端初次連線時，服務端提示輸入暱稱，如果暱稱已經有人使用，提示重新輸入，如果暱稱唯一，則登入成功，之後傳送訊息都需要按照規定格式帶著

java socket 基於netty的網路聊天室

Netty是一個Java的NIO客戶端服務端框架可以快速的開發網路應用程式，比如客戶端和服務端的協議，大大簡化了網路程式的開發過程。我們知道Netty的整體架構主要由3部分組成：緩衝(buffer)、通道(channel)、事件模型(event model)。所有的

自己寫的聊天室專案

作業：（服務端，客戶端）寫一個聊天室功能：類似qq群聊 1.進入聊天室需要輸入姓名，提示一下姓名不能重複 2.有人進入聊天室會向其他人傳送通知 xxx 進入了聊天室 3.一個人發訊息，其他人會收到訊息，自己不收到 xxx 說：xxxxxxxxxxx 4.某人

日常改bug之寫簡單聊天室並放到伺服器上

一.查詢資料庫時查詢不了中文的問題當查詢語句是這樣時，如果${name}是中文，則查詢不到資料 `select * from admin_table where name=${name}` 改為以下，即在${name}前加入N即可 `select * from admi

基於linux的TCP網路聊天室設計與實現

利用Linux實現基於TCP模式的網路聊天程式主要完成的兩大組成部分為：伺服器和客戶端。伺服器程式主要負責監聽客戶端發來的訊息。客戶端需要登入到伺服器端才可以實現正常的聊天功能。該程式是利用程序以及共享記憶體來實現群傳送訊息的。以下簡單分析一下

14 QT TCP網路程式設計與網路聊天室的實現

網路裝置:用於遠端的計算機間的通訊. 每個網路裝置都有一個ip地址. ip地址用於區分一個區域網內不同的計算機，　ip地址在同一個區域網內不可以重複使用(如重複使用會兩個都連不了網), ip地址可由路由器動態分配，也可以手動指定. 網路掩碼用於指定所屬的區域

boost::asio 非同步超時機制一

#include <boost/asio/deadline_timer.hpp> #include <boost/asio/io_service.hpp> #include <boost/asio/ip/tcp.hpp> #include

boost asio 非同步實現tcp通訊

一、前言 boost asio可算是一個簡單易用，功能又強大可跨平臺的C++通訊庫，效率也表現的不錯，linux環境是epoll實現的，而windows環境是iocp實現的。而tcp通訊是專案當中經常用到通訊方式之一，實現的方法有各式各樣，因此總結一套適用於自己專案的方法是

linux系統下一個基於TCP的網路聊天室

本聊天室程式在Ubuntu下，採用C語言實現，結構為Client/Server結構; 服務端程式通過共享儲存區儲存聊天資料，併發送給每個連線的客戶端；服務端程式和客戶端程式都是通過父子程序分別負責傳送和接收資料的，以避免資料衝撞；需按以下格式呼叫客戶端程式：client

SpiFlash同步/非同步讀寫微控制器裸機例項

微控制器裸機開發中會經常遇到外設速度過慢，長時間讀忙等待，但CPU又不能長時間阻塞的問題。這種問題可以通過實現一個狀態機來非同步處理。非同步狀態機程式碼結構示例： enum { eIDLE = 0, eSTART, eWAIT, eSUCCESS }; st

boost asio非同步讀寫網路聊天室【官方示例】

相關推薦