Linux Socket 编程实战：基于 UDP 的简易英译汉翻译服务器

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <fstream>
#include <unordered_map>
#include <functional>
#include <cstdlib>
#include <cerrno>
using namespace std;

// 全局常量配置
const uint16_t DEFAULT_PORT = 8888;
const int DEFAULT_BUFF_SIZE = 1024;
const string DICT_PATH = "./dict.txt";
const string SEP = ": ";
const string UNKNOWN = "未查到";

// 字典类：封装加载和查询功能
class Dict {
private:
    unordered_map<string, string> _dict;

    // 加载字典文件到哈希表
    void LoadDict() {
        ifstream in(DICT_PATH);
        if (!in.is_open()) {
            cerr << "打开字典文件失败：" << strerror(errno) << endl;
            return;
        }
        string line;
        while (getline(in, line)) {
            if (line.empty()) continue;
            size_t pos = line.find(SEP);
            if (pos == string::npos) continue; // 格式错误跳过
            string key = line.substr(0, pos);
            string value = line.substr(pos + SEP.size());
            _dict.insert(make_pair(key, value));
        }
        in.close();
        cout << "字典加载完成，共加载" << _dict.size() << "个单词" << endl;
    }
public:
    Dict() { LoadDict(); }

    string Translate(const string& key) {
        auto iter = _dict.find(key);
        if (iter == _dict.end()) {
            return UNKNOWN;
        }
        return iter->second;
    }
};

// UDP 服务端类：封装网络通信功能，解耦业务处理
class UdpServer {
private:
    int _sockfd;
    uint16_t _port;
    function<void(const string&, string*)> _func;

    bool Init() {
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0) {
            cerr << "创建 Socket 失败：" << strerror(errno) << endl;
            return false;
        }
        struct sockaddr_in local;
        memset(&local, 0, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(_port);
        local.sin_addr.s_addr = INADDR_ANY;
        if (bind(_sockfd, (struct sockaddr*)&local, sizeof(local)) < 0) {
            cerr << "绑定端口失败：" << strerror(errno) << endl;
            close(_sockfd);
            return false;
        }
        cout << "UDP 服务端初始化成功，监听端口：" << _port << endl;
        return true;
    }

public:
    UdpServer(uint16_t port = DEFAULT_PORT, function<void(const string&, string*)> func = nullptr)
        : _port(port), _func(func), _sockfd(-1) {}

    ~UdpServer() {
        if (_sockfd >= 0) {
            close(_sockfd);
        }
    }

    void Start() {
        if (!Init() || _func == nullptr) {
            cerr << "服务端启动失败" << endl;
            return;
        }
        char buffer[DEFAULT_BUFF_SIZE] = {0};
        while (true) {
            struct sockaddr_in peer;
            socklen_t peer_len = sizeof(peer);
            ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &peer_len);
            if (n > 0) {
                buffer[n] = 0;
                string req = buffer;
                string resp;
                _func(req, &resp); // 调用回调处理业务
                sendto(_sockfd, resp.c_str(), resp.size(), 0, (struct sockaddr*)&peer, peer_len);
                
                string peer_ip = inet_ntoa(peer.sin_addr);
                uint16_t peer_port = ntohs(peer.sin_port);
                cout << "[" << peer_ip << ":" << peer_port << "] 查词：" << req << " → " << resp << endl;
            }
        }
    }
};

// 业务处理函数：调用 Dict 的 Translate 接口
void HandleRequest(const string& req, string* resp) {
    static Dict dict; // 静态对象，只加载一次字典
    *resp = dict.Translate(req);
}

int main(int argc, char* argv[]) {
    uint16_t port = DEFAULT_PORT;
    if (argc == 2) {
        port = atoi(argv[1]);
    }
    UdpServer server(port, HandleRequest);
    server.Start();
    return 0;
}

3. 客户端代码 (dict_client.cpp)

客户端相对简单，主要负责建立连接、发送请求和展示结果。注意处理命令行参数和退出机制。

#include <iostream>
#include <string>
#include <cstring>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <cerrno>
#include <cstdlib>
using namespace std;

const int DEFAULT_BUFF_SIZE = 1024;

void Usage(const string& proc) {
    cout << "Usage: " << proc << " server_ip server_port" << endl;
    cout << "Example: " << proc << " 127.0.0.1 8888" << endl;
}

int main(int argc, char* argv[]) {
    if (argc != 3) {
        Usage(argv[0]);
        return 1;
    }
    string server_ip = argv[1];
    uint16_t server_port = atoi(argv[2]);

    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0) {
        cerr << "创建 Socket 失败：" << strerror(errno) << endl;
        return 2;
    }

    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(server_port);
    server.sin_addr.s_addr = inet_addr(server_ip.c_str());
    if (server.sin_addr.s_addr == INADDR_NONE) {
        cerr << "IP 地址格式错误" << endl;
        close(sockfd);
        return 3;
    }

    cout << "客户端启动成功，连接服务端：" << server_ip << ":" << server_port << endl;
    cout << "请输入英文单词（输入 q 退出）：" << endl;

    string word;
    char buffer[DEFAULT_BUFF_SIZE] = {0};
    while (true) {
        cout << ">> ";
        getline(cin, word);
        if (word == "q" || word == "Q") {
            cout << "客户端退出" << endl;
            break;
        }
        if (word.empty()) continue;

        ssize_t n = sendto(sockfd, word.c_str(), word.size(), 0, (struct sockaddr*)&server, sizeof(server));
        if (n < 0) {
            cerr << "发送失败：" << strerror(errno) << endl;
            continue;
        }

        struct sockaddr_in temp;
        socklen_t temp_len = sizeof(temp);
        ssize_t m = recvfrom(sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&temp, &temp_len);
        if (m > 0) {
            buffer[m] = 0;
            cout << word << " → " << buffer << endl;
        } else {
            cerr << "接收失败：" << strerror(errno) << endl;
        }
        memset(buffer, 0, sizeof(buffer));
    }
    close(sockfd);
    return 0;
}

编译与运行

1. 编译

使用 g++ 配合 C++11 标准编译，因为用到了 lambda 和 function 等特性。

g++ -o dict_server dict_server.cpp -std=c++11
g++ -o dict_client dict_client.cpp -std=c++11

2. 启动服务端

默认监听 8888 端口，也可通过命令行指定：

./dict_server
# 或指定端口
./dict_server 9999

启动成功后会看到字典加载数量和端口监听信息。

3. 启动客户端

本地测试指向 127.0.0.1，远程测试需替换为服务器公网 IP。如果是云服务器，记得在安全组放行 UDP 协议对应端口。

./dict_client 127.0.0.1 8888

4. 效果演示

客户端输入单词，服务端实时返回释义：

>> apple
apple → 苹果
>> test
test → 未查到
>> q
客户端退出

扩展方向

这个基础版本还有很多优化空间，比如：

• 多字典支持：允许加载多个词典文件。
• 模糊查询：当单词不存在时，推荐相似拼写。
• 日志持久化：将访问日志写入文件而非终端。
• TCP 支持：如果对可靠性要求高，可切换为 TCP 协议。
• 异常处理：增强对空文件、超长输入等边界情况的容错。

总结

本次实战通过 UDP Socket 实现了完整的英译汉服务，涵盖了 Linux 网络编程的核心流程。重点实践了类的封装思想，利用 unordered_map 提升了查询性能，并通过回调函数实现了网络层与业务层的解耦。这些模式在实际开发中非常常见，掌握它们有助于构建更健壮的网络应用。