基于 Linux epoll ET 模式的 Reactor 网络服务器实现

Reactor 反应堆模式

Reactor 反应堆模式是一种事件驱动的设计模式，通常用于处理高并发的 I/O 操作，尤其是在服务器或网络编程中。

基本概念

Reactor 模式又称之为响应器模式，基于事件多路复用机制，使得单个线程能够同时管理大量并发连接，而不需要为每个连接创建一个独立的线程。它通过一个事件分发器（Reactor）来监听和管理不同的 I/O 事件，当事件发生时，分发器会将该事件分发给对应的事件处理器来处理。

核心组件

• 事件分发器（Reactor）：负责监听各种事件源（如 socket、文件描述符）并将事件分发给相应的处理器。事件分发器通常使用 I/O 多路复用机制（如 select、poll、epoll）来同时监听多个 I/O 事件。
• 事件处理器（Event Handler）：定义了如何处理特定事件。当事件分发器检测到某个事件时，就会触发相应的事件处理器中的回调函数。
• 同步事件分离器（Demultiplexer）：本质上是系统调用，用于监听事件源上的事件，并将事件通知给事件分发器。例如，在 Linux 中，可以使用 select、poll 或 epoll 等系统调用来实现同步事件分离器。

工作流程

• 注册事件：事件分发器注册需要监听的 I/O 事件（如连接、读写），并关联相应的事件处理器。
• 进入循环：事件分发器进入循环，使用 I/O 多路复用机制来监听注册的 I/O 事件。
• 分发事件：一旦某个 I/O 事件发生，事件分发器会将该事件分发给对应的事件处理器。
• 处理事件：事件处理器执行预定义的操作来处理该事件。处理完成后，可能会重新注册事件或关闭连接。

epoll 服务器 (ET)

服务器监听一个指定的端口，当有新的连接请求到来时，服务器接受连接并将其注册到 Reactor 中，以便处理后续的数据读写事件。

Socket.hpp

包含了一个抽象基类 Socket 和一个继承自 Socket 的具体实现类 TcpSocket。提供一个面向对象的网络套接字编程接口，允许用户通过继承和实现基类中的纯虚函数来创建不同类型的套接字（例如 TCP 套接字）。

#include <iostream>
#include <string>
#include <functional>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <unistd.h>
#include 






 socket_ns {
 ;
   gbacklog = ; 
 socket_sptr = std::shared_ptr<Socket>; 
 { SOCKET_ERROR = , BIND_ERROR, LISTEN_ERROR, USAGE_ERROR };

  {
:
    = ; 
    = ; 
    = ; 
    = ; 
    = ; 
    = ; 
    = ; 
    = ; 
    = ; 

:
    
    {
        ();
        (addr);
        ();
    }
    {
        ();
         (addr);
    }
};

  :  Socket {
:
    ( sockfd = ) : _sockfd(sockfd) {}

    {
        _sockfd = (AF_INET, SOCK_STREAM, );
         (_sockfd < ) {
            (FATAL, );
            (SOCKET_ERROR);
        }
        (_sockfd);
        (DEBUG, , _sockfd);
    }

    {
          local;
        (&local, , (local));
        local.sin_family = AF_INET;
        local.sin_port = (addr.());
        local.sin_addr.s_addr = (addr.().());
         n = (_sockfd, ( sockaddr*)&local, (local));
         (n < ) {
            (FATAL, );
            (BIND_ERROR);
        }
        (DEBUG, , _sockfd);
    }

    {
         n = (_sockfd, gbacklog);
         (n < ) {
            (FATAL, );
            (LISTEN_ERROR);
        }
        (DEBUG, , _sockfd);
    }

    {
          peer;
         len = (peer);
         sockfd = (_sockfd, ( sockaddr*)&peer, &len);
        *code = errno;
         (sockfd < ) {
            (WARNING, );
             ;
        }
        *addr = peer;
        (sockfd);
         sockfd;
    }

    {
          server;
        (&server, , (server));
        server.sin_family = AF_INET;
        server.sin_addr.s_addr = (addr.().());
        server.sin_port = (addr.());
         n = (_sockfd, ( sockaddr*)&server, (server));
         (n < ) {
            std::cerr <<  << std::endl;
             ;
        }
         ;
    }

    {
         inbuffer[];
         n = (_sockfd, inbuffer, (inbuffer) - , );
         (n > ) {
            inbuffer[n] = ;
            *out += inbuffer;
        }
         n;
    }

    {
         n = (_sockfd, in.(), in.(), );
         n;
    }

    {
         _sockfd;
    }

    {
         (_sockfd > )
            ::(_sockfd);
    }

    ~() {}

:
     _sockfd;
};
}