sproto 也是 云风 写的一个开源的 数据描述语言 库，可以将数据进行序列化和反序列化 主要用于数据存储、通信协议订制等方面。和 Google公司开发 protobuf 类似
至于为什么重造轮子，是因为 protobuf 作为国际大公司的产品，当然不是想着如何在精简而是想着如何扩大影响力。也就是普适性。那么带来的问题就是会有一些东西是咱们做游戏开发用不到的。但是你又不得不为使用它而买单。而 云风 一开始也是用的 protobuf 后面他也认为是时候做下减法了。于是乎 sproto 就被造出来了。
它长这样的：
#定义数据结构：
.person {
.address {
email 0 : string
phone 1 : string
}
name 0 : string
age 1 : integer
marital 2 : boolean
children 3 : *person # 这是一个 person 类型的数组
address 4 : address
}
#在 lua 中使用上面的数据结构
local person = { name = "Alice" , age = 13, marital = false } :
#编码后的二进制数据，没有值的字段不会被写入
#如果是中间字段没数据 ，会有2个字节描述跳过多少个字段
03 00 01 00 (fn = 3, dn = 1)
00 00 00 00 (id = 0, ref = 0)
00 00 0E 00 (id = 1, value = 13)
00 00 01 00 (id = 2, value = false)
05 00 00 00 (sizeof "Alice")
41 6C 69 63 65 00 00 00 ("Alice" align by 4)
相对于 protobuf ， sproto 更精简，编解码更快。那么做到这些东西并不是说 云风 比Google公司厉害，而是 sproto 去掉了一些游戏开发中不需要，或者不常用的特性。更适合游戏开发使用。准确来说更适合使用 lua 进行开发的游戏使用。因为 云风 还为 lua 做了一层 RPC 协议封装。其他语言的话就需要自己撸了，之前我就撸了一个 js 版本的sproto，现在公司还在用。效果还行。
那么上面定义的数据怎么被序列化成二进制数据的，为了解释清楚这个问题照惯例我要上图了
sproto.jpg
原文
所有的数字编码都是以小端方式(little-endian) 编码。
打包的单位是一个结构体（用户定义的类型） 每个包分两个部分：1\. 字段 2\. 数据块
首先是一个 word n，描述字段的个数，接下来有 n 个 word 描述字段的内容。这个结构体的前半部分的长度就是 (n+1) * 2 字节。
字段的 tag 从 0 开始累加，每处理一个字段，将 tag 加一。
如果一个字段 v 为奇数，则把当前 tag 加上 (v-1)/2 + 1 ，并继续处理下一个字段值。 如果一个字段为 0 ，表示这个字段引用后面的一个数据块。 如果一个字段不为 0(且为偶数），这个字段的值为 v/2 - 1。（可以表示 [0, 32767] 的值）
接下来是被上面字段引用的数据块。
数据块用于描述字段中的大数据。它是由一个 dword 长度 + 字节串构成。通常用来表示数组或结构。大于 32767 的整数和负整数用 4 字节或 8 字节长的数据块表示(取决于需要和实现)。
数组的编码就是把同一类型的数据依次打包成数据块。如果是布尔数组，按 1 字节一个编码。如果是整数数组，它比较特殊，会根据需要打包成 4 字节或 8 字节一个数字；第一字节是 4 或 8 ，指明后面的整数宽度。
最后，数据中的 0 将被压缩的。压缩算法见[上一篇 blog](http://blog.codingnow.com/2014/07/ejoyproto.html) 。
这就是数据编码后的样子，细心的同学不难看出数据段中，描述长度的类型都是32位，可能有些人会问都用32位来描述长度是不是太浪费了。
别担心，以云大这种追求极简的人不可能做出这样的事情。下面是打包的流程
pack.jpg
看清楚了没有，没用到的字节其实是被压缩了的。
下面也贴一下产生上面数据的代码。注意，sproto.c 并没有给上面的数据分配内存，而是由调用层去分配，并且 sproto.c 只是 做了数据长度的写入。数据内容
都是 调用层去做的 默认是 lsproto.c 给 lua 用的，当然你也可以自己写你喜欢的。
代码很多，但是你看下面的编码函数就够了，解码就是反向操作。
sproto.c
int
sproto_encode(const struct sproto_type *st, void * buffer, int size, sproto_callback cb, void *ud) {
//回调时候回传到上层的结构体
struct sproto_arg args;
//头部段指针
uint8_t * header = buffer;
//当前数据写入的位置
uint8_t * data;
//头部段总长度
int header_sz = SIZEOF_HEADER + st->maxn * SIZEOF_FIELD;
int i;
//当前写到第几个字段
int index;
//上次的tag
int lasttag;
int datasz;
if (size < header_sz)
return -1;
args.ud = ud;
//先把 buffer 分成 header部分（2个字节） | header_sz（st->maxn * SIZEOF_FIELD） | data（数据段--可扩展的）
data = header + header_sz;
size -= header_sz;
//有数据字段的数量索引
index = 0;
lasttag = -1;
for (i=0;i<st->n;i++) {
struct field *f = &st->f[i];
int type = f->type;
//只有字段类型为整形并且小于0xEFFF才有改变
//如果=0则这个字段的值被打包到数据段
int value = 0;
//这字段写入数据的长度
int sz = -1;
args.tagname = f->name;
args.tagid = f->tag;
args.subtype = f->st;
args.mainindex = f->key;
args.extra = f->extra;
if (type & SPROTO_TARRAY) {
args.type = type & ~SPROTO_TARRAY;
sz = encode_array(cb, &args, data, size);
//数组先写入4个字节表示长度
//后面的解析和下面的类似，复杂数据前面加4个字节长度
//sz 就是已经写了多少字节
} else {
args.type = type;
args.index = 0;
switch(type) {
case SPROTO_TINTEGER:
case SPROTO_TBOOLEAN: {
union {
uint64_t u64;
uint32_t u32;
} u;
args.value = &u;
args.length = sizeof(u);
sz = cb(&args);
if (sz < 0) {
if (sz == SPROTO_CB_NIL)
continue;
if (sz == SPROTO_CB_NOARRAY) // no array, don't encode it
return 0;
return -1; // sz == SPROTO_CB_ERROR
}
if (sz == SIZEOF_INT32) {
if (u.u32 < 0x7fff) {
value = (u.u32+1) * 2;
sz = 2; // sz can be any number > 0
} else {
sz = encode_integer(u.u32, data, size);
}
} else if (sz == SIZEOF_INT64) {
sz= encode_uint64(u.u64, data, size);
} else {
return -1;
}
break;
}
case SPROTO_TSTRUCT:
case SPROTO_TSTRING:
//写入长度后还是递归调用到这边
sz = encode_object(cb, &args, data, size);
//data 前4个字节放总长度，后面的放到 args->value
//上层逻辑按各自的数据结构写入到 args->value
//sz 是这次一共用了多少个字节
break;
}
}
if (sz < 0)
return -1;
if (sz > 0) {
//record 如果为 0 则表示数据放在了 数据段
//record 如果为 基数 则表示跳过若干个字段
//record 如果为 偶素 则表示数据为小整形
uint8_t * record;
//tag 的意义就是打包的数据中有部分字段可能没有数据
//需要记录跳过几个字段。并且把跳过的信息也记录在描述字段中，用基数值来表示
//描述字段偶数值就是小整形和bool
//描述字段值为0就是把数据放在了数据段上
int tag;
if (value == 0) {
data += sz;
size -= sz;
}
record = header+SIZEOF_HEADER+SIZEOF_FIELD*index;
tag = f->tag - lasttag - 1;
//两个不连续的字段中,需要额外加2个字节的跳过信息
if (tag > 0) {
// skip tag
tag = (tag - 1) * 2 + 1;
//这里返回 -1 重新分配 buffer 内存，大于 ENCODE_MAXSIZE 会报错和结束
if (tag > 0xffff)
return -1;
record[0] = tag & 0xff;
record[1] = (tag >> 8) & 0xff;
++index;
record += SIZEOF_FIELD;
}
//如果有写入数据
++index;
// value 为 0 数据在数据段
record[0] = value & 0xff;
record[1] = (value >> 8) & 0xff;
//为了计算空字段 记录上一个 tag 等于 当前 tag
lasttag = f->tag;
}
}
//如果全部的字段都没有数据这里就是 0x00 0x00
header[0] = index & 0xff;
header[1] = (index >> 8) & 0xff;
//计算用掉的数据部分长度
datasz = data - (header + header_sz);
data = header + header_sz;
//如果有空的字段就收缩
if (index != st->maxn) {
//header部分（2个字节） | 收缩这部分 header_sz（st->maxn * SIZEOF_FIELD）| data
memmove(header + SIZEOF_HEADER + index * SIZEOF_FIELD, data, datasz);
}
//返回写入数据的总长度
return SIZEOF_HEADER + index * SIZEOF_FIELD + datasz;
}
下次再写一篇 sproto rpc 方面的文章。
网友评论