# 基于主从Reactor的高并发服务器组件

**Repository Path**: zlzelu/server

## Basic Information

- **Project Name**: 基于主从Reactor的高并发服务器组件
- **Description**: ⼀个基于主从Reactor模型的⾼并发服务器组件
- **Primary Language**: Unknown
- **License**: MulanPSL-2.0
- **Default Branch**: developW
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2025-08-21
- **Last Updated**: 2025-11-01

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# 高并发服务器组件使用文档

## 1. 组件概述

本组件是一个Linux环境下基于主从Reactor模型的高并发服务器框架，提供了底层的TCP连接管理、事件循环、线程池等核心功能，不依赖特定协议，允许用户自定义应用层协议和业务逻辑。

核心特点：
- 采用主从Reactor模式，支持高并发连接

- 内置事件循环机制，高效处理IO事件

- 支持连接超时管理

- 提供灵活的回调机制，方便用户扩展

## 2.安装

请确保您的系统已安装以下依赖：

- CMake
- GCC 或 Clang 编译器
- Git

然后运行以下命令来克隆并构建项目：

```bash
git clone https://gitee.com/zlzelu/server.git
cd server
cd 基于主从Reactor的高并发服务器/
cd 基于主从Reactor的高并发服务器/
cmake .
make
```

本项目虽然提供了CMakeLists.txt文件，但仍建议使用者在此基础上进行更改以适应自己需求或重写新的CMakeLists.txt.
```cmake
# 指定 CMake 最低版本要求
cmake_minimum_required(VERSION 2.8)
#find_package(Threads REQUIRED)

# 项目名称
project(server)


set(CMAKE_CXX_STANDARD 14)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11 -g -ggdb")
set(CMAKE_BUILD_TYPE "Debug")

# # 强制添加调试符号编译选项（确保 Debug/Release 模式都能保留调试信息，可选）
# #    -g：生成调试符号（GCC/Clang 通用，用于 GDB 调试）
# #    -ggdb：生成更适合 GDB 的调试信息（可选，增强 GDB 功能）
# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -ggdb")

# # 3. 禁用可能破坏调试信息的优化（Debug 模式默认 -O0，此处显式指定更稳妥）
# #    若需在 Release 模式保留调试信息，需将 -O0 改为 -O2（优化等级），同时保留 -g
set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -O0")


# 添加可执行文件（源文件列表）
add_executable(Server 
    ./testWebPage/test.cpp 
    ./source/Buffer.cpp 
    ./source/Channel.cpp 
    ./source/Poll.cpp 
    ./source/Connection.cpp 
    ./source/EventLoop.cpp 
    ./source/EventLoopThreadPool.cpp 
    ./source/EventLoopThread.cpp 
    ./source/Acceptor.cpp 
    ./source/TimerQueue.cpp 
    ./source/Socket.cpp 
    ./source/TcpServer.cpp 
    ./testProtocol/Http.cpp 
    ./source/Mmap.cpp 
    ./source/Base.cpp
    ./include/log/source/logLinux.cpp 
    ./include/log/source/lwLog.cpp 
)

target_link_libraries(Server PUBLIC pthread)

include_directories(
    ./include
    ./include/log/include)
```

## 使用

构建完成后，您可以通过运行以下命令启动服务器(当然，应用层协议与业务层仍需使用者自己构建，本项目并不包含实际的业务内容)：

```bash
./server
```

## 2. 核心类说明

### 2.1 TcpServer 类

服务器主类，负责监听端口、接受连接并分发到事件循环

```cpp
// 构造函数：指定监听端口
TcpServer::TcpServer(uint16_t port)

// 设置Reactor线程池大小
void setReactorThreadPoolCount(size_t count)

// 启动非活跃连接销毁（指定超时秒数）
void enableInactiveRelease(int sec)

// 添加定时任务
void addTimerTask(const Function& task, int sec)

// 启动服务器
void start()

// 设置各类回调函数
void setConnectedCallback(const connectedCallback& con)
void setMessageCallback(const messageCallback& msg)
void setClosedCallback(const closedCallback& close)
void setAnyEventCallback(const anyEventCallback& any)
```

### 2.2 Connection 类

连接类，每个TCP连接对应一个实例，负责数据的收发和事件处理

```cpp
// 获取socket描述符
socket_t getSockfd()

// 获取连接ID
uint64_t getConnectId()

// 设置协议上下文
void setProtocolContent(const Any& con)

// 获取协议上下文
Any* getProtocol()

// 发送数据
void Send(const std::string& data)

// 关闭连接
void shutdown()

// 启动/取消非活跃销毁
void enableInactiveRelease(int sec)
void cancelInactiveRelease()

// 协议切换（用于协议升级，如HTTP升级到WebSocket）
void changeProtocol(Any& protocol, const connectedCallback& conn, 
                   const messageCallback& msg, const closedCallback& closed, 
                   const anyEventCallback& event)
```

### 2.3 Eventloop 类

事件循环类，负责IO事件的监听和处理，是Reactor模型的核心

```cpp
// 启动事件循环
void start()

// 在事件循环中执行任务
void runInLoop(const Func& fun)

// 添加定时任务
void addTime(const Func& fun, double timeout, uint64_t id)

// 刷新定时任务
void refreshTime(uint64_t id)

// 取消定时任务
void cancelTime(uint64_t id)
```

## 3. 快速使用步骤

### 3.1 服务器初始化与启动

```cpp
// 创建服务器实例，指定端口
TcpServer server(8080);

// 设置Reactor线程池大小
server.setReactorThreadPoolCount(4);

// 设置连接超时（可选）
server.enableInactiveRelease(300); // 5分钟无活动则关闭连接

// 设置回调函数
server.setConnectedCallback([](const std::shared_ptr<Connection>& conn) {
    // 新连接建立时的处理
    std::cout << "New connection: " << conn->getSockfd() << std::endl;
});

server.setMessageCallback([](const std::shared_ptr<Connection>& conn, Buffer& buffer) {
    // 处理接收到的数据
    std::string data = buffer.readAll();
    std::cout << "Received data: " << data << std::endl;
    
    // 处理后回复数据
    conn->Send("Received: " + data);
});

server.setClosedCallback([](const std::shared_ptr<Connection>& conn) {
    // 连接关闭时的处理
    std::cout << "Connection closed: " << conn->getSockfd() << std::endl;
});

// 启动服务器
server.start();
```

### 3.2 自定义协议实现

通过`setProtocolContent`和`getProtocol`方法可以为每个连接设置自定义协议上下文，实现协议解析：

```cpp
// 定义自定义协议类
class MyProtocol {
public:
    // 解析缓冲区数据
    bool parse(Buffer& buffer) {
        // 实现协议解析逻辑
        // ...
        return true;
    }
    
    // 打包数据
    std::string pack(const std::string& data) {
        // 实现协议打包逻辑
        // ...
        return packedData;
    }
};

// 在连接建立时初始化协议
server.setConnectedCallback([](const std::shared_ptr<Connection>& conn) {
    // 为连接设置协议上下文
    conn->setProtocolContent(MyProtocol());
});

// 在消息回调中使用自定义协议解析
server.setMessageCallback([](const std::shared_ptr<Connection>& conn, Buffer& buffer) {
    // 获取协议实例
    MyProtocol* proto = conn->getProtocol()->get<MyProtocol>();
    
    // 解析数据
    if (proto->parse(buffer)) {
        // 处理解析后的数据
        // ...
        
        // 打包并发送响应
        std::string response = proto->pack("Processed");
        conn->Send(response);
    }
});
```

### 3.3 定时任务使用

```cpp
// 添加定时任务（每60秒执行一次）
server.addTimerTask([]() {
    std::cout << "Timer task executed" << std::endl;
}, 60);
```

## 4. 协议层实现

本项目提供了一个简易的Http协议的实现作为参考，使用者可根据相关接口自定义协议层与业务层的实现。