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

最新推荐文章于 2024-02-27 11:46:51 发布
最新推荐文章于 2024-02-27 11:46:51 发布 · 121 阅读 · 0
文章标签：

#网络协议 #编程 #网络应用 #.net #应用服务器

本文介绍了Muduo网络库中的五个简单TCP服务示例，包括discard、daytime、time、echo和chargen协议。这些示例展示了如何使用Muduo库实现不同类型的网络服务。

陈硕 (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,
<!--CRLF--> 
   2:                  muduo::net::Buffer* buf,
<!--CRLF--> 
   3:                  muduo::Timestamp time)
<!--CRLF--> 
   4: {
<!--CRLF--> 
   5:   string msg(buf->retrieveAsString());  // 取回读到的全部数据
<!--CRLF--> 
   6:   LOG_INFO << conn->name() << " discards " << msg.size() << " bytes at " << time.toString();
<!--CRLF--> 
   7: }
剩下的都是例行公事的代码：
定义一个 DiscardServer class，以 TcpServer 为成员。
   1: #ifndef MUDUO_EXAMPLES_SIMPLE_DISCARD_DISCARD_H
<!--CRLF--> 
   2: #define MUDUO_EXAMPLES_SIMPLE_DISCARD_DISCARD_H
<!--CRLF--> 
   3:
<!--CRLF--> 
   4: #include
<!--CRLF--> 
   5:
<!--CRLF--> 
   6: // RFC 863
<!--CRLF--> 
   7: class DiscardServer
<!--CRLF--> 
   8: {
<!--CRLF--> 
   9:  public:
<!--CRLF--> 
  10:   DiscardServer(muduo::net::EventLoop* loop,
<!--CRLF--> 
  11:                 const muduo::net::InetAddress& listenAddr);
<!--CRLF--> 
  12:
<!--CRLF--> 
  13:   void start();
<!--CRLF--> 
  14:
<!--CRLF--> 
  15:  private:
<!--CRLF--> 
  16:   void onConnection(const muduo::net::TcpConnectionPtr& conn);
<!--CRLF--> 
  17:
<!--CRLF--> 
  18:   void onMessage(const muduo::net::TcpConnectionPtr& conn,
<!--CRLF--> 
  19:                  muduo::net::Buffer* buf,
<!--CRLF--> 
  20:                  muduo::Timestamp time);
<!--CRLF--> 
  21:
<!--CRLF--> 
  22:   muduo::net::EventLoop* loop_;
<!--CRLF--> 
  23:   muduo::net::TcpServer server_;
<!--CRLF--> 
  24: };
<!--CRLF--> 
  25:
<!--CRLF--> 
  26: #endif  // MUDUO_EXAMPLES_SIMPLE_DISCARD_DISCARD_H
注册回调函数
   1: DiscardServer::DiscardServer(muduo::net::EventLoop* loop,
<!--CRLF--> 
   2:                              const muduo::net::InetAddress& listenAddr)
<!--CRLF--> 
   3:   : loop_(loop),
<!--CRLF--> 
   4:     server_(loop, listenAddr, "DiscardServer")
<!--CRLF--> 
   5: {
<!--CRLF--> 
   6:   server_.setConnectionCallback(
<!--CRLF--> 
   7:       boost::bind(&DiscardServer::onConnection, this, _1));
<!--CRLF--> 
   8:   server_.setMessageCallback(
<!--CRLF--> 
   9:       boost::bind(&DiscardServer::onMessage, this, _1, _2, _3));
<!--CRLF--> 
  10: }
<!--CRLF--> 
  11:
<!--CRLF--> 
  12: void DiscardServer::start()
<!--CRLF--> 
  13: {
<!--CRLF--> 
  14:   server_.start();
<!--CRLF--> 
  15: }
<!--CRLF--> 
处理连接与数据事件
   1: void DiscardServer::onConnection(const muduo::net::TcpConnectionPtr& conn)
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:   LOG_INFO << "DiscardServer - " << conn->peerAddress().toHostPort() << " -> "
<!--CRLF--> 
   4:     << conn->localAddress().toHostPort() << " is "
<!--CRLF--> 
   5:     << (conn->connected() ? "UP" : "DOWN");
<!--CRLF--> 
   6: }
<!--CRLF--> 
   7:
<!--CRLF--> 
   8: void DiscardServer::onMessage(const muduo::net::TcpConnectionPtr& conn,
<!--CRLF--> 
   9:                  muduo::net::Buffer* buf,
<!--CRLF--> 
  10:                  muduo::Timestamp time)
<!--CRLF--> 
  11: {
<!--CRLF--> 
  12:   string msg(buf->retrieveAsString());
<!--CRLF--> 
  13:   LOG_INFO << conn->name() << " discards " << msg.size() << " bytes at " << time.toString();
<!--CRLF--> 
  14: }
<!--CRLF--> 
在 main() 里用 EventLoop 让整个程序转起来
   1: #include "discard.h"
<!--CRLF--> 
   2:
<!--CRLF--> 
   3: #include
<!--CRLF--> 
   4: #include
<!--CRLF--> 
   5:
<!--CRLF--> 
   6: using namespace muduo;
<!--CRLF--> 
   7: using namespace muduo::net;
<!--CRLF--> 
   8:
<!--CRLF--> 
   9: int main()
<!--CRLF--> 
  10: {
<!--CRLF--> 
  11:   LOG_INFO << "pid = " << getpid();
<!--CRLF--> 
  12:   EventLoop loop;
<!--CRLF--> 
  13:   InetAddress listenAddr(2009);
<!--CRLF--> 
  14:   DiscardServer server(&loop, listenAddr);
<!--CRLF--> 
  15:   server.start();
<!--CRLF--> 
  16:   loop.loop();
<!--CRLF--> 
  17: }
<!--CRLF-->
<!--CRLF-->
<!--CRLF-->

daytime

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

   1: void DaytimeServer::onConnection(const muduo::net::TcpConnectionPtr& conn)
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:   LOG_INFO << "DaytimeServer - " << conn->peerAddress().toHostPort() << " -> "
<!--CRLF--> 
   4:     << conn->localAddress().toHostPort() << " is "
<!--CRLF--> 
   5:     << (conn->connected() ? "UP" : "DOWN");
<!--CRLF--> 
   6:   if (conn->connected())
<!--CRLF--> 
   7:   {
<!--CRLF--> 
   8:     conn->send(Timestamp::now().toFormattedString() + "\n"); // 发送时间字符串
<!--CRLF--> 
   9:     conn->shutdown(); // 主动断开连接
<!--CRLF--> 
  10:   }
<!--CRLF--> 
  11: }
<!--CRLF-->

剩下的都是例行公事的代码，为节省篇幅，此处从略，请阅读 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)
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:   LOG_INFO << "TimeServer - " << conn->peerAddress().toHostPort() << " -> "
<!--CRLF--> 
   4:     << conn->localAddress().toHostPort() << " is "
<!--CRLF--> 
   5:     << (conn->connected() ? "UP" : "DOWN");
<!--CRLF--> 
   6:   if (conn->connected())
<!--CRLF--> 
   7:   {
<!--CRLF--> 
   8:     int32_t now = sockets::hostToNetwork32(static_cast<int>(::time(NULL)));
<!--CRLF--> 
   9:     conn->send(&now, sizeof now);  // 发送 4 个字节
<!--CRLF--> 
  10:     conn->shutdown();  // 主动断开连接
<!--CRLF--> 
  11:   }
<!--CRLF--> 
  12: }
<!--CRLF-->

剩下的都是例行公事的代码，为节省篇幅，此处从略，请阅读 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)
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:   if (buf->readableBytes() >= sizeof(int32_t))
<!--CRLF--> 
   4:   {
<!--CRLF--> 
   5:     const void* data = buf->peek();
<!--CRLF--> 
   6:     int32_t time = *static_cast<const int32_t*>(data);
<!--CRLF--> 
   7:     buf->retrieve(sizeof(int32_t));
<!--CRLF--> 
   8:     time_t servertime = sockets::networkToHost32(time);
<!--CRLF--> 
   9:     Timestamp t(servertime * Timestamp::kMicroSecondsPerSecond);
<!--CRLF--> 
  10:     LOG_INFO << "Server time = " << servertime << ", " << t.toFormattedString();
<!--CRLF--> 
  11:   }
<!--CRLF--> 
  12:   else
<!--CRLF--> 
  13:   {
<!--CRLF--> 
  14:     LOG_INFO << conn->name() << " no enough data " << buf->readableBytes()
<!--CRLF--> 
  15:      << " at " << receiveTime.toFormattedString();
<!--CRLF--> 
  16:   }
<!--CRLF--> 
  17: }
<!--CRLF-->

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

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

   1: #include
<!--CRLF--> 
   2: #include
<!--CRLF--> 
   3: #include
<!--CRLF--> 
   4: #include
<!--CRLF--> 
   5: #include
<!--CRLF--> 
   6:
<!--CRLF--> 
   7: #include
<!--CRLF--> 
   8:
<!--CRLF--> 
   9: #include
<!--CRLF--> 
  10:
<!--CRLF--> 
  11: #include
<!--CRLF--> 
  12: #include
<!--CRLF--> 
  13:
<!--CRLF--> 
  14: using namespace muduo;
<!--CRLF--> 
  15: using namespace muduo::net;
<!--CRLF--> 
  16:
<!--CRLF--> 
  17: class TimeClient : boost::noncopyable
<!--CRLF--> 
  18: {
<!--CRLF--> 
  19:  public:
<!--CRLF--> 
  20:   TimeClient(EventLoop* loop, const InetAddress& listenAddr)
<!--CRLF--> 
  21:     : loop_(loop),
<!--CRLF--> 
  22:       client_(loop, listenAddr, "TimeClient")
<!--CRLF--> 
  23:   {
<!--CRLF--> 
  24:     client_.setConnectionCallback(
<!--CRLF--> 
  25:         boost::bind(&TimeClient::onConnection, this, _1));
<!--CRLF--> 
  26:     client_.setMessageCallback(
<!--CRLF--> 
  27:         boost::bind(&TimeClient::onMessage, this, _1, _2, _3));
<!--CRLF--> 
  28:     // client_.enableRetry();
<!--CRLF--> 
  29:   }
<!--CRLF--> 
  30:
<!--CRLF--> 
  31:   void connect()
<!--CRLF--> 
  32:   {
<!--CRLF--> 
  33:     client_.connect();
<!--CRLF--> 
  34:   }
<!--CRLF--> 
  35:
<!--CRLF--> 
  36:  private:
<!--CRLF--> 
  37:   void onConnection(const TcpConnectionPtr& conn)
<!--CRLF--> 
  38:   {
<!--CRLF--> 
  39:     LOG_INFO << conn->localAddress().toHostPort() << " -> "
<!--CRLF--> 
  40:         << conn->peerAddress().toHostPort() << " is "
<!--CRLF--> 
  41:         << (conn->connected() ? "UP" : "DOWN");
<!--CRLF--> 
  42:
<!--CRLF--> 
  43:     if (!conn->connected())  // 如果连接断开，则终止主循环，退出程序
<!--CRLF--> 
  44:       loop_->quit();
<!--CRLF--> 
  45:   }
<!--CRLF--> 
  46:
<!--CRLF--> 
  47:   void onMessage(const TcpConnectionPtr& conn, Buffer* buf, Timestamp receiveTime)
<!--CRLF--> 
  48:   {
<!--CRLF--> 
  49:     if (buf->readableBytes() >= sizeof(int32_t))
<!--CRLF--> 
  50:     {
<!--CRLF--> 
  51:       const void* data = buf->peek();
<!--CRLF--> 
  52:       int32_t time = *static_cast<const int32_t*>(data);
<!--CRLF--> 
  53:       buf->retrieve(sizeof(int32_t));
<!--CRLF--> 
  54:       time_t servertime = sockets::networkToHost32(time);
<!--CRLF--> 
  55:       Timestamp t(servertime * Timestamp::kMicroSecondsPerSecond);
<!--CRLF--> 
  56:       LOG_INFO << "Server time = " << servertime << ", " << t.toFormattedString();
<!--CRLF--> 
  57:     }
<!--CRLF--> 
  58:     else
<!--CRLF--> 
  59:     {
<!--CRLF--> 
  60:       LOG_INFO << conn->name() << " no enough data " << buf->readableBytes()
<!--CRLF--> 
  61:        << " at " << receiveTime.toFormattedString();
<!--CRLF--> 
  62:     }
<!--CRLF--> 
  63:   }
<!--CRLF--> 
  64:
<!--CRLF--> 
  65:   EventLoop* loop_;
<!--CRLF--> 
  66:   TcpClient client_;
<!--CRLF--> 
  67: };
<!--CRLF--> 
  68:
<!--CRLF--> 
  69: int main(int argc, char* argv[])
<!--CRLF--> 
  70: {
<!--CRLF--> 
  71:   LOG_INFO << "pid = " << getpid();
<!--CRLF--> 
  72:   if (argc > 1)
<!--CRLF--> 
  73:   {
<!--CRLF--> 
  74:     EventLoop loop;
<!--CRLF--> 
  75:     InetAddress serverAddr(argv[1], 2037);
<!--CRLF--> 
  76:
<!--CRLF--> 
  77:     TimeClient timeClient(&loop, serverAddr);
<!--CRLF--> 
  78:     timeClient.connect();
<!--CRLF--> 
  79:     loop.loop();
<!--CRLF--> 
  80:   }
<!--CRLF--> 
  81:   else
<!--CRLF--> 
  82:   {
<!--CRLF--> 
  83:     printf("Usage: %s host_ip\n", argv[0]);
<!--CRLF--> 
  84:   }
<!--CRLF--> 
  85: }
<!--CRLF-->

程序的运行结果如下，假设 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,
<!--CRLF--> 
   2:                            Buffer* buf,
<!--CRLF--> 
   3:                            Timestamp time)
<!--CRLF--> 
   4: {
<!--CRLF--> 
   5:   string msg(buf->retrieveAsString());
<!--CRLF--> 
   6:   LOG_INFO << conn->name() << " echo " << msg.size() << " bytes at " << time.toString();
<!--CRLF--> 
   7:   conn->send(msg);
<!--CRLF--> 
   8: }
<!--CRLF-->

这段代码实现的不是行回显(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)
<!--CRLF--> 
   2: {
<!--CRLF--> 
   3:   LOG_INFO << "ChargenServer - " << conn->peerAddress().toHostPort() << " -> "
<!--CRLF--> 
   4:     << conn->localAddress().toHostPort() << " is "
<!--CRLF--> 
   5:     << (conn->connected() ? "UP" : "DOWN");
<!--CRLF--> 
   6:   if (conn->connected())
<!--CRLF--> 
   7:   {
<!--CRLF--> 
   8:     conn->send(message_);  // 在连接建立时发生第一次数据
<!--CRLF--> 
   9:   }
<!--CRLF--> 
  10: }
<!--CRLF--> 
  11:
<!--CRLF--> 
  12: void ChargenServer::onMessage(const muduo::net::TcpConnectionPtr& conn,
<!--CRLF--> 
  13:                  muduo::net::Buffer* buf,
<!--CRLF--> 
  14:                  muduo::Timestamp time)
<!--CRLF--> 
  15: {
<!--CRLF--> 
  16:   string msg(buf->retrieveAsString());
<!--CRLF--> 
  17:   LOG_INFO << conn->name() << " discards " << msg.size() << " bytes at " << time.toString();
<!--CRLF--> 
  18: }
<!--CRLF--> 
  19:
<!--CRLF--> 
  20: void ChargenServer::onWriteComplete(const TcpConnectionPtr& conn)
<!--CRLF--> 
  21: {
<!--CRLF--> 
  22:   transferred_ += message_.size();
<!--CRLF--> 
  23:   conn->send(message_);  // 继续发送数据
<!--CRLF--> 
  24: }
<!--CRLF-->

剩下的都是例行公事的代码，为节省篇幅，此处从略，请阅读 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"
<!--CRLF--> 
   2: #include "../daytime/daytime.h"
<!--CRLF--> 
   3: #include "../discard/discard.h"
<!--CRLF--> 
   4: #include "../echo/echo.h"
<!--CRLF--> 
   5: #include "../time/time.h"
<!--CRLF--> 
   6:
<!--CRLF--> 
   7: #include
<!--CRLF--> 
   8: #include
<!--CRLF--> 
   9:
<!--CRLF--> 
  10: #include
<!--CRLF--> 
  11:
<!--CRLF--> 
  12: using namespace muduo;
<!--CRLF--> 
  13: using namespace muduo::net;
<!--CRLF--> 
  14:
<!--CRLF--> 
  15: int main()
<!--CRLF--> 
  16: {
<!--CRLF--> 
  17:   LOG_INFO << "pid = " << getpid();
<!--CRLF--> 
  18:   EventLoop loop;
<!--CRLF--> 
  19:
<!--CRLF--> 
  20:   ChargenServer ChargenServer(&loop, InetAddress(2019));
<!--CRLF--> 
  21:   ChargenServer.start();
<!--CRLF--> 
  22:
<!--CRLF--> 
  23:   DaytimeServer daytimeServer(&loop, InetAddress(2013));
<!--CRLF--> 
  24:   daytimeServer.start();
<!--CRLF--> 
  25:
<!--CRLF--> 
  26:   DiscardServer discardServer(&loop, InetAddress(2009));
<!--CRLF--> 
  27:   discardServer.start();
<!--CRLF--> 
  28:
<!--CRLF--> 
  29:   EchoServer echoServer(&loop, InetAddress(2007));
<!--CRLF--> 
  30:   echoServer.start();
<!--CRLF--> 
  31:
<!--CRLF--> 
  32:   TimeServer timeServer(&loop, InetAddress(2037));
<!--CRLF--> 
  33:   timeServer.start();
<!--CRLF--> 
  34:
<!--CRLF--> 
  35:   loop.loop();
<!--CRLF--> 
  36: }
<!--CRLF-->

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

(待续)

iteye_8595
关注
C++ - 仿 RabbitMQ 实现消息队列--muduo快速上手
2301_80079840的博客
07-15 1165
public:public:/// 当一个新连接建立成功的时候被调用/// 消息的业务处理回调函数---这是收到新连接消息的时候被调用的函数构造函数：loop：进行事件监控的对象。listenAddr：绑定的ip，port。nameArg：服务器的名称。option：是否启用端口复用，默认不启用。setThreadNum：设置线程数目。start：启动服务器。setConnectionCallback：设置收到新链接的时候要调用的回调函数。
Muduo 网络编程示例之零：前言
热门推荐
陈硕的Blog
02-02 4万+
我将会写一系列文章，介绍用 muduo 网络库完成常见的 TCP 网络编程任务。这些例子都比较简单，逻辑不复杂，代码也很短，适合摘取关键部分放到博客上。其中一些有一定的代表性与针对性，比如“如何传输完整的文件”估计是网络编程的初学者经常遇到的问题。
TCP协议示例
sghuu的博客
07-29 239
## 标题 TCP协议示例 代码示例1：客户端发送信息给服务端，服务端将数据显示在控制台上 //客户端 @Test public void client() { Socket socket = null; OutputStream os = null; try { //1.创建Socket对象，指明服务器端的...
TCP协议实现网络通信简单例子
ALsoAm
03-24 659
TCP协议实现网络通信简单例子
TCP 协议文件传输示例
Blog???
06-23 2539
一个简单的传输的例子 单线程 阻塞模式.   用 bcc32.exe 可直接编译通过. 以下是发送端代码 send.cpp//---------------------------------------------------------------------------#include #include "winsock2.h"using namespac
Muduo 网络编程示例之十：socks4a 代理服务器
陈硕的Blog
06-02 2万+
本文介绍用 muduo 实现一个简单的 socks4a 代理服务器，代码见 http://code.google.com/p/muduo/source/browse/trunk/examples/socks4a/ 。
Muduo 网络编程示例之九：简单的消息广播服务
陈硕的Blog
05-25 2万+
本文介绍用 muduo 实现一个简单的 topic-based 消息广播服务，这其实是“聊天室”的一个简单扩展，不过聊天的不是人，而是分布式系统中的程序。
Muduo 网络编程示例之四：Twisted Finger
陈硕的Blog
02-23 7646
Python Twisted 是一款非常好的网络库，它也采用 Reactor 作为网络编程的基本模型，所以从使用上与 muduo 颇有相似之处。（当然，muduo 没有 deferreds）Finger 是 twisted 文档的一个经典例子，本文展示如何用 muduo 来实现最简单的 finger 服务端。限于篇幅，只实现 finger01~07。代码位于 examples/twisted/finger 。
Muduo 网络编程示例之三：定时器
陈硕的Blog
02-06 1万+
本文介绍在非阻塞网络编程中定时器的用法与注意事项。
TCP协议重点总结（万字总结-附实例）
VIBE的博客
01-09 3949
开发与算法学习社区Killing Vibe的博客欢迎大家加入，一起交流学习~~以上就是TCP协议的万字总结，内容有点多，但每个知识点的细节博主都有举实例，帮助大家更好的理解，码字不易，有帮助的话大家可以起来慢慢看，有什么问题可以私信博主，大家交流一下。
TCP协议的原理分析与示例
qq_36594703的博客
09-05 414
TCP是一个可靠的协议，面向连接的协议 实现TCP程序，需要编写服务器端和客户端，java API为我们提供了java.net包，为实现网络应用程序提供类 serversocket此类实现服务器套接字 socket是网络驱动层提供给应用程序编程的接口和一种机制 数据发送过程： 产生socket，应用程序将要发送的数据传给socket，调用bind将socket的信息通知给驱动层，驱动程序
Linux多线程服务端编程：使用muduo C++网络库 学习笔记 附录A 谈一谈网络编程学习经验
最新发布
tus00000的博客
02-27 1149
本文谈一谈作者在学习网络编程方面的一些个人经验。“网络编程”这个术语的范围很广，本文指用Sockets API开发基于TCP/IP的网络应用程序，具体定义见A.1.5 “网络编程的各种任务角色”。 受限于作者的经历和经验，本附录的适应范围是： 1.x86-64 Linux服务端网络编程，直接或间接使用Sockets API。 2.公司内网。不一定是局域网，但总体位于公司防火墙之内，环境可控。 文本可能不适合： 1.PC客户端网络编程，程序运行在客户的PC上，环境多变且不可控。 2.Windows网络编程。
（P42）muduo库使用例子（一）：五个简单TCP协议，muduo库网络模型使用示例
喜欢打篮球的普通人
06-30 961
MuduoManual.pdf P50（1）echo - 回显服务，把收到的数据发回客户端eg测试：42\jmuduo\examples\simple\echo\echo.h 42\jmuduo\examples\simple\echo\main.cc 42\jmuduo\CMakeLists.txt测试：客户端使用nc 服务端 客户端退出后，服务端一个TcpConnection销毁了 （2）discard - 服务器端收到客户端发送过来的数据，丢弃所有收到的数据；eg：42\jmuduo\exampl
网络编程之TCP简单示例
sinat_36002055的博客
09-30 1060
转载地址 TCP网络编程关键函数： socket()、struct sockaddr_in、htons()、htonl()、socklen_t、bind()、listen()、accept()、recv()、connect()、send() 传输层协议:TCP协议(打电话)面向于有连接的通信方式 例题： 使用网络通信TCP协议，实现不同主机之间的通信 主机A---主机B Jack.c Rose.c 核心代码 Rose.c 服务器 创建未连接TCP套接字 int fd = socket(AF_IN
muduo编程示例之五个简单TCP示例
瞧，那小子真帅
05-29 574
文章目录前言五个简单TCP1. discard2.daytime3. echo4. time5. chargen 前言 五个简单TCP示例，分别是echo,discard， 插入跟， daytime， time。简介如下： discard： 丢弃所有收到的数据。 daytime：服务端accept连接之后，以字符串形式发送当前时间，然后主动断开连接。 time：服务端accept连接之后，以二进制形式发送当前时间，然后主动断开连接，我们需要一个客户程序来把收到的时间转换为字符串。 echo：回显服务，把收到
Linux多线程服务端编程：使用muduo C++网络库 学习笔记 第七章 muduo编程示例（上）
tus00000的博客
11-02 589
本章将介绍如何用muduo网络库完成常见的TCP网络编程任务。内容如下： 1.[UNP]中的五个简单协议，包括echo、daytime、time、discard、chargen等。 2.文件传输，示范非阻塞TCP网络程序中如何完整地发送数据。 3.Boost.Asio中的示例，包括timer2~6、chat等。chat实现了TCP封包与拆包（codec，coder-decoder的简称，编解码器）。 4.muduo Buffer class的设计与使用。 5.Protobuf（Protobuf（Protoc
net6. 套接字封装类——Endian、SocketsOps、Socket、InetAddress
TABE_的博客
03-29 859
Endian.h 封装了字节序转换函数（全局函数，位于muduo::net::sockets名称空间中）。 SocketsOps.h/ SocketsOps.cc 封装了socket相关系统调用（全局函数，位于muduo::net::sockets名称空间中）。 Socket.h/Socket.cc（Socket类） 用RAII方法封装socket file descriptor。 InetAddress.h/InetAddress.cc（InetAddress类） 网际地址sockaddr_in封装。 1
端口基础常识大全
一溪云——云淡风清的陪伴
10-16 889
端口可分为3大类： 公认端口（Well Known Ports）：从0到1023，它们紧密绑定于一些服务。通常这些端口的通讯明确表明了某种服务的协议。例如：80端口实际上总是HTTP通讯。 注册端口（Registered Ports）：从1024到49151。它们松散地绑定于一些服务。也就是说有许多服务绑定于这些端口，这些端口同样用于许多其它目的。例如：许多系统处理动态
muduo网络库编程示例源码解析
muduo是一个基于C++开发的高性能网络库，它是由陈硕先生设计并开源的，主要用于Linux平台下的高并发网络服务器编程。muduo网络库采用非阻塞IO模型，通过事件驱动来处理网络事件，利用Reactor模式实现，能够高效地...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值