2. 程式人生 > >Boost.Asio C++ 網路程式設計之五：TCP回顯客戶端/服務端

Boost.Asio C++ 網路程式設計之五：TCP回顯客戶端/服務端

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

       回顯就是服務端將接收到的任何內容回發給客戶端顯示，然後關閉客戶端的連線。這個服務端可以處理任何數量的客戶端。每個客戶端連線之後傳送一個訊息，服務端接收到訊息後把它傳送回去。在那之後，服務端關閉連線。具體流程如下圖所示。


       對於TCP而言，我們需要一個額外的保證：每一個訊息以換行符結束(‘\n’)。編寫一個同步回顯服務端/客戶端非常簡單。下面我們分別實現同步客戶端，同步服務端，非同步客戶端和非同步服務端。

一.TCP同步客戶端

#ifdef WIN32
#define _WIN32_WINNT 0x0501
#include <stdio.h>
#endif

#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
using namespace boost::asio;
using boost::system::error_code;
io_service service;

size_t read_complete(char * buf, const error_code & err, size_t bytes) {
	if (err) return 0;
	bool found = std::find(buf, buf + bytes, '\n') < buf + bytes;
	// 一個一個字元的讀取，直到回車, 不快取
	return found ? 0 : 1;
}

ip::tcp::endpoint ep(ip::address::from_string("127.0.0.1"), 8001);
void sync_echo(std::string msg) {
	msg += "\n";
	ip::tcp::socket sock(service);
	sock.connect(ep);
	sock.write_some(buffer(msg));
	char buf[1024];
	int bytes = read(sock, buffer(buf), boost::bind(read_complete, buf, _1, _2));
	std::string copy(buf, bytes - 1);
	msg = msg.substr(0, msg.size() - 1);
	std::cout << "server echoed our " << msg << ": "
		<< (copy == msg ? "OK" : "FAIL") << std::endl;
	sock.close();
}

int main(int argc, char* argv[]) {
	// 連線多個客戶端
	char* messages[] = { "Can", "ge", "ge", "blog!", 0 };
	boost::thread_group threads;
	for (char ** message = messages; *message; ++message) {
		threads.create_thread(boost::bind(sync_echo, *message));
		boost::this_thread::sleep(boost::posix_time::millisec(100));
	}
	threads.join_all();

	system("pause");
}
       你會發現，在讀取時，我使用了自由函式（不屬於socket類，屬於名稱空間asio）read()，因為我想要讀‘\n’之前的所有內容。sock.read_some()方法滿足不了這個要求，因為它只會讀可用的，不一定是整個的訊息。
       read(stream, buffer [, completion])這個方法同步地從一個流中讀取資料。你可以選擇指定一個完成處理方法。完成處理方法會在每次read操作呼叫成功之後呼叫，然後告訴read操作是否完成（如果沒有完成，它會繼續讀取）。它的格式是：size_t completion(const boost::system::error_code& err, size_t bytes_transfered) 。當這個完成處理方法返回0時，我們認為read操作完成；如果它返回一個非0值，它表示了下一次sock.read_some操作需要從流中讀取的位元組數。

       read_complete一個個的讀取字元，直到回車，這是通過std::find方法控制的，std::find的行為大概如下。

template<class InputIterator, class T>
  InputIterator find (InputIterator first, InputIterator last, const T& val)
{
  while (first!=last) {
    if (*first==val) return first;
    ++first;
  }
  return last;
}
       結合到上面客戶端程式碼就是，如果沒有找到回車'\n'，std::find始終返回buf+bytes，否則返回'\n'的地址，也就是buf+bytes-1，此時'\n'是已讀取內容的最後一個字元。
       注意：因為我們是同步的，所以不需要呼叫service.run()。

二.TCP同步服務端

#ifdef WIN32
#define _WIN32_WINNT 0x0501
#include <stdio.h>
#endif

#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
using namespace boost::asio;
using namespace boost::posix_time;
using boost::system::error_code;


io_service service;
size_t read_complete(char * buff, const error_code & err, size_t bytes) {
    if ( err) return 0;
    bool found = std::find(buff, buff + bytes, '\n') < buff + bytes;
    // we read one-by-one until we get to enter, no buffering
    return found ? 0 : 1;
}


void handle_connections() {
    ip::tcp::acceptor acceptor(service, ip::tcp::endpoint(ip::tcp::v4(),8001));
    char buff[1024];
    while ( true) {
        ip::tcp::socket sock(service);
        acceptor.accept(sock);
        int bytes = read(sock, buffer(buff), 
                    boost::bind(read_complete,buff,_1,_2));
        std::string msg(buff, bytes);
        sock.write_some(buffer(msg));
        sock.close();
    }
}


int main(int argc, char* argv[]) {
    handle_connections();
}
       服務端的邏輯主要在handle_connections()。因為是單執行緒，它接受一個客戶端請求，讀取客戶端傳送的訊息，然後回發給客戶端，接著等待下一個連線。可以確定，當兩個客戶端同時連線時，第二個客戶端需要等待服務端處理完第一個客戶端的請求。

       還是要注意因為我們是同步的，所以不需要呼叫service.run()。

       下面是客戶端回顯的結果，當然要先啟動服務端。


三.TCP非同步客戶端

#ifdef WIN32
#define _WIN32_WINNT 0x0501
#include <stdio.h>
#endif

#include <boost/thread.hpp>
#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
using namespace boost::asio;
io_service service;

#define MEM_FN(x)       boost::bind(&self_type::x, shared_from_this())
#define MEM_FN1(x,y)    boost::bind(&self_type::x, shared_from_this(),y)
#define MEM_FN2(x,y,z)  boost::bind(&self_type::x, shared_from_this(),y,z)

class talk_to_svr : public boost::enable_shared_from_this<talk_to_svr>
	, boost::noncopyable {
	typedef talk_to_svr self_type;
	talk_to_svr(const std::string & message)
		: sock_(service), started_(true), message_(message) {}
	void start(ip::tcp::endpoint ep) {
		sock_.async_connect(ep, MEM_FN1(on_connect, _1));
	}
public:
	typedef boost::system::error_code error_code;
	typedef boost::shared_ptr<talk_to_svr> ptr;

	static ptr start(ip::tcp::endpoint ep, const std::string & message) {
		ptr new_(new talk_to_svr(message));
		new_->start(ep);
		return new_;
	}
	void stop() {
		if (!started_) return;
		started_ = false;
		sock_.close();
	}
	bool started() { return started_; }
private:
	void on_connect(const error_code & err) {
		if (!err)      do_write(message_ + "\n");
		else            stop();
	}
	void on_read(const error_code & err, size_t bytes) {
		if (!err) {
			std::string copy(read_buffer_, bytes - 1);
			std::cout << "server echoed our " << message_ << ": "
				<< (copy == message_ ? "OK" : "FAIL") << std::endl;
		}
		stop();
	}

	void on_write(const error_code & err, size_t bytes) {
		do_read();
	}
	void do_read() {
		async_read(sock_, buffer(read_buffer_),
			MEM_FN2(read_complete, _1, _2), MEM_FN2(on_read, _1, _2));
	}
	void do_write(const std::string & msg) {
		if (!started()) return;
		std::copy(msg.begin(), msg.end(), write_buffer_);
		sock_.async_write_some(buffer(write_buffer_, msg.size()),
			MEM_FN2(on_write, _1, _2));
	}
	size_t read_complete(const boost::system::error_code & err, size_t bytes) {
		if (err) return 0;
		bool found = std::find(read_buffer_, read_buffer_ + bytes, '\n') < read_buffer_ + bytes;
		return found ? 0 : 1;
	}

private:
	ip::tcp::socket sock_;
	enum { max_msg = 1024 };
	char read_buffer_[max_msg];
	char write_buffer_[max_msg];
	bool started_;
	std::string message_;
};

int main(int argc, char* argv[]) {
	ip::tcp::endpoint ep(ip::address::from_string("127.0.0.1"), 8001);
	char* messages[] = { "Can", "ge", "ge", "blog", 0 };
	for (char ** message = messages; *message; ++message) {
		talk_to_svr::start(ep, *message);
		boost::this_thread::sleep(boost::posix_time::millisec(100));
	}
	service.run();
	system("pause");
}
四.TCP非同步服務端 
#ifdef WIN32
#define _WIN32_WINNT 0x0501
#include <stdio.h>
#endif

#include <boost/bind.hpp>
#include <boost/asio.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
using namespace boost::asio;
using namespace boost::posix_time;
io_service service;

#define MEM_FN(x)       boost::bind(&self_type::x, shared_from_this())
#define MEM_FN1(x,y)    boost::bind(&self_type::x, shared_from_this(),y)
#define MEM_FN2(x,y,z)  boost::bind(&self_type::x, shared_from_this(),y,z)


class talk_to_client : public boost::enable_shared_from_this<talk_to_client>, boost::noncopyable {
	typedef talk_to_client self_type;
	talk_to_client() : sock_(service), started_(false) {}
public:
	typedef boost::system::error_code error_code;
	typedef boost::shared_ptr<talk_to_client> ptr;

	void start() {
		started_ = true;
		do_read();
	}
	static ptr new_() {
		ptr new_(new talk_to_client);
		return new_;
	}
	void stop() {
		if (!started_) return;
		started_ = false;
		sock_.close();
	}
	ip::tcp::socket & sock() { return sock_; }
private:
	void on_read(const error_code & err, size_t bytes) {
		if (!err) {
			std::string msg(read_buffer_, bytes);
			// echo message back, and then stop
			do_write(msg + "\n");
		}
		stop();
	}

	void on_write(const error_code & err, size_t bytes) {
		do_read();
	}
	void do_read() {
		async_read(sock_, buffer(read_buffer_),
			MEM_FN2(read_complete, _1, _2), MEM_FN2(on_read, _1, _2));
	}
	void do_write(const std::string & msg) {
		std::copy(msg.begin(), msg.end(), write_buffer_);
		sock_.async_write_some(buffer(write_buffer_, msg.size()),
			MEM_FN2(on_write, _1, _2));
	}
	size_t read_complete(const boost::system::error_code & err, size_t bytes) {
		if (err) return 0;
		bool found = std::find(read_buffer_, read_buffer_ + bytes, '\n') < read_buffer_ + bytes;
		// we read one-by-one until we get to enter, no buffering
		return found ? 0 : 1;
	}
private:
	ip::tcp::socket sock_;
	enum { max_msg = 1024 };
	char read_buffer_[max_msg];
	char write_buffer_[max_msg];
	bool started_;
};

ip::tcp::acceptor acceptor(service, ip::tcp::endpoint(ip::tcp::v4(), 8001));

void handle_accept(talk_to_client::ptr client, const boost::system::error_code & err) {
	client->start();
	talk_to_client::ptr new_client = talk_to_client::new_();
	acceptor.async_accept(new_client->sock(), boost::bind(handle_accept, new_client, _1));
}


int main(int argc, char* argv[]) {
	talk_to_client::ptr client = talk_to_client::new_();
	acceptor.async_accept(client->sock(), boost::bind(handle_accept, client, _1));
	service.run();
}
      TCP非同步客戶端和非同步服務端的關鍵是enable_shared_from_this模板類的使用，關於enable_shared_from_this詳見：C++11新特性之十一：enable_shared_from_this，C++11和boost的enable_shared_from_this功能和原理一樣。

       客戶端回顯結果和同步時的一樣，如下：





相關推薦

Boost.Asio C++ 網路程式設計之五：TCP回顯客戶端/服務端

       回顯就是服務端將接收到的任何內容回發給客戶端顯示，然後關閉客戶端的連線。這個服務端可以處理任何數量的客戶端。每個客戶端連線之後傳送一個訊息，服務端接收到訊息後把它傳送回去。在那之後，服務端關閉連線。具體流程如下圖所示。        對於TCP而言，我們需要

Boost.Asio C++ 網路程式設計之十：基於TCP的非同步服務端

       這個流程圖是相當複雜的：從Boost.Asio出來你可以看到4個箭頭指向on_accept，on_read，on_write和on_check_ping。這也就意味著你永遠不知道哪個非同步呼叫是下一個完成的呼叫，但是你可以確定的是它是這4個操作中的一個。基於TC

Boost.Asio C++ 網路程式設計之七：基於TCP的同步客戶端

      從本篇開始，我們會深入學習怎樣使用Boost.Asio建立更加複雜的客戶端和服務端應用。你可以執行並測試它們，而且在理解之後，你可以把它們做為框架來構造自己的應用。在接下來的例子中：1.客戶

Boost.Asio C++ 網路程式設計之二：同步和非同步

       首先，非同步程式設計和同步程式設計是截然不同的。在同步程式設計中，所有的操作都是順序執行的，比如從socket中讀取（請求），然後寫入（迴應）到socket中。每一個操作都是阻塞的。因為操作是阻塞的，所以為了不影響主程式，當在socket上讀寫時，通常會建立一個

Boost.Asio C++ 網路程式設計之九：基於TCP的非同步客戶端

       現在，是比較有趣（也比較難）的非同步實現！ 當檢視流程圖時，你需要知道Boost.Asio代表由Boost.Asio執行的一個非同步呼叫。例如do_read()，Boost.Asio和on_read()代表了從do_read()到on_read()的邏輯流程，

Boost.Asio c++ 網路程式設計翻譯（30）［完結］

本地socket是一種只能被執行在主機上的應用訪問的socket。你可以使用本地socket來實現簡單的程序間通訊。你可以用客戶端或者服務端的方式來連線兩端。對於本地socket，端點時一個檔案，比如/tmp/whatever。很酷的一件事情是你可以給指定的檔案賦予許可權，從而禁止機器上指定的使用者在檔案上建

Boost.Asio c++ 網路程式設計翻譯（6）

io_service類 你應該已經發現大部分使用Boost.Asio編寫的程式碼都會使用幾個ios_service的例項。ios_service是這個庫裡面最重要的類；它負責和作業系統打交道，等待所有非同步操作的結束，然後為每一個非同步操作呼叫完成處理程式。 如果你選擇用同

Python3 與 C# 網路程式設計之～ 網路基礎篇

最新版本檢視：https://www.cnblogs.com/dotnetcrazy/p/9919202.html 入門篇 官方文件：https://docs.python.org/3/library/ipc.html（程序間通訊和網路） 例項程式碼：https://github.com/lotapp/

洞悉C++網路程式設計之tcp/ip和socket api

原文地址：https://blog.csdn.net/libaineu2004/article/details/79020403 TCP(Transmission Control Protocol)　傳輸控制協議 三次握手 TCP是主機對主機層的傳輸控制協議，提供可靠的連線服務，採用三次

腦殘式網路程式設計入門(五)：每天都在用的Ping命令，它到底是什麼？

本文引用了公眾號純潔的微笑作者奎哥的技術文章，感謝原作者的分享。 1、前言 老於網路程式設計熟手來說，在測試和部署網路通訊應用（比如IM聊天、實時音視訊等）時，如果發現網路連線超時，第一時間想到的就是使用Ping命令Ping一下伺服器看看通不通。甚至在有些情況下通過圖

c++ 網路程式設計之socket

windows 10 structures sockaddr, sockaddr_in sockaddr 和 sockaddr_in 同樣都是為了處理網路通訊的地址，包含了地址類別（familty），地址（ip），埠資訊。 sockaddr是給機器用的，

Linux-C網路程式設計之epoll函式

上文中說到如果從100的不同的地方取外賣，那麼epoll相當於一部手機，當外賣到達後，送貨員可以通知你，從而達到每去必得，少走很多路。 它是如何實現這些作用的呢？ epoll的功能 epoll是select/poll的強化版，同是多路複用的函式，epoll

C++網路程式設計之select

select函式決定一個或者多個套接字（socket）的狀態，如果需要的話，等待執行非同步I/O。 int select(               __in        int    nfds,               __inout    fd_set *readfds,            

C# 網路程式設計之基於SMTP傳送電子郵件

        本文主要講述基於C#網路程式設計的傳送郵件的程式設計,郵件傳送功能是基於郵件協議的,常見的電子郵件協議有SMTP(簡單郵件傳輸協議)、POP3(郵局協議)、IMAP(Internet郵件訪問協議),文章主要參考周存傑的《C#網路程式設計例項教程》.這也是最後

C#網路程式設計之---TCP協議的同步通訊（二）

上一篇學習日記C#網路程式設計之--TCP協議（一）中以服務端接受客戶端的請求連線結尾 既然服務端已經與客戶端建立了連線，那麼溝通通道已經打通，載滿資料的小火車就可以彼此傳送和接收了。現在讓我們來看看資料的傳送與接收 先把服務端與客戶端的連線程式碼敲出來 服務端 IPAddress ip = new IP

C# 網路程式設計之webBrowser亂碼問題及解決知識

       在使用PHP+MySQL編寫網頁時，曾近就因為顯示中文亂碼”口口口？？？”困擾我很長時間,沒想到在C#製作瀏覽器或獲取XML頁面時也經常會遇到顯示中文亂碼的問題，可想而知怎樣解決編碼問題

Linux 下 C 網路程式設計之 多執行緒通訊 例項

簡單示例，有不對的地方，歡迎指點。 伺服器端 /* ============================================================================ Name : sockThreadServer

linux c/c++網路程式設計之—select模型

1.select 模型是一個比較傳統的非同步IO模型，我們知道的著名的apache就是基於select模型，而我之前工作過的搜狐暢遊的天龍八部，還有幾款遊戲都是基於select模型。 對於select模型，大多都是說他的缺點，實際上我的觀點有點不一樣，select模型的跨平

網路程式設計之二：java.net包的Socket和SocketServer

    寫網路程式設計這一章，初衷是為了講訴HttpClient、Jetty、Netty的使用心得，NIO和BIO的比較，Thrift和Avro等，無奈今天被合作伙伴鄙視了，他看到我用了Apache的Httpclient（C)+Jetty（S），說：你只不過是傳一些資料，用Socket多簡單迅速，我們的量一天

C# 網路程式設計之最簡單瀏覽器實現

      最近學習C#網路程式設計的HTTP協議程式設計，HTTP即Hypertext Transfer Protocol的縮寫，意為：超文字傳輸協議。其中與HTTP相關的知識主要有六個類的知識，分