Thrift序列化与反序列化

怼烎@ 2021-09-22 05:44 496阅读 0赞

Thrift提供了可扩展序列化机制, 不但兼容性好而且压缩率高。  
我们来比较下常见的数据传输格式

<table style="table-layout:fixed; border-collapse:collapse; border:1px solid #ccc; width:602px"> 
 <tbody> 
  <tr> 
   <td style="word-wrap:break-word; width:70px"><span style="font-size:14px">数据传输格式</span></td> 
   <td style="word-wrap:break-word; width:70px">类型</td> 
   <td style="word-wrap:break-word; width:232px">优点</td> 
   <td style="word-wrap:break-word; width:230px">缺点</td> 
  </tr> 
  <tr> 
   <td style="word-wrap:break-word; width:70px">Xml</td> 
   <td style="word-wrap:break-word; width:70px">文本</td> 
   <td style="word-wrap:break-word; width:232px">1、良好的可读性<br> 2、序列化的数据包含完整的结构<br> 3、调整不同属性的顺序对序列化/反序列化不影响</td> 
   <td style="word-wrap:break-word; width:230px">1、数据传输量大<br> 2、不支持二进制数据类型</td> 
  </tr> 
  <tr> 
   <td style="word-wrap:break-word; width:70px">Json</td> 
   <td style="word-wrap:break-word; width:70px">文本</td> 
   <td style="word-wrap:break-word; width:232px">1、良好的可读性<br> 2、调整不同属性的顺序对序列化/反序列化不影响</td> 
   <td style="word-wrap:break-word; width:230px">1、丢弃了类型信息, 比如"price":100, 对price类型是int/double解析有二义性<br> 2、不支持二进制数据类型</td> 
  </tr> 
  <tr> 
   <td style="word-wrap:break-word; width:70px">Thrift</td> 
   <td style="word-wrap:break-word; width:70px">二进制</td> 
   <td style="word-wrap:break-word; width:232px">高效</td> 
   <td style="word-wrap:break-word; width:230px">1、不宜读<br> 2、向后兼容有一定的约定限制，采用id递增的方式标识并以optional修饰来添加</td> 
  </tr> 
  <tr> 
   <td style="word-wrap:break-word; width:70px">Google Protobuf</td> 
   <td style="word-wrap:break-word; width:70px">二进制</td> 
   <td style="word-wrap:break-word; width:232px">高效</td> 
   <td style="word-wrap:break-word; width:230px">1、不宜读<br> 2、向后兼容有一定的约定限制</td> 
  </tr> 
 </tbody> 
</table>

**Thrift 支持的数据类型**

1、基本类型

bool: 布尔值

byte: 8位有符号整数

i16: 16位有符号整数

i32: 32位有符号整数

i64: 64位有符号整数

double: 64位浮点数

string: UTF-8编码的字符串

binary: 二进制串

2、结构体类型

struct: 定义了一个很普通的OOP对象，但是没有继承特性，用法如下：

struct User \{  
1: i32 uid,  
2: string name  
\}

如果变量有默认值，可以直接写在定义文件里:

struct User \{  
1: i32 uid = 1,  
2: string name = "User1"  
\}

说明：

a. 每个域有一个唯一的，正整数标识符

b. 每个域可以标识为required或者optional（也可以不注明）

c. 结构体可以包含其他结构体

d. 域可以有缺省值

e. 一个thrift中可定义多个结构体，并存在引用关系

规范的struct定义中的每个域均会使用required或者optional关键字进行标识。如果required标识的域没有赋值，thrift将给予提示。如果optional标识的域没有赋值，该域将不会被序列化传输。如果某个optional标识域有缺省值而用户没有重新赋值，则该域的值一直为缺省值。

与service不同，结构体不支持继承，即一个结构体不能继承另一个结构体。

3、容器类型

Thrift容器与类型密切相关，它与当前流行编程语言提供的容器类型相对应，采用java泛型风格表示。Thrift提供了3种容器类型：

list<t1>: 一系列t1类型的元素组成的有序表，元素可以重复

set: <t1>：一系列t1类型的元素组成的无序表，元素唯一

map<t1,t2>：key/value对（key的类型是t1且唯一，value类型是t2）

容器中的元素类型可以是除了service意外的任何合法thrift类型（包括结构体和异常）

用法如下：

struct Node \{  
1: i32 id,  
2: string name,  
3: list<i32> subNodeList,  
4: map<i32,string> subNodeMap,  
5: set<i32> subNodeSet  
\}

包含定义的其他Object:

struct SubNode \{  
1: i32 uid,  
2: string name,  
3: i32 pid  
\}  
struct Node \{  
1: i32 uid,  
2: string name,  
3: list<SubNode> subNodes  
\}

4、异常类型：

exception: 异常类型，用法如下：

exception InvalidOperation \{  
1: i32 whatOp,  
2: string why  
\}

5、服务类型：

service: 具体对应服务的类，也就是对外展现的接口。用法如下：

service UserStorage \{  
void store(1: User user),  
User retrieve(1: i32 uid)  
\}

说明：

a． 函数定义可以使用逗号或者分号标识结束

b． 参数可以是基本类型或者结构体，参数是只读的（const），不可以作为返回值！！！

c． 返回值可以是基本类型或者结构体

d． 返回值可以是void

注意，函数中参数列表的定义方式与struct完全一样

Service支持继承，一个service可使用extends关键字继承另一个service

6、Thrift支持C/C++风格的typedef，用法如下：

typedef i32 myInteger  
typedef myStruct MyStruct

说明：

a. 末尾没有逗号

b. struct可以使用typedef

7、枚举类型

可以像C/C++那样定义枚举类型，用法如下：

enum Operation \{  
ADD = 1,  
SUBTRACT = 2,  
MULTIPLY = 3,  
DIVIDE = 4  
\}

说明：

a. 编译器默认从0开始赋值

b. 可以赋予某个常量某个整数

c. 允许常量是十六进制整数

d. 末尾没有逗号

e. 给常量赋缺省值时，使用常量的全称

注意，不同于protocol buffer，thrift不支持枚举类嵌套，枚举常量必须是32位的正整数

thrift的架构如下图所示。两个矩形是创建server和client的stack。最上面的是IDL，然后生成Client和Processor。红色的是发送的数据。protocol和transport 是Thrift运行库的一部分。通过Thrift 你只需要关心服务的定义，而不需要关心protocol和transport。  
![Center][]

**协议**

Thrift可以让你选择客户端与服务端之间传输通信协议的类别，在传输协议上总体上划分为文本(text)和二进制(binary)传输协议, 为节约带宽，提供传输效率，一般情况下使用二进制类型的传输协议为多数，但有时会还是会使用基于文本类型的协议，这需要根据项目/产品中的实际需求（例如：调试的时候）：

1、TBinaryProtocol – 二进制编码格式进行数据传输。

2、TCompactProtocol – 这种协议非常有效，使用Variable-Length Quantity (VLQ) 编码对数据进行压缩。

3、TJSONProtocol – 使用JSON的数据编码协议进行数据传输。

4、TSimpleJSONProtocol – 这种节约只提供JSON只写的协议，适用于通过脚本语言解析

5、TDebugProtocol – 在开发的过程中帮助开发人员调试用的，以文本的形式展现方便阅读。

**传输层**

一个server只允许定义一个接口服务。这样的话多个接口需要多个server。这样会带来资源的浪费。通常可以通过定义一个组合服务来解决。

1、TSocket- 使用堵塞式I/O进行传输，也是最常见的模式。

2、TFramedTransport- 使用非阻塞方式，按块的大小，进行传输，类似于Java中的NIO。

3、TFileTransport- 顾名思义按照文件的方式进程传输，虽然这种方式不提供Java的实现，但是实现起来非常简单。

4、TMemoryTransport- 使用内存I/O，就好比Java中的ByteArrayOutputStream实现。

5、TZlibTransport- 使用执行zlib压缩，不提供Java的实现。

**thrift的序列化和反序列化方式**

步骤：

1.  创建thrift接口定义文件；
2.  将thrift的定义文件转换为对应语言的源代码；
3.  选择相应的protocol，进行序列化和反序列化

写一个简单的thrift文件

namespace java tutorial
    struct User{
      1: i32 id= 0,
      2: required string name,
    }

生成User类，然后写一个测试方法

public class Test {
        public static void main(String[] args) {
            byte[] bytes = serial();
            System.out.println("序列化以后的对象：" + new String(bytes));
            ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
            parse(bis);
        }
    
        /**
         * 序列化方法
         *
         * @return
         */
        private static byte[] serial() {
            User user = new User();
            user.setId(100);
            user.setName("sss");
            System.out.println("序列化之前的对象：" + user.toString());
            // 序列化
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            TTransport transport = new TIOStreamTransport(out);
            TBinaryProtocol tp = new TBinaryProtocol(transport);//二进制编码格式进行数据传输
    //        TCompactProtocol tp = new TCompactProtocol (transport);
            try {
                user.write(tp);
            } catch (TException e) {
                e.printStackTrace();
            }
            byte[] buf = out.toByteArray();
            return buf;
        }
    
        /**
         * 反序列化方法
         *
         * @param bis
         */
        private static void parse(ByteArrayInputStream bis) {
            User user = new User();
            TTransport transport = new TIOStreamTransport(bis);
            TBinaryProtocol tp = new TBinaryProtocol(transport);
    //        TCompactProtocol tp = new TCompactProtocol(transport);
            try {
                user.read(tp);
                System.out.println("反序列化后的对象：" + user.toString());
            } catch (TException e) {
                e.printStackTrace();
            }
        }
    
    }

效果如下：  
![Center 1][]  
好，就说这么多吧，不足之处还请多多指教 [  
源代码][Link 1]  
参考

[http://www.tuicool.com/articles/UFZzIzv][http_www.tuicool.com_articles_UFZzIzv]

[http://www.aiprograming.com/b/pengpeng/24][http_www.aiprograming.com_b_pengpeng_24]

[http://www.open-open.com/lib/view/open1412731170858.html][http_www.open-open.com_lib_view_open1412731170858.html]

[http://blog.csdn.net/column/details/slimina-thrift.html][http_blog.csdn.net_column_details_slimina-thrift.html]

[http://jnb.ociweb.com/jnb/jnbJun2009.html][http_jnb.ociweb.com_jnb_jnbJun2009.html]

[http://blog.163.com/kewangwu@126/blog/static/86728471201271353354581/][http_blog.163.com_kewangwu_126_blog_static_86728471201271353354581]

[http://blog.csdn.net/njchenyi/article/details/8889013][http_blog.csdn.net_njchenyi_article_details_8889013]

[http://blog.csdn.net/chen8238065/article/details/50846104][http_blog.csdn.net_chen8238065_article_details_50846104]

[http://blog.csdn.net/menuconfig/article/details/12837173][http_blog.csdn.net_menuconfig_article_details_12837173]

[http://www.cnblogs.com/cocos2014/p/4259037.html][http_www.cnblogs.com_cocos2014_p_4259037.html]

[https://developers.google.com/protocol-buffers/docs/javatutorial][https_developers.google.com_protocol-buffers_docs_javatutorial]

[Center]: /images/20210920/2d3ca0d70db54819b4604675f0e876cf.png
[Center 1]: /images/20210920/46a0f40c0d5d4166a4d2a25e20ff24d3.png
[Link 1]: http://download.csdn.net/detail/xuemengrui12/9775790
[http_www.tuicool.com_articles_UFZzIzv]: http://www.tuicool.com/articles/UFZzIzv
[http_www.aiprograming.com_b_pengpeng_24]: http://www.aiprograming.com/b/pengpeng/24
[http_www.open-open.com_lib_view_open1412731170858.html]: http://www.open-open.com/lib/view/open1412731170858.html
[http_blog.csdn.net_column_details_slimina-thrift.html]: http://blog.csdn.net/column/details/slimina-thrift.html
[http_jnb.ociweb.com_jnb_jnbJun2009.html]: http://jnb.ociweb.com/jnb/jnbJun2009.html
[http_blog.163.com_kewangwu_126_blog_static_86728471201271353354581]: http://blog.163.com/kewangwu@126/blog/static/86728471201271353354581/
[http_blog.csdn.net_njchenyi_article_details_8889013]: http://blog.csdn.net/njchenyi/article/details/8889013
[http_blog.csdn.net_chen8238065_article_details_50846104]: http://blog.csdn.net/chen8238065/article/details/50846104
[http_blog.csdn.net_menuconfig_article_details_12837173]: http://blog.csdn.net/menuconfig/article/details/12837173
[http_www.cnblogs.com_cocos2014_p_4259037.html]: http://www.cnblogs.com/cocos2014/p/4259037.html
[https_developers.google.com_protocol-buffers_docs_javatutorial]: https://developers.google.com/protocol-buffers/docs/javatutorial