09. 数据序列化

# 09. 数据序列化

目前，我们服务器协议的响应是一个错误码加一个字符串。但要是我们需要返回更复杂的数据可咋办呢？比如说，我们可能要添加一个keys命令，用来返回一个字符串列表。我们在请求协议里已经对字符串列表数据进行了编码。在本章，我们要把这种编码方式进行通用化处理，以应对不同类型的数据。这通常就叫做“序列化（serialization）” 。

我们的序列化协议包含五种数据类型：

enum {
    SER_NIL = 0,
    SER_ERR = 1,
    SER_STR = 2,
    SER_INT = 3,
    SER_ARR = 4,
};

1
2
3
4
5
6
7

SER_NIL就像NULL，SER_ERR用于返回错误码和错误信息，SER_STR和SER_INT分别用于处理字符串和64位整数，SER_ARR则用于处理数组。

代码从try_one_request函数开始：

static bool try_one_request(Conn *conn)  {
    // 代码省略...

    // 解析请求
    std::vector<std::string> cmd;
    if (0 != parse_req(&conn->rbuf[4], len, cmd)) {
        msg("bad req");
        conn->state = STATE_END;
        return false;
    }

    // 得到一个请求，生成响应
    std::string out;
    do_request(cmd, out);

    // 将响应打包到缓冲区
    if (4 + out.size() > k_max_msg) {
        out.clear();
        out_err(out, ERR_2BIG, "response is too big");
    }
    uint32_t wlen = (uint32_t)out.size();
    memcpy(&conn->wbuf[0], &wlen, 4);
    memcpy(&conn->wbuf[4], out.data(), out.size());
    conn->wbuf_size = 4 + wlen;

    // 代码省略...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

为了方便，这里用std::string来存储响应数据。在生产级项目里，通常会有更厉害的缓冲区管理方法。

do_request处理函数里新增了一个keys命令：

static void do_request(std::vector<std::string> &cmd, std::string &out)  {
    if (cmd.size() == 1 && cmd_is(cmd[0], "keys")) {
        do_keys(cmd, out);
    } else if (cmd.size() == 2 && cmd_is(cmd[0], "get")) {
        do_get(cmd, out);
    } else if (cmd.size() == 3 && cmd_is(cmd[0], "set")) {
        do_set(cmd, out);
    } else if (cmd.size() == 2 && cmd_is(cmd[0], "del")) {
        do_del(cmd, out);
    } else {
        // 无法识别的命令
        out_err(out, ERR_UNKNOWN, "Unknown cmd");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

下面是我们序列化协议的代码：

static void out_nil(std::string &out)  {
    out.push_back(SER_NIL);
}

static void out_str(std::string &out, const std::string &val)  {
    out.push_back(SER_STR);
    uint32_t len = (uint32_t)val.size();
    out.append((char *)&len, 4);
    out.append(val);
}

static void out_int(std::string &out, int64_t val)  {
    out.push_back(SER_INT);
    out.append((char *)&val, 8);
}

static void out_err(std::string &out, int32_t code, const std::string &msg)  {
    out.push_back(SER_ERR);
    out.append((char *)&code, 4);
    uint32_t len = (uint32_t)msg.size();
    out.append((char *)&len, 4);
    out.append(msg);
}

static void out_arr(std::string &out, uint32_t n)  {
    out.push_back(SER_ARR);
    out.append((char *)&n, 4);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

可以看到，我们的序列化协议以一个字节的数据类型开头，后面跟着各种类型的负载数据。数组会先给出大小，然后是可能嵌套的元素。

do_keys函数生成一个由字符串列表构成的响应：

static void h_scan(HTab *tab, void (*f)(HNode *, void *), void *arg)  {
    if (tab->size == 0) {
        return;
    }
    for (size_t i = 0; i < tab->mask + 1; ++i) {
        HNode *node = tab->tab[i];
        while (node) {
            f(node, arg);
            node = node->next;
        }
    }
}

static void cb_scan(HNode *node, void *arg)  {
    std::string &out = *(std::string *)arg;
    out_str(out, container_of(node, Entry, node)->key);
}

static void do_keys(std::vector<std::string> &cmd, std::string &out)  {
    (void)cmd;
    out_arr(out, (uint32_t)hm_size(&g_data.db));
    h_scan(&g_data.db.ht1, &cb_scan, &out);
    h_scan(&g_data.db.ht2, &cb_scan, &out);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

del命令会返回一个整数，用来表示删除操作是否成功。

static void do_del(std::vector<std::string> &cmd, std::string &out)  {
    Entry key;
    key.key.swap(cmd[1]);
    key.node.hcode = str_hash((uint8_t *)key.key.data(), key.key.size());

    HNode *node = hm_pop(&g_data.db, &key.node, &entry_eq);
    if (node) {
        delete container_of(node, Entry, node);
    }
    return out_int(out, node? 1 : 0);
}

1
2
3
4
5
6
7
8
9
10
11

其他命令的代码没啥意思，就不用列出来啦。下面是客户端“反序列化”的代码：

static int32_t on_response(const uint8_t *data, size_t size)  {
    if (size < 1) {
        msg("bad response");
        return -1;
    }
    switch (data[0]) {
        case SER_NIL:
            printf("(nil)\n");
            return 1;
        case SER_ERR:
            if (size < 1 + 8) {
                msg("bad response");
                return -1;
            }
            {
                int32_t code = 0;
                uint32_t len = 0;
                memcpy(&code, &data[1], 4);
                memcpy(&len, &data[1 + 4], 4);
                if (size < 1 + 8 + len) {
                    msg("bad response");
                    return -1;
                }
                printf("(err) %d %.*s\n", code, len, &data[1 + 8]);
                return 1 + 8 + len;
            }
        case SER_STR:
            // 代码省略...
        case SER_INT:
            // 代码省略...
        case SER_ARR:
            if (size < 1 + 4) {
                msg("bad response");
                return -1;
            }
            {
                uint32_t len = 0;
                memcpy(&len, &data[1], 4);
                printf("(arr) len=%u\n", len);
                size_t arr_bytes = 1 + 4;
                for (uint32_t i = 0; i < len; ++i) {
                    int32_t rv = on_response(&data[arr_bytes], size - arr_bytes);
                    if (rv < 0) {
                        return rv;
                    }
                    arr_bytes += (size_t)rv;
                }
                printf("(arr) end\n");
                return (int32_t)arr_bytes;
            }
        default:
            msg("bad response");
            return -1;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55

# 测试我们的新服务器/客户端

$ ./client asdf
(err) 1 Unknown cmd
$ ./client get asdf
(nil)
$ ./client set k v
(nil)
$ ./client get k
(str) v
$ ./client keys
(arr) len=1
(str) k
(arr) end
$ ./client del k
(int) 1
$ ./client del k
(int) 0
$ ./client keys
(arr) len=0
(arr) end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

09_client.cpp
09_server.cpp
hashtable.cpp
hashtable.h

上次更新: 2025/03/25, 00:48:42

← 08. 数据结构：哈希表 10. AVL树：实现与测试→