项目——基于C/S架构的文件传输系统平台（2）——重构

前言：

我们已经完成了

环境搭建和 MySQL 数据库初始化

客户端基本框架（连接服务器、菜单打印、注册 / 登录）

数据库操作类的完整实现

二、TCP Socket 通信完整流程详解（必懂）

服务器（接电话的人）	动作	客户端（打电话的人）
买手机	`socket()` 创建套接字	买手机
绑定手机号	`bind()` 绑定地址和端口	无
开机等电话	`listen()` 开始监听	无
接电话	`accept()` 接受连接	打电话 `connect()` 发起连接
通话	`recv()`/`send()` 收发数据	通话
挂电话	`close()` 关闭套接字	挂电话

重点理解：

服务器必须先启动，等待客户端连接

accept()会创建一个新的套接字 （就是int c），专门和这个客户端通信

原来的监听套接字继续等待其他客户端连接

三、服务器端

3.1 服务器实现文件（server/server.cpp）

先写 Server 类的核心实现：

cpp 复制代码

#include "server.h"


Server::Server() {
    cout << "服务器启动中..." << endl;
    ip = "127.0.0.1";  
    port = 6000;     
    sockfd = -1;       
    base = NULL;        
}

Server::Server(string ip, int port) {
    this->ip = ip;
    this->port = port;
    sockfd = -1;
    base = NULL;
}


Server::~Server() {
    cout << "服务器关闭" << endl;
    if (sockfd != -1) {
        close(sockfd);  
    }
    if (base != NULL) {
        event_base_free(base);  // 释放Libevent事件基础
    }
}

//创建监听套接字
bool Server::Create_Socket() {
   
    sockfd = socket(AF_INET, SOCK_STREAM, 0);
    if (-1 == sockfd) {
        perror("socket create failed");  
        return false;
    }

    // 重点：设置端口复用
    // 解决服务器重启后"地址已被使用"的问题
    int opt = 1;
    setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 2. 填充服务器地址结构
    struct sockaddr_in saddr;
    memset(&saddr, 0, sizeof(saddr));  // 清空结构，防止垃圾数据
    saddr.sin_family = AF_INET;        // 地址族：IPv4
    saddr.sin_port = htons(port);      // 端口号：主机字节序转网络字节序
    // INADDR_ANY：监听所有网卡的地址
    saddr.sin_addr.s_addr = htonl(INADDR_ANY);

    // 3. 绑定地址和端口到套接字
    int res = bind(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));
    if (-1 == res) {
        perror("bind failed");
        close(sockfd);
        return false;
    }

    // 4. 开始监听客户端连接
    // LIS_MAX：监听队列的最大长度，即同时等待连接的客户端数量
    res = listen(sockfd, LIS_MAX);
    if (-1 == res) {
        perror("listen failed");
        close(sockfd);
        return false;
    }

    cout << "监听套接字创建成功，端口：" << port << endl;
    return true;
}

// 初始化Libevent事件驱动框架
bool Server::Libevent_Init() {
    // 1. 创建事件基础对象（Libevent的核心，管理所有事件）
    // 相当于Libevent的"大脑"
    base = event_base_new();
    if (nullptr == base) {
        cout << "event_base_new failed" << endl;
        return false;
    }

    // 2. 创建监听套接字的读事件
    // 参数说明：
    // base：事件基础对象
    // sockfd：要监听的文件描述符（监听套接字）
    // EV_READ：监听读事件（有客户端连接时触发）
    // EV_PERSIST：持久事件，触发后不会自动删除
    // Accept_CallBack：事件触发时的回调函数
    // this：传递给回调函数的参数（当前Server对象的指针）
    struct event* sock_ev = event_new(base, sockfd, 
                                     EV_READ | EV_PERSIST, 
                                     Accept_CallBack, 
                                     static_cast<void*>(this));
    if (sock_ev == nullptr) {
        cout << "event_new failed" << endl;
        return false;
    }

    // 3. 将事件添加到事件基础中，开始监听
    event_add(sock_ev, nullptr);

    cout << "Libevent初始化成功" << endl;
    return true;
}

// 服务器总初始化函数
bool Server::Ser_Init() {
    // 1. 创建文件存储根目录（如果不存在）
    if (access(PATH.c_str(), F_OK) == -1) {
        if (mkdir(PATH.c_str(), 0775) == -1) {
            cout << "创建根目录失败：" << PATH << endl;
            return false;
        }
        cout << "创建文件根目录：" << PATH << endl;
    }

    // 2. 创建监听套接字
    if (!Create_Socket()) {
        return false;
    }

    // 3. 初始化Libevent
    if (!Libevent_Init()) {
        return false;
    }

    return true;
}

// 接受客户端连接
bool Server::Accept_Client() {
    // 接受一个新的客户端连接
    // 返回值：新的套接字（int c），专门和这个客户端通信
    int c = accept(sockfd, NULL, NULL);
    if (c == -1) {
        perror("accept failed");
        return false;
    }

    cout << "新客户端连接成功，套接字：" << c << endl;

    // ⚠️ 重点：为每个新客户端创建一个Con_Client对象
    // 这个对象会管理这个客户端的所有状态
    Con_Client* p = new Con_Client(c, base);

    // 为这个客户端创建读事件，监听它发来的数据
    struct event* c_ev = event_new(base, c, 
                                  EV_READ | EV_PERSIST, 
                                  Read_CallBack, 
                                  static_cast<void*>(p));
    if (c_ev == NULL) {
        delete p;
        close(c);
        return false;
    }

    // 将事件对象保存到Con_Client中，方便后续释放
    p->Set_event(c_ev);

    // 将事件添加到事件基础中，开始监听这个客户端的数据
    event_add(c_ev, NULL);

    return true;
}

// 启动服务器事件循环（阻塞函数，一直运行）
void Server::Run() {
    cout << "服务器启动成功，开始监听客户端连接..." << endl;
    // 启动事件循环，等待事件发生
    // 这个函数会一直阻塞，直到event_base被销毁
    event_base_dispatch(base);
}

/************************** 全局回调函数 **************************/

// 监听套接字的读事件回调：有新客户端连接时触发
void Accept_CallBack(int fd, short event, void* arg) {
    // 将void*参数转换回Server对象指针
    Server* ser = static_cast<Server*>(arg);
    // 调用Server类的Accept_Client方法接受连接
    ser->Accept_Client();
}

// 客户端套接字的读事件回调：有客户端发来数据时触发
void Read_CallBack(int fd, short event, void* arg) {
    // 将void*参数转换回Con_Client对象指针
    Con_Client* cli = static_cast<Con_Client*>(arg);
    // 调用Con_Client类的Recv_Data方法接收数据
    cli->Recv_Data();
}

重点代码讲解：

setsockopt(SO_REUSEADDR)：非常重要！解决服务器重启后 "地址已被使用" 的问题，因为 TCP 有 TIME_WAIT 状态，端口不会立即释放。
event_base：Libevent 的核心，相当于一个事件管理器，所有事件都要注册到它上面。
event_new()：创建一个事件对象，指定要监听的文件描述符、事件类型和回调函数。
回调函数：Libevent 是事件驱动的，当事件发生时，会自动调用你注册的回调函数。
每个客户端一个 Con_Client 对象：这是面向对象设计的精髓，把每个客户端的状态和行为封装在一起。

3.2 Con_Client 类核心实现