Muduo 网络编程示例之一：五个简单 TCP 协议

关注

原创最新推荐文章于 2026-05-01 12:11:23 发布 2w 阅读 AI 写同款· GEO 优化 ›

Muduo 网络编程示例之零：前言我将会写一系列文章，介绍用 muduo 网络库完成常见的 TCP 网络编程任务。这些例子都比较简单，逻辑不复杂，代码也很短，适合摘取关键部分放到博客上。其中一些有一定的代表性与针对性，比如“如何传输完整的文件”估计是网络编程的初学者经常遇到的问题。阅读详情

陈硕 (giantchen_AT_gmail)

Blog.youkuaiyun.com/Solstice

这是《Muduo 网络编程示例》系列的第一篇文章。

全系列文章列表： http://blog.youkuaiyun.com/Solstice/category/779646.aspx

本文将介绍第一个示例：五个简单 TCP 网络服务协议，包括 echo (RFC 862)、discard (RFC 863)、chargen (RFC 864)、daytime (RFC 867)、time (RFC 868)，以及 time 协议的客户端。各协议的功能简介如下：

discard - 丢弃所有收到的数据；
daytime - 服务端 accept 连接之后，以字符串形式发送当前时间，然后主动断开连接；
time - 服务端 accept 连接之后，以二进制形式发送当前时间（从 Epoch 到现在的秒数），然后主动断开连接；我们需要一个客户程序来把收到的时间转换为字符串。
echo - 回显服务，把收到的数据发回客户端；
chargen - 服务端 accept 连接之后，不停地发送测试数据。

以上五个协议使用不同的端口，可以放到同一个进程中实现，且不必使用多线程。完整的代码见 muduo/examples/simple，下载地址 http://muduo.googlecode.com/files/muduo-0.1.6-alpha.tar.gz 。

discard

Discard 恐怕算是最简单的长连接 TCP 应用层协议，它只需要关注“三个半事件”中的“消息/数据到达”事件，事件处理函数如下：

   1: void DiscardServer::onMessage(const muduo::net::TcpConnectionPtr& conn,

   2:                  muduo::net::Buffer* buf,

   3:                  muduo::Timestamp time)

   4: {

   5:   string msg(buf->retrieveAsString());  // 取回读到的全部数据

   6:   LOG_INFO << conn->name() << " discards " << msg.size() << " bytes at " << time.toString();

   7: }

剩下的都是例行公事的代码：

定义一个 DiscardServer class，以 TcpServer 为成员。

   1: #ifndef MUDUO_EXAMPLES_SIMPLE_DISCARD_DISCARD_H

   2: #define MUDUO_EXAMPLES_SIMPLE_DISCARD_DISCARD_H

3:

   4: #include

5:

   6: // RFC 863

   7: class DiscardServer

   8: {

   9:  public:

  10:   DiscardServer(muduo::net::EventLoop* loop,

  11:                 const muduo::net::InetAddress& listenAddr);

12:

  13:   void start();

14:

  15:  private:

  16:   void onConnection(const muduo::net::TcpConnectionPtr& conn);

17:

  18:   void onMessage(const muduo::net::TcpConnectionPtr& conn,

  19:                  muduo::net::Buffer* buf,

  20:                  muduo::Timestamp time);

21:

  22:   muduo::net::EventLoop* loop_;

  23:   muduo::net::TcpServer server_;

  24: };

25:

  26: #endif  // MUDUO_EXAMPLES_SIMPLE_DISCARD_DISCARD_H

注册回调函数

   1: DiscardServer::DiscardServer(muduo::net::EventLoop* loop,

   2:                              const muduo::net::InetAddress& listenAddr)

   3:   : loop_(loop),

   4:     server_(loop, listenAddr, "DiscardServer")

   5: {

   6:   server_.setConnectionCallback(

   7:       boost::bind(&DiscardServer::onConnection, this, _1));

   8:   server_.setMessageCallback(

   9:       boost::bind(&DiscardServer::onMessage, this, _1, _2, _3));

  10: }

11:

  12: void DiscardServer::start()

  13: {

  14:   server_.start();

  15: }

处理连接与数据事件

   1: void DiscardServer::onConnection(const muduo::net::TcpConnectionPtr& conn)

   2: {

   3:   LOG_INFO << "DiscardServer - " << conn->peerAddress().toHostPort() << " -> "

   4:     << conn->localAddress().toHostPort() << " is "

   5:     << (conn->connected() ? "UP" : "DOWN");

   6: }

7:

   8: void DiscardServer::onMessage(const muduo::net::TcpConnectionPtr& conn,

   9:                  muduo::net::Buffer* buf,

  10:                  muduo::Timestamp time)

  11: {

  12:   string msg(buf->retrieveAsString());

  13:   LOG_INFO << conn->name() << " discards " << msg.size() << " bytes at " << time.toString();

  14: }

在 main() 里用 EventLoop 让整个程序转起来

   1: #include "discard.h"

2:

   3: #include

   4: #include

5:

   6: using namespace muduo;

   7: using namespace muduo::net;

8:

   9: int main()

  10: {

  11:   LOG_INFO << "pid = " << getpid();

  12:   EventLoop loop;

  13:   InetAddress listenAddr(2009);

  14:   DiscardServer server(&loop, listenAddr);

  15:   server.start();

  16:   loop.loop();

  17: }

daytime

Daytime 是短连接协议，在发送完当前时间后，由服务端主动断开连接。它只需要关注“三个半事件”中的“连接已建立”事件，事件处理函数如下：

   1: void DaytimeServer::onConnection(const muduo::net::TcpConnectionPtr& conn)

   2: {

   3:   LOG_INFO << "DaytimeServer - " << conn->peerAddress().toHostPort() << " -> "

   4:     << conn->localAddress().toHostPort() << " is "

   5:     << (conn->connected() ? "UP" : "DOWN");

   6:   if (conn->connected())

   7:   {

   8:     conn->send(Timestamp::now().toFormattedString() + "/n"); // 发送时间字符串

   9:     conn->shutdown(); // 主动断开连接

  10:   }

  11: }

剩下的都是例行公事的代码，为节省篇幅，此处从略，请阅读 muduo/examples/simple/daytime。

用 netcat 扮演客户端，运行结果如下：

$ nc 127.0.0.1 2013
2011-02-02 03:31:26.622647 # 服务器返回的时间字符串

time

Time 协议与 daytime 极为类似，只不过它返回的不是日期时间字符串，而是一个 32-bit 整数，表示从 1970-01-01 00:00:00Z 到现在的秒数。当然，这个协议有“2038 年问题”。服务端只需要关注“三个半事件”中的“连接已建立”事件，事件处理函数如下：

   1: void TimeServer::onConnection(const muduo::net::TcpConnectionPtr& conn)

   2: {

   3:   LOG_INFO << "TimeServer - " << conn->peerAddress().toHostPort() << " -> "

   4:     << conn->localAddress().toHostPort() << " is "

   5:     << (conn->connected() ? "UP" : "DOWN");

   6:   if (conn->connected())

   7:   {

   8:     int32_t now = sockets::hostToNetwork32(static_cast<int>(::time(NULL)));

   9:     conn->send(&now, sizeof now);  // 发送 4 个字节

  10:     conn->shutdown();  // 主动断开连接

  11:   }

  12: }

剩下的都是例行公事的代码，为节省篇幅，此处从略，请阅读 muduo/examples/simple/time。

用 netcat 扮演客户端，并用 hexdump 来打印二进制数据，运行结果如下：

$ nc 127.0.0.1 2037 | hexdump -C
00000000 4d 48 d0 d5 |MHÐÕ|
00000004

time_client

因为 time 服务端发送的是二进制数据，不便直接阅读，我们编写一个客户端来解析并打印收到的 4 个字节数据。这个程序只需要关注“三个半事件”中的“消息/数据到达”事件，事件处理函数如下：

   1: void TimeClient::onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp receiveTime)

   2: {

   3:   if (buf->readableBytes() >= sizeof(int32_t))

   4:   {

   5:     const void* data = buf->peek();

   6:     int32_t time = *static_cast<const int32_t*>(data);

   7:     buf->retrieve(sizeof(int32_t));

   8:     time_t servertime = sockets::networkToHost32(time);

   9:     Timestamp t(servertime * Timestamp::kMicroSecondsPerSecond);

  10:     LOG_INFO << "Server time = " << servertime << ", " << t.toFormattedString();

  11:   }

  12:   else

  13:   {

  14:     LOG_INFO << conn->name() << " no enough data " << buf->readableBytes()

  15:      << " at " << receiveTime.toFormattedString();

  16:   }

  17: }

注意其中考虑到了如果数据没有一次性收全，已经收到的数据会暂存在 Buffer 里，以等待下一次机会，程序也不会阻塞。这样即便服务器一个字节一个字节地发送数据，代码还是能正常工作，这也是非阻塞网络编程必须在用户态使用接受缓冲的主要原因。

这是我们第一次用到 TcpClient class，完整的代码如下：

   1: #include

   2: #include

   3: #include

   4: #include

   5: #include

6:

   7: #include

8:

   9: #include

10:

  11: #include

  12: #include

13:

  14: using namespace muduo;

  15: using namespace muduo::net;

16:

  17: class TimeClient : boost::noncopyable

  18: {

  19:  public:

  20:   TimeClient(EventLoop* loop, const InetAddress& listenAddr)

  21:     : loop_(loop),

  22:       client_(loop, listenAddr, "TimeClient")

  23:   {

  24:     client_.setConnectionCallback(

  25:         boost::bind(&TimeClient::onConnection, this, _1));

  26:     client_.setMessageCallback(

  27:         boost::bind(&TimeClient::onMessage, this, _1, _2, _3));

  28:     // client_.enableRetry();

  29:   }

30:

  31:   void connect()

  32:   {

  33:     client_.connect();

  34:   }

35:

  36:  private:

  37:   void onConnection(const TcpConnectionPtr& conn)

  38:   {

  39:     LOG_INFO << conn->localAddress().toHostPort() << " -> "

  40:         << conn->peerAddress().toHostPort() << " is "

  41:         << (conn->connected() ? "UP" : "DOWN");

42:

  43:     if (!conn->connected())  // 如果连接断开，则终止主循环，退出程序

  44:       loop_->quit();

  45:   }

46:

  47:   void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp receiveTime)

  48:   {

  49:     if (buf->readableBytes() >= sizeof(int32_t))

  50:     {

  51:       const void* data = buf->peek();

  52:       int32_t time = *static_cast<const int32_t*>(data);

  53:       buf->retrieve(sizeof(int32_t));

  54:       time_t servertime = sockets::networkToHost32(time);

  55:       Timestamp t(servertime * Timestamp::kMicroSecondsPerSecond);

  56:       LOG_INFO << "Server time = " << servertime << ", " << t.toFormattedString();

  57:     }

  58:     else

  59:     {

  60:       LOG_INFO << conn->name() << " no enough data " << buf->readableBytes()

  61:        << " at " << receiveTime.toFormattedString();

  62:     }

  63:   }

64:

  65:   EventLoop* loop_;

  66:   TcpClient client_;

  67: };

68:

  69: int main(int argc, char* argv[])

  70: {

  71:   LOG_INFO << "pid = " << getpid();

  72:   if (argc > 1)

  73:   {

  74:     EventLoop loop;

  75:     InetAddress serverAddr(argv[1], 2037);

76:

  77:     TimeClient timeClient(&loop, serverAddr);

  78:     timeClient.connect();

  79:     loop.loop();

  80:   }

  81:   else

  82:   {

  83:     printf("Usage: %s host_ip/n", argv[0]);

  84:   }

  85: }

程序的运行结果如下，假设 time server 运行在本机：

$ ./simple_timeclient 127.0.0.1
2011-02-02 04:10:35.181717 4296 INFO pid = 4296 - timeclient.cc:71
2011-02-02 04:10:35.183668 4296 INFO TcpClient::connect[TimeClient] - connecting to 127.0.0.1:2037 - TcpClient.cc:60
2011-02-02 04:10:35.185178 4296 INFO 127.0.0.1:40960 -> 127.0.0.1:2037 is UP - timeclient.cc:39
2011-02-02 04:10:35.185279 4296 INFO Server time = 1296619835, 2011-02-02 04:10:35.000000 - timeclient.cc:56
2011-02-02 04:10:35.185354 4296 INFO 127.0.0.1:40960 -> 127.0.0.1:2037 is DOWN - timeclient.cc:39

echo

Echo 是我们遇到的第一个带交互的协议：服务端把客户端发过来的数据原封不动地传回去。它只需要关注“三个半事件”中的“消息/数据到达”事件，事件处理函数如下：

   1: void EchoServer::onMessage(const TcpConnectionPtr& conn,

   2:                            Buffer* buf,

   3:                            Timestamp time)

   4: {

   5:   string msg(buf->retrieveAsString());

   6:   LOG_INFO << conn->name() << " echo " << msg.size() << " bytes at " << time.toString();

   7:   conn->send(msg);

   8: }

这段代码实现的不是行回显(line echo)服务，而是有一点数据就发送一点数据。这样可以避免客户端恶意地不发送换行字符，而服务端又必须缓存已经收到的数据，导致服务器内存暴涨。但这个程序还是有一个安全漏洞，即如果客户端故意不断发生数据，但从不接收，那么服务端的发送缓冲区会一直堆积，导致内存暴涨。解决办法可以参考下面的 chargen 协议。

剩下的都是例行公事的代码，为节省篇幅，此处从略，请阅读 muduo/examples/simple/echo。

练习 1：修改 EchoServer::onMessage()，实现大小写互换。

练习 2：修改 EchoServer::onMessage()，实现 rot13 加密。

chargen

Chargen 协议很特殊，它只发送数据，不接收数据。而且，它发送数据的速度不能快过客户端接收的速度，因此需要关注“三个半事件”中的半个“消息/数据发送完毕”事件(onWriteComplete)，事件处理函数如下：

   1: void ChargenServer::onConnection(const muduo::net::TcpConnectionPtr& conn)

   2: {

   3:   LOG_INFO << "ChargenServer - " << conn->peerAddress().toHostPort() << " -> "

   4:     << conn->localAddress().toHostPort() << " is "

   5:     << (conn->connected() ? "UP" : "DOWN");

   6:   if (conn->connected())

   7:   {

   8:     conn->send(message_);  // 在连接建立时发生第一次数据

   9:   }

  10: }

11:

  12: void ChargenServer::onMessage(const muduo::net::TcpConnectionPtr& conn,

  13:                  muduo::net::Buffer* buf,

  14:                  muduo::Timestamp time)

  15: {

  16:   string msg(buf->retrieveAsString());

  17:   LOG_INFO << conn->name() << " discards " << msg.size() << " bytes at " << time.toString();

  18: }

19:

  20: void ChargenServer::onWriteComplete(const TcpConnectionPtr& conn)

  21: {

  22:   transferred_ += message_.size();

  23:   conn->send(message_);  // 继续发送数据

  24: }

剩下的都是例行公事的代码，为节省篇幅，此处从略，请阅读 muduo/examples/simple/chargen。

完整的 chargen 服务端还带流量统计功能，用到了定时器，我们会在下一篇文章里介绍定时器的使用，到时候再回头来看相关代码。

用 netcat 扮演客户端，运行结果如下：

$ nc localhost 2019 | head
!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefgh
"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghi
#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghij
$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghijk
%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghijkl
&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghijklm
'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghijklmn
()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghijklmno
)*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghijklmnop
*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[/]^_`abcdefghijklmnopq

Five in one

前面五个程序都用到了 EventLoop，这其实是个 Reactor，用于注册和分发 IO 事件。Muduo 遵循 one loop per thread 模型，多个服务端(TcpServer)和客户端(TcpClient)可以共享同一个 EventLoop，也可以分配到多个 EventLoop 上以发挥多核多线程的好处。这里我们把五个服务端用同一个 EventLoop 跑起来，程序还是单线程的，功能却强大了很多：

   1: #include "../chargen/chargen.h"

   2: #include "../daytime/daytime.h"

   3: #include "../discard/discard.h"

   4: #include "../echo/echo.h"

   5: #include "../time/time.h"

6:

   7: #include

   8: #include

9:

  10: #include

11:

  12: using namespace muduo;

  13: using namespace muduo::net;

14:

  15: int main()

  16: {

  17:   LOG_INFO << "pid = " << getpid();

  18:   EventLoop loop;

19:

  20:   ChargenServer ChargenServer(&loop, InetAddress(2019));

  21:   ChargenServer.start();

22:

  23:   DaytimeServer daytimeServer(&loop, InetAddress(2013));

  24:   daytimeServer.start();

25:

  26:   DiscardServer discardServer(&loop, InetAddress(2009));

  27:   discardServer.start();

28:

  29:   EchoServer echoServer(&loop, InetAddress(2007));

  30:   echoServer.start();

31:

  32:   TimeServer timeServer(&loop, InetAddress(2037));

  33:   timeServer.start();

34:

  35:   loop.loop();

  36: }

以上几个协议的消息格式都非常简单，没有涉及 TCP 网络编程中常见的分包处理，在下一篇文章讲 Boost.Asio 的聊天服务器时我们再来讨论这个问题。

(待续)

收录于

c++

muduo

标签

#网络 #编程 #tcp #buffer #server

Muduo 网络编程示例之二：Boost.Asio 的聊天服务器这是《Muduo 网络编程示例》系列的第二篇文章。本文讲介绍一个与 Boost.Asio 的示例代码中的聊天服务器功能类似的网络服务程序，包括客户端与服务端的 muduo 实现。这个例子的主要目的是介绍如何处理分包，并初步涉及 Muduo 的多线程功能。阅读详情