1
#pragma once
2
#include "Mutex.hpp"
3
#include <ctime>
4
#include <filesystem> //c++17文件系统库
5
#include <fstream>
6
#include <iostream>
7
#include <memory>
8
#include <sstream>
9
#include <string>
10
#include <unistd.h>
11

12
namespace LogModule {
13
    using namespace MutexModule;
14

15
    // 默认配置
16
    const std::string defaultpath = "./log/"; // 默认日志文件存放目录
17
    const std::string defaultname = "log.txt";
18

19
    // 日志等级定义
20
    enum class LogLevel {
21
        DEBUG,   // 调试信息
22
        INFO,    // 常规信息
23
        WARNING, // 警告信息
24
        ERROR,   // 错误信息
25
        FATAL    // 致命错误
26
    };
27

28
    // 将日志等级枚举转换为可读字符串
29
    std::string LogLevelToString(LogLevel level) {
30
        switch (level) {
31
        case LogLevel::DEBUG:
32
            return "DEBUG";
33
        case LogLevel::INFO:
34
            return "INFO";
35
        case LogLevel::WARNING:
36
            return "WARNING";
37
        case LogLevel::ERROR:
38
            return "ERROR";
39
        case LogLevel::FATAL:
40
            return "FATAL";
41
        default:
42
            return "UNKNOWN";
43
        }
44
    }
45

46
    // 获取当前时间的格式化字符串，如“2026-04-08 15:30:45”
47
    // 使用localttime_r 保证线程安全
48
    std::string GetCurrTime() {
49
        time_t tm = time(nullptr);
50
        struct tm curr; // tm 为<time.h>定义的一个结构体类型，用于表示时间的各个组成部分。
51
        localtime_r(&tm, &curr);
52

53
        char timebuffer[64];
54
        snprintf(timebuffer, sizeof(timebuffer), "%4d-%02d-%02d %02d:%02d:%02d",
55
                 curr.tm_year + 1900, curr.tm_mon + 1, curr.tm_mday,
56
                 curr.tm_hour, curr.tm_min, curr.tm_sec);
57
        return timebuffer;
58
    }
59

60
    // 策略模式：抽象基类
61
    // 定义日志输出策略的统一接口
62
    class LogStrategy {
63
    public:
64
        // 同步一条日志信息
65
        virtual void SyncLog(const std::string &message) = 0;
66
        virtual ~LogStrategy() = default;
67
    };
68

69
    // 控制台输出策略
70
    // 将日志输出到标准错误流（stderr）
71
    class ConsoleLogStrategy : public LogStrategy {
72
    public:
73
        void SyncLog(const std::string &message) override {
74
            LockGuard lockguard(_mutex);
75
            std::cerr << message << std::endl;
76
        }
77
        ~ConsoleLogStrategy() {}
78

79
    private:
80
        Mutex _mutex; // 保护cerr共享资源
81
    };
82

83
    // 文件输出策略
84
    // 将日志追加到指定路径的文件中
85
    class FileLogStrategy : public LogStrategy {
86
    public:
87
        // 构造
88
        FileLogStrategy(const std::string logpath = defaultpath, std::string logfilename = defaultname)
89
            : _logpath(logpath), _logfilename(logfilename) {
90
            LockGuard lockguard(_mutex);
91
            // 如果路径存在则不创建
92
            if (std::filesystem::exists(_logpath))
93
                return;
94
            // 捕获异常
95
            try {
96
                // 递归创建目录（例如 ./log/ 如果父目录不存在也会创建）
97
                std::filesystem::create_directories(_logpath);
98
            } catch (const std::filesystem::filesystem_error &e) {
99
                std::cerr << e.what() << "\n";
100
            }
101
        }
102

103
        void SyncLog(const std::string &message) override {
104
            LockGuard lockguard(_mutex);
105
            std::string fullpath = _logpath + _logfilename;
106
            // 以追加模式打开文件
107
            std::ofstream out(fullpath.c_str(), std::ios::app);
108
            if (!out.is_open())
109
                return;
110
            out << message << "\n";
111
            out.close();
112
        }
113
        ~FileLogStrategy() {}
114

115
        // 公开成员变量（允许外部调整路径）
116
        std::string _logpath;
117
        std::string _logfilename;
118
        Mutex _mutex;
119
    };
120

121
    // 日志器主类
122
    // 负责管理日志策略，并通过内部RAII类LogMassage完成日志的格式化与自动刷新
123
    class Logger {
124
    public:
125
        Logger() {
126
            // 默认使用控制台输出策略
127
            UseConsoleStrategy();
128
        }
129
        ~Logger() {}
130

131
        // 切换控制台策略
132
        void UseConsoleStrategy() {
133
            _strategy = std::make_unique<ConsoleLogStrategy>();
134
        }
135

136
        // 切换文件策略（使用默认路径/文件名）
137
        void UseFileStrategy() {
138
            _strategy = std::make_unique<FileLogStrategy>();
139
        }
140

141
        // 内部RAII类：代表一条完整的日志消息
142
        class LogMessage {
143
        private:
144
            LogLevel _type;         // 日志等级
145
            std::string _curr_time; // 日志产生的时间
146
            pid_t _pid;             // 进程id
147
            std::string _filename;  // 源代码文件
148
            int _line;              // 源代码行号
149
            Logger &_logger;        // 引入外部Logger，便于调用策略刷新
150
            std::string _loginfo;   // 最终拼接完整日志内容
151

152
        public:
153
            // 构造函数：构建日志头部（时间，等级，进程，id,文件名，行号）
154
            LogMessage(LogLevel type, const std::string &filename, int line, Logger &logger)
155
                : _type(type), _curr_time(GetCurrTime()), _pid(getpid()), _filename(filename), _line(line), _logger(logger) {
156
                std::stringstream ssbuffer;
157
                ssbuffer << "[" << _curr_time << "]"
158
                         << "[" << LogLevelToString(type) << "]"
159
                         << "[" << _pid << "]"
160
                         << "[" << _filename << "]"
161
                         << "[" << _line << "]"
162
                         << " - ";
163
                _loginfo = ssbuffer.str();
164
            }
165

166
            // 重载 << 操作符，支持流式追加任意类型的数据（模板实现）
167
            // 例如：LOG(INFO) << "value = " << 42;
168
            template <typename T>
169
            LogMessage &operator<<(const T &info) {
170
                std::stringstream ssbuffer;
171
                ssbuffer << info;
172
                _loginfo += ssbuffer.str();
173
                return *this; // 返回自身，支持连续<<
174
            }
175

176
            // 析构函数：当 LogMessage 临时对象生命周期结束时，
177
            // 自动调用策略的 SyncLog 将完整的日志持久化（输出到控制台或文件）
178
            ~LogMessage() {
179
                if (_logger._strategy) {
180
                    _logger._strategy->SyncLog(_loginfo);
181
                }
182
            }
183
        };
184

185
        // 仿函数：创建一个临时的 LogMessage 对象
186
        // 参数：日志等级、文件名、行号
187
        // 该对象会被 LOG 宏使用，宏会自动传入 __FILE__ 和 __LINE__
188
        LogMessage operator()(LogLevel type, std::string filename, int line) {
189
            return LogMessage(type, filename, line, *this);
190
        }
191

192
    private:
193
        std::unique_ptr<LogStrategy> _strategy; // 当前的日志输出策略
194
    };
195

196
    // 全局唯一的日志器实例（方便直接使用，无需手动创建对象）
197
    Logger logger;
198

199
// 宏定义
200
// 生成一条日志消息，自动注入文件名和行号
201
// 使用示例：LOG(LogLevel::INFO) << "Hello";
202
#define LOG(type) logger(type, __FILE__, __LINE__)
203

204
// 切换日志策略的宏
205
#define ENABLE_CONSOLE_LOG_STRATEGY() logger.UseConsoleStrategy()
206
#define ENABLE_FILE_LOG_STRATEGY() logger.UseFileStrategy()
207

208
} // namespace LogModule

1
#pragma once
2
#include <iostream>
3
#include <pthread.h>
4

5
namespace MutexModule {
6

7
    class Mutex {
8
    public:
9
        Mutex() {
10
            pthread_mutex_init(&_mutex, nullptr);
11
        }
12

13
        void Lock() {
14
            pthread_mutex_lock(&_mutex);
15
        }
16

17
        void Unlock() {
18
            pthread_mutex_unlock(&_mutex);
19
        }
20

21
        ~Mutex() {
22
            pthread_mutex_destroy(&_mutex);
23
        }
24

25
        pthread_mutex_t *Get() {
26
            return &_mutex;
27
        }
28

29
    private:
30
        pthread_mutex_t _mutex;
31
    };
32

33
    class LockGuard {
34
    public:
35
        // 在构造时自动加锁
36
        LockGuard(Mutex &mutex) : _mutex(mutex) {
37
            _mutex.Lock();
38
        }
39

40
        // 在析构时自动释放锁，防止死锁
41
        ~LockGuard() {
42
            _mutex.Unlock();
43
        }
44

45
    private:
46
        Mutex &_mutex;
47
    };
48

49
} // namespace MutexModule

1
#include "Mutex.hpp"
2
#include <iostream>
3
#include <pthread.h>
4

5
using namespace MutexModule;
6

7
namespace CondModule {
8

9
    class Cond {
10
    public:
11
        Cond() {
12
            pthread_cond_init(&_cond, nullptr);
13
        }
14

15
        // 这里的 Wait 需要传入一个封装好的 Mutex 对象
16
        void Wait(Mutex &mutex) {
17
            pthread_cond_wait(&_cond, mutex.Get());
18
        }
19

20
        // 唤醒条件变量下等待的一个线程
21
        void Signal() {
22
            pthread_cond_signal(&_cond);
23
        }
24

25
        // 唤醒所有在条件变量下等待的线程
26
        void Broadcast() {
27
            pthread_cond_broadcast(&_cond);
28
        }
29

30
        ~Cond() {
31
            pthread_cond_destroy(&_cond);
32
        }
33

34
    private:
35
        pthread_cond_t _cond;
36
    };
37

38
} // namespace CondModule

1
#ifndef _THREAD_H_
2
#define _THREAD_H_
3

4
#include "Log.hpp"
5
#include <atomic>    // C++11 引入的原子类型，提供线程安全的操作
6
#include <cstdio>
7
#include <cstring>
8
#include <functional>
9
#include <iostream>
10
#include <pthread.h>
11
#include <string>
12

13
namespace ThreadModule {
14
    using namespace LogModule;
15

16
    // 使用 std::atomic 确保在多线程环境下递增线程编号是安全的
17
    static std::atomic<uint32_t> number(1);
18

19
    class Thread {
20
        // 定义函数包装器类型：允许传入符合 void() 签名的可调用对象
21
        using func_t = std::function<void()>;
22

23
    private:
24
        // 设置分离状态
25
        void EnableDetach() {
26
            _isdetach = true;
27
        }
28

29
        // 设置运行状态
30
        void EnableRunning() {
31
            _isrunning = true;
32
        }
33

34
        // 线程执行的函数入口
35
        // pthread_create 要求的回调函数必须是静态的（没有隐含的 this 指针）
36
        static void *Routine(void *args) {
37
            // 通过传入的 this 指针，静态函数可以访问类的非静态成员
38
            Thread *self = static_cast<Thread *>(args);
39
            self->EnableRunning();
40

41
            if (self->_isdetach)
42
                self->Detach();
43

44
            // 设置线程在操作系统中的名称
45
            pthread_setname_np(self->_tid, self->_name.c_str());
46

47
            // 执行用户传入的任务逻辑
48
            self->_func();
49
            return nullptr;
50
        }
51

52
    public:
53
        // 构造：初始化线程基本信息，不立即启动线程
54
        Thread(func_t func)
55
            : _tid(0), _isdetach(false), _isrunning(false), res(nullptr), _func(func) {
56
            _name = "thread-" + std::to_string(number++);
57
        }
58

59
        // 分离线程
60
        void Detach() {
61
            if (_isdetach)
62
                return; // 防止重复分离
63
            if (_isrunning) {
64
                pthread_detach(_tid);
65
            }
66
            EnableDetach();
67
        }
68

69
        // 获取线程名
70
        std::string Name() {
71
            return _name;
72
        }
73

74
        // 启动线程，调用 pthread_create
75
        bool Start() {
76
            if (_isrunning)
77
                return false;
78

79
            // 将 this 作为参数传递给 Routine，以便 Routine 访问实例成员
80
            int n = pthread_create(&_tid, nullptr, Routine, this);
81
            if (n != 0)
82
                return false;
83
            return true;
84
        }
85

86
        // 停止线程：通过 pthread_cancel 发送请求
87
        bool Stop() {
88
            if (_isrunning) {
89
                int n = pthread_cancel(_tid);
90
                if (n != 0)
91
                    return false;
92
                _isrunning = false;
93
                return true;
94
            }
95
            return false;
96
        }
97

98
        // 等待线程：阻塞调用者直到该线程执行完毕
99
        void Join() {
100
            // 已分离的线程不可被 Join
101
            if (_isdetach)
102
                return;
103

104
            int n = pthread_join(_tid, &res);
105
            if (n != 0) {
106
                LOG(LogLevel::DEBUG) << "Join 线程 " << _name << " 失败";
107
            } else {
108
                LOG(LogLevel::DEBUG) << "Join 线程 " << _name << " 成功";
109
                _isrunning = false;
110
            }
111
        }
112

113
        pthread_t Id() {
114
            return _tid;
115
        }
116

117
        ~Thread() {}
118

119
    private:
120
        pthread_t _tid;    // 线程原生 ID
121
        std::string _name; // 自定义线程名
122
        bool _isdetach;    // 是否是分离状态
123
        bool _isrunning;   // 是否在运行
124
        void *res;         // 线程返回的结果指针
125
        func_t _func;      // 用户要执行的任务
126
    };
127
} // namespace ThreadModule
128

129
#endif

1
#pragma once
2
#include "Common.hpp"
3

4
class InetAddr {
5
public:
6
    InetAddr() {}
7

8
    // 构造函数：从底层的 sockaddr_in 解析出 IP 和端口
9
    InetAddr(const struct sockaddr_in &addr) : _addr(addr) {
10
        // 1. 端口转换：网络字节序转为主机字节序
11
        _port = ntohs(_addr.sin_port);
12

13
        // 2. IP 转换：网络二进制格式转为点分十进制字符串 (线程安全)
14
        char ipbuffer[64];
15
        inet_ntop(AF_INET, &_addr.sin_addr, ipbuffer, sizeof(ipbuffer));
16
        _ip = ipbuffer;
17
    }
18

19
    // 构造函数：传入 IP 和端口（常用于客户端连接或服务器绑定特定 IP）
20
    InetAddr(const std::string &ip, uint16_t port) : _ip(ip), _port(port) {
21
        memset(&_addr, 0, sizeof(_addr));
22
        _addr.sin_family = AF_INET; // IPv4 协议族
23

24
        // 1. IP 转换：点分十进制字符串转为网络二进制格式
25
        inet_pton(AF_INET, _ip.c_str(), &_addr.sin_addr);
26

27
        // 2. 端口转换：主机字节序转为网络字节序
28
        _addr.sin_port = htons(_port);
29
    }
30

31
    // 构造函数：仅指定端口（常用于服务器 bind，默认监听所有网卡 INADDR_ANY）
32
    InetAddr(uint16_t port) : _port(port), _ip("") {
33
        memset(&_addr, 0, sizeof(_addr));
34
        _addr.sin_family = AF_INET;
35

36
        // 监听本地所有可用 IP
37
        _addr.sin_addr.s_addr = INADDR_ANY;
38

39
        // 端口转换：主机字节序转为网络字节序
40
        _addr.sin_port = htons(_port);
41
    }
42

43
    // 获取 IP 字符串
44
    std::string Ip() {
45
        return _ip;
46
    }
47

48
    // 获取底层的 sockaddr_in 结构体引用
49
    const struct sockaddr_in &NetAddr() {
50
        return _addr;
51
    }
52

53
    // 获取底层的 sockaddr 指针并进行强制类型转换（用于 bind, connect, sendto 等系统调用）
54
    const struct sockaddr *NetAddrPtr() {
55
        return (struct sockaddr *)&_addr;
56
    }
57

58
    // 获取结构体长度
59
    socklen_t NetAddrLen() {
60
        return sizeof(_addr);
61
    }
62

63
    // 重载判等操作符，方便比较两个地址对象
64
    bool operator==(const InetAddr &addr) {
65
        return addr._ip == _ip && addr._port == _port;
66
    }
67

68
    // 返回 "IP:Port" 格式的字符串，方便日志打印
69
    std::string StringAddr() {
70
        return _ip + ":" + std::to_string(_port);
71
    }
72

73
    ~InetAddr() {}
74

75
private:
76
    struct sockaddr_in _addr; // 底层 socket API 需要的结构
77
    std::string _ip;
78
    uint16_t _port;
79
};

1
#pragma once
2
#include "Log.hpp"
3
#include "Mutex.hpp"
4
#include "Thread.hpp"
5
#include "Cond.hpp"
6
#include <iostream>
7
#include <queue>
8
#include <string>
9
#include <vector>
10

11
namespace ThreadPoolModule {
12
    using namespace ThreadModule;
13
    using namespace LogModule;
14
    using namespace CondModule;
15
    using namespace MutexModule;
16

17
    static const int gnum = 5;
18

19
    template <typename T>
20
    class ThreadPool {
21
    private:
22
        // 唤醒所有等待中的工作线程
23
        // 通常在线程停止时调用
24
        void WakeUpAllThread() {
25
            LockGuard lockguard(_mutex);
26
            if (_sleepernum > 0)
27
                _cond.Broadcast();
28
            LOG(LogLevel::INFO) << "唤醒所有休眠的线程";
29
        }
30

31
        // 唤醒单个休眠线程
32
        void WakeUpOne() {
33
            _cond.Signal();
34
            LOG(LogLevel::INFO) << "唤醒一个休眠线程";
35
        }
36

37
        // 私有构造函数：确保单例模式
38
        ThreadPool(int num = gnum) : _num(num), _isrunning(false), _sleepernum(0) {
39
            for (int i = 0; i < num; i++) {
40
                // 使用 lambda 表达式绑定工作函数 HandlerTask
41
                _threads.emplace_back([this]() { HandlerTask(); });
42
            }
43
        }
44

45
        // 内部启动接口：启动所有线程对象
46
        void Start() {
47
            if (_isrunning)
48
                return;
49
            _isrunning = true;
50
            for (auto &thread : _threads) {
51
                thread.Start();
52
                LOG(LogLevel::INFO) << "start new thread success: " << thread.Name();
53
            }
54
        }
55

56
        // 禁止拷贝构造和赋值构造，防止单例违背
57
        ThreadPool(const ThreadPool<T> &) = delete;
58
        ThreadPool<T> &operator=(const ThreadPool<T> &) = delete;
59

60
    public:
61
        // 获取单例实例（双重检查锁定）
62
        static ThreadPool<T> *GetInstance() {
63
            if (inc == nullptr) // 第一次检查，避免不必要的加锁
64
            {
65
                LockGuard lockgurad(_lock); // 加锁确保线程安全
66
                if (inc == nullptr)         // 第二次检查：确认是否其他线程已创建
67
                {
68
                    LOG(LogLevel::DEBUG) << "首次使用单例，创建并启动线程池...";
69
                    inc = new ThreadPool<T>();
70
                    inc->Start();
71
                }
72
            }
73
            return inc;
74
        }
75

76
        // 停止线程池，设置运行标志并唤醒所有工作线程让他们退出
77
        void Stop() {
78
            if (!_isrunning)
79
                return;
80
            _isrunning = false;
81
            WakeUpAllThread();
82
        }
83

84
        // 等待所有线程退出
85
        void Join() {
86
            for (auto &thread : _threads) {
87
                thread.Join();
88
            }
89
        }
90

91
        // 线程执行逻辑（消费者）
92
        void HandlerTask() {
93
            char name[128];
94
            pthread_getname_np(pthread_self(), name, sizeof(name));
95
            while (true) {
96
                T t; // 任务对象
97
                {
98
                    LockGuard lockguard(_mutex);
99
                    // 1. 等待条件：队列为空且池还在运行，则线程休眠
100
                    while (_taskq.empty() && _isrunning) {
101
                        _sleepernum++;
102
                        _cond.Wait(_mutex); // 释放锁并等待信号
103
                        _sleepernum--;
104
                    }
105

106
                    // 2. 检查退出条件：池已关且任务已处理完
107
                    if (!_isrunning && _taskq.empty()) {
108
                        LOG(LogLevel::INFO) << name << " 退出了，线程池已关闭且任务队列为空";
109
                        break;
110
                    }
111

112
                    // 3. 提取任务：从队列中获取一个任务
113
                    t = _taskq.front();
114
                    _taskq.pop();
115
                }
116
                // 4. 执行任务：在临界区外部执行，提升并发性能
117
                t();
118
            }
119
        }
120

121
        // 生产者接口：向队列投放任务
122
        bool Enqueue(const T &in) {
123
            if (_isrunning) {
124
                LockGuard lockguard(_mutex);
125
                _taskq.push(in);
126
                if (_sleepernum > 0)
127
                    WakeUpOne();
128
                return true;
129
            }
130
            return false;
131
        }
132

133
        ~ThreadPool() {}
134

135
    private:
136
        std::vector<Thread> _threads; // 线程集合
137
        int _num;                     // 线程数量
138
        std::queue<T> _taskq;         // 任务队列
139
        Cond _cond;                   // 条件变量
140
        Mutex _mutex;                 // 任务队列互斥锁
141
        bool _isrunning;              // 运行状态标识
142
        int _sleepernum;              // 正在休眠的线程数
143

144
        static ThreadPool<T> *inc;    // 单例指针
145
        static Mutex _lock;           // 单例创建过程的全局锁
146
    };
147

148
    // 模板静态成员初始化
149
    template <typename T>
150
    ThreadPool<T> *ThreadPool<T>::inc = nullptr;
151

152
    template <typename T>
153
    MutexModule::Mutex ThreadPool<T>::_lock;
154

155
} // namespace ThreadPoolModule

1
// UDP 服务器核心
2
// 服务器遵循：创建套接字 -> 绑定(Bind) -> 循环收发数据
3
#pragma once
4
#include "Comm.hpp"
5
#include "InetAddr.hpp"
6
#include "Log.hpp"
7
#include "nocopy.hpp"
8
#include <arpa/inet.h>
9
#include <cerrno>
10
#include <cstring>
11
#include <iostream>
12
#include <netinet/in.h>
13
#include <string>
14
#include <strings.h>
15
#include <sys/socket.h>
16
#include <sys/types.h>
17
#include <unistd.h>
18
#include <functional>
19

20
using namespace LogModule;
21

22
// 定义回调函数类型：参数包括套接字、接收到的消息、发送方的地址信息
23
using func_t = std::function<void(int sockfd, const std::string& message, InetAddr& addr)>;
24

25
// 默认配置
26
const static uint16_t defaultport = 8888;
27
const static int defaultfd = -1;
28
const static int defaultsize = 1024;
29

30
// 继承 nocopy，防止服务器对象被意外复制
31
class UdpServer : public nocopy {
32
public:
33
    UdpServer(uint16_t port = defaultport, func_t func = nullptr)
34
        : _port(port), _sockfd(defaultfd), _func(func) {
35
    }
36

37
    void Init() {
38
        // 1. 创建 socket。AF_INET 表示 IPv4, SOCK_DGRAM 表示 UDP 协议
39
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
40
        if (_sockfd < 0) {
41
            LOG(LogLevel::FATAL) << "socket error!";
42
            exit(Usage_Err);
43
        }
44
        LOG(LogLevel::INFO) << "socket success, sockfd: " << _sockfd;
45

46
        // 2. 绑定指定服务器的网络信息（IP 和端口）
47
        struct sockaddr_in local;
48
        bzero(&local, sizeof(local)); // 清空内存
49
        local.sin_family = AF_INET;
50
        local.sin_port = htons(_port);      // 主机端口转为网络字节序
51
        local.sin_addr.s_addr = INADDR_ANY; // 监听本地所有可用 IP
52

53
        // 真正的绑定操作，将配置信息设置进内核
54
        int n = ::bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
55
        if (n != 0) {
56
            LOG(LogLevel::FATAL) << "bind error";
57
            exit(Bind_Err);
58
        }
59
        LOG(LogLevel::INFO) << "bind success, sockfd: " << _sockfd;
60
    }
61

62
    void Start() {
63
        char buffer[defaultsize];
64
        for (;;) // 服务器死循环，永远不退出
65
        {
66
            struct sockaddr_in peer; // 用于存储发送端（客户端）的信息
67
            socklen_t len = sizeof(peer);
68

69
            // recvfrom: 接收数据，同时获取对方的 IP 和端口并填入 peer
70
            ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
71

72
            if (n > 0) {
73
                InetAddr addr(peer);      // 解析发送方地址信息封装成对象
74
                buffer[n] = 0;            // 字符串结尾，防止越界或乱码
75

76
                // 调用外部传入的业务逻辑处理函数
77
                if (_func) {
78
                    _func(_sockfd, buffer, addr);
79
                }
80
            }
81
        }
82
    }
83

84
    ~UdpServer() {
85
        // 析构时自动关闭文件描述符，释放系统资源
86
        if (_sockfd > defaultfd) {
87
            close(_sockfd);
88
        }
89
    }
90

91
private:
92
    uint16_t _port;   // 服务器端口号
93
    int _sockfd;      // 网络文件描述符
94
    func_t _func;     // 外部回调业务逻辑
95
};