Apache Thrift系列详解(三) - 序列化机制

淡淡的烟草味﹌ 2022-04-11 15:00 435阅读 0赞

# 前言 #

`Thrift`支持**二进制**，**压缩格式**，以及`json`格式数据的**序列化**和**反序列化**。开发人员可以更加灵活的选择协议的具体形式。协议是可**自由扩展**的，新版本的协议，完全**兼容**老的版本！

# 正文 #

## 数据交换格式简介 ##

当前流行的**数据交换格式**可以分为如下几类：

### (一) 自解析型 ###

序列化的数据包含**完整**的结构， 包含了`field`**名称**和`value`**值**。比如`xml/json/java serizable`，大百度的`mcpack/compack`，都属于此类。即调整不同属性的**顺序**对**序列化/反序列化**不造成影响。

### (二) 半解析型 ###

序列化的数据，丢弃了部分信息， 比如`field`名称， 但引入了`index`(常常是`id`\+`type`的方式)来对应具体**属性**和**值**。这方面的代表有`google protobuf/thrift`也属于此类。

### (三) 无解析型 ###

传说中大百度的`infpack`实现，就是借助该种方式来实现，丢弃了很多**有效信息**，**性能/压缩**比最好，不过向后兼容需要开发做一定的工作， 详情不知。

<table> 
 <thead> 
  <tr> 
   <th>交换格式</th> 
   <th>类型</th> 
   <th>优点</th> 
   <th>缺点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>Xml</td> 
   <td>文本</td> 
   <td>易读</td> 
   <td>臃肿，不支持二进制数据类型</td> 
  </tr> 
  <tr> 
   <td>JSON</td> 
   <td>文本</td> 
   <td>易读</td> 
   <td>丢弃了类型信息，比如"score":100，对score类型是int/double解析有二义性， 不支持二进制数据类型</td> 
  </tr> 
  <tr> 
   <td>Java serizable</td> 
   <td>二进制</td> 
   <td>使用简单</td> 
   <td>臃肿，只限制在JAVA领域</td> 
  </tr> 
  <tr> 
   <td>Thrift</td> 
   <td>二进制</td> 
   <td>高效</td> 
   <td>不易读，向后兼容有一定的约定限制</td> 
  </tr> 
  <tr> 
   <td>Google Protobuf</td> 
   <td>二进制</td> 
   <td>高效</td> 
   <td>不易读，向后兼容有一定的约定限制</td> 
  </tr> 
 </tbody> 
</table>

## Thrift的数据类型 ##

1.  **基本类型：**  
    　　**bool**: 布尔值  
    　　**byte**: 8位有符号整数  
    　　**i16**: 16位有符号整数  
    　　**i32**: 32位有符号整数  
    　　**i64**: 64位有符号整数  
    　　**double**: 64位浮点数  
    　　**string**: UTF-8编码的字符串  
    　　**binary**: 二进制串
2.  **结构体类型：**  
    　　**struct**: 定义的结构体对象
3.  **容器类型：**  
    　　**list**: 有序元素列表  
    　　**set**: 无序无重复元素集合  
    　　**map**: 有序的key/value集合
4.  **异常类型：**  
    　　**exception**: 异常类型
5.  **服务类型：**  
    　　**service**: 具体对应服务的类

## Thrift的序列化协议 ##

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

*  TBinaryProtocol：**二进制**编码格式进行数据传输
 *  TCompactProtocol：**高效率**的、**密集**的**二进制**编码格式进行数据传输
 *  TJSONProtocol： 使用`JSON`**文本**的数据编码协议进行数据传输
 *  TSimpleJSONProtocol：只提供`JSON`**只写**的协议，适用于通过**脚本语言解析**

## Thrift的序列化测试 ##

(a). 首先编写一个简单的`thrift`文件`pair.thrift`：

struct Pair {
        1: required string key
        2: required string value
    }

> 这里标识了`required`的字段，要求在使用时必须正确赋值，否则运行时会抛出`TProtocolException`异常。缺省和指定为`optional`时，则运行时不做字段非空校验。

(b). 编译并生成`java`源代码：

thrift -gen java pair.thrift

(c). 编写序列化和反序列化的测试代码：

*  序列化测试，将`Pair`对象写入文件中

private static void writeData() throws IOException， TException {
        Pair pair = new Pair();
        pair.setKey("key1").setValue("value1");
        FileOutputStream fos = new FileOutputStream(new File("pair.txt"));
        pair.write(new TBinaryProtocol(new TIOStreamTransport(fos)));
        fos.close();
    }

*  反序列化测试，从文件中解析生成`Pair`对象

private static void readData() throws TException， IOException {
        Pair pair = new Pair();
        FileInputStream fis = new FileInputStream(new File("pair.txt"));
        pair.read(new TBinaryProtocol(new TIOStreamTransport(fis)));
        System.out.println("key => " + pair.getKey());
        System.out.println("value => " + pair.getValue());
        fis.close();
    }

(d) 观察运行结果，正常输出表明**序列化**和**反序列化**过程正常完成。

![12738336-e02dcc94678a589d.png][]

image

## Thrift协议源码 ##

### (一) writeData()分析 ###

首先查看`thrift`的**序列化机制**，即数据写入实现，这里采用**二进制协议**`TBinaryProtocol`，切入点为`pair.write(TProtocol)`：

![12738336-6bd07e5c0b2bed90.png][]

image

查看`scheme()`方法，决定采用**元组计划**(`TupleScheme`)还是**标准计划**(`StandardScheme`)来实现序列化，默认采用的是**标准计划**`StandardScheme`。

![12738336-7e0478eba65070cb.png][]

image

**标准计划**(`StandardScheme`)下的`write()`方法：

![12738336-1cb912231ccc7c03.png][]

image

这里完成了几步操作：

(a). 根据`Thrift IDL`文件中定义了`required`的字段验证字段是否正确赋值。

public void validate() throws org.apache.thrift.TException {
      // check for required fields
      if (key == null) {
        throw new org.apache.thrift.protocol.TProtocolException("Required field 'key' was not present! Struct: " + toString());
      }
      if (value == null) {
        throw new org.apache.thrift.protocol.TProtocolException("Required field 'value' was not present! Struct: " + toString());
      }
    }

(b). 通过`writeStructBegin()`记录**写入结构**的**开始标记**。

public void writeStructBegin(TStruct struct) {}

(c). 逐一写入`Pair`对象的各个字段，包括字段**字段开始标记**、**字段的值**和**字段结束标记**。

if (struct.key != null) {
      oprot.writeFieldBegin(KEY_FIELD_DESC);
      oprot.writeString(struct.key);
      oprot.writeFieldEnd();
    }
    // 省略...

(1). 首先是**字段开始标记**，包括`type`和`field-id`。`type`是字段的**数据类型的标识号**，`field-id`是`Thrift IDL`定义的**字段次序**，比如说`key`为1，`value`为2。

public void writeFieldBegin(TField field) throws TException {
      writeByte(field.type);
      writeI16(field.id);
    }

`Thrift`提供了`TType`，对不同的**数据类型**(`type`)提供了唯一标识的`typeID`。

public final class TType {
        public static final byte STOP   = 0;   // 数据读写完成
        public static final byte VOID   = 1;   // 空值
        public static final byte BOOL   = 2;   // 布尔值
        public static final byte BYTE   = 3;   // 字节
        public static final byte DOUBLE = 4;   // 双精度浮点型
        public static final byte I16    = 6;   // 短整型
        public static final byte I32    = 8;   // 整型
        public static final byte I64    = 10;  // 长整型
        public static final byte STRING = 11;  // 字符串类型
        public static final byte STRUCT = 12;  // 引用类型
        public static final byte MAP    = 13;  // Map
        public static final byte SET    = 14;  // 集合
        public static final byte LIST   = 15;  // 列表
        public static final byte ENUM   = 16;  // 枚举
    }

(2). 然后是写入**字段的值**，根据字段的数据类型又归纳为以下实现：`writeByte()`、`writeBool()`、`writeI32()`、`writeI64()`、`writeDouble()`、`writeString()`和`writeBinary()`方法。

`TBinaryProtocol`通过一个长度为`8`的`byte`字节数组缓存**写入**或**读取**的临时字节数据。

private final byte[] inoutTemp = new byte[8];

> **常识1：**16进制的介绍。以0x开始的数据表示16进制，0xff换成十进制为255。在16进制中，A、B、C、D、E、F这五个字母来分别表示10、11、12、13、14、15。

`16`**进制**变**十进制**：f表示15。第n位的权值为16的n次方，由右到左从0位起：0xff = 15*16^1 + 15*16^0 = 255  
`16`**进制**变**二进制**再变**十进制**：0xff = 1111 1111 = 2^8 - 1 = 255

> **常识2：**位运算符的使用。>>表示代表右移符号，如：int i=15; i>>2的结果是3，移出的部分将被抛弃。而<<表示左移符号，与>>刚好相反。

转为**二进制**的形式可能更好理解，0000 1111(15)右移2位的结果是0000 0011(3)，0001 1010(18)右移3位的结果是0000 0011(3)。

*  **writeByte()**：写入**单个字节**数据。

public void writeByte(byte b) throws TException {
      inoutTemp[0] = b;
      trans_.write(inoutTemp， 0， 1);
    }

*  **writeBool()**：写入**布尔值**数据。

public void writeBool(boolean b) throws TException {
      writeByte(b ? (byte)1 : (byte)0);
    }

*  **writeI16()**：写入**短整型**`short`类型数据。

public void writeI16(short i16) throws TException {
      inoutTemp[0] = (byte)(0xff & (i16 >> 8));
      inoutTemp[1] = (byte)(0xff & (i16));
      trans_.write(inoutTemp， 0， 2);
    }

*  **writeI32()**：写入**整型**`int`类型数据。

public void writeI32(int i32) throws TException {
      inoutTemp[0] = (byte)(0xff & (i32 >> 24));
      inoutTemp[1] = (byte)(0xff & (i32 >> 16));
      inoutTemp[2] = (byte)(0xff & (i32 >> 8));
      inoutTemp[3] = (byte)(0xff & (i32));
      trans_.write(inoutTemp， 0， 4);
    }

*  **writeI64()**：写入**长整型**`long`类型数据。

public void writeI64(long i64) throws TException {
      inoutTemp[0] = (byte)(0xff & (i64 >> 56));
      inoutTemp[1] = (byte)(0xff & (i64 >> 48));
      inoutTemp[2] = (byte)(0xff & (i64 >> 40));
      inoutTemp[3] = (byte)(0xff & (i64 >> 32));
      inoutTemp[4] = (byte)(0xff & (i64 >> 24));
      inoutTemp[5] = (byte)(0xff & (i64 >> 16));
      inoutTemp[6] = (byte)(0xff & (i64 >> 8));
      inoutTemp[7] = (byte)(0xff & (i64));
      trans_.write(inoutTemp， 0， 8);
    }

*  **writeDouble()**：写入**双浮点型**`double`类型数据。

public void writeDouble(double dub) throws TException {
      writeI64(Double.doubleToLongBits(dub));
    }

*  **writeString()**：写入**字符串类型**，这里先写入**字符串长度**，再写入**字符串内容**。

public void writeString(String str) throws TException {
      try {
        byte[] dat = str.getBytes("UTF-8");
        writeI32(dat.length);
        trans_.write(dat， 0， dat.length);
      } catch (UnsupportedEncodingException uex) {
        throw new TException("JVM DOES NOT SUPPORT UTF-8");
      }
    }

*  **writeBinary**：写入**二进制数组**类型数据，这里数据输入是`NIO`中的`ByteBuffer`类型。

public void writeBinary(ByteBuffer bin) throws TException {
      int length = bin.limit() - bin.position();
      writeI32(length);
      trans_.write(bin.array()， bin.position() + bin.arrayOffset()， length);
    }

(3). 每个字段写入完成后，都需要记录**字段结束标记**。

public void writeFieldEnd() {}

(d). 当所有的字段都写入以后，需要记录**字段停止标记**。

public void writeFieldStop() throws TException {
      writeByte(TType.STOP);
    }

(e). 当所有数据写入完成后，通过`writeStructEnd()`记录**写入结构**的**完成标记**。

public void writeStructEnd() {}

### (二) readData()分析 ###

查看`thrift`的**反序列化机制**，即**数据读取**实现，同样采用**二进制协议**`TBinaryProtocol`，切入点为`pair.read(TProtocol)`：

![12738336-1f793be5505cbdeb.png][]

image

**数据读取**和**数据写入**一样，也是采用的**标准计划**`StandardScheme`。**标准计划**(`StandardScheme`)下的`read()`方法：

![12738336-cba1f4fbcc4c1d52.png][]

image

这里完成的几步操作：

(a). 通过`readStructBegin`读取**结构**的**开始标记**。

iprot.readStructBegin();

(b). 循环读取**结构**中的**所有字段数据**到`Pair`对象中，直到读取到`org.apache.thrift.protocol.TType.STOP`为止。`iprot.readFieldBegin()`指明开始读取**下一个字段**的前需要读取**字段开始标记**。

while (true) {
      schemeField = iprot.readFieldBegin();
      if (schemeField.type == org.apache.thrift.protocol.TType.STOP) {
        break;
      }
      // 字段的读取，省略...
    }

(c). 根据`Thrift IDL`定义的`field-id`读取对应的字段，并赋值到`Pair`对象中，并设置`Pair`对象相应的字段为**已读状态**(前提：字段在`IDL`中被定义为`required`)。

switch (schemeField.id) {
      case 1: // KEY
        if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
          struct.key = iprot.readString();
          struct.setKeyIsSet(true);
        } else {
          org.apache.thrift.protocol.TProtocolUtil.skip(iprot， schemeField.type);
        }
        break;
      case 2: // VALUE
        if (schemeField.type == org.apache.thrift.protocol.TType.STRING) {
          struct.value = iprot.readString();
          struct.setValueIsSet(true);
        } else {
          org.apache.thrift.protocol.TProtocolUtil.skip(iprot， schemeField.type);
        }
        break;
      default:
        org.apache.thrift.protocol.TProtocolUtil.skip(iprot， schemeField.type);
    }

关于**读取字段**的值，根据字段的**数据类型**也分为以下实现：`readByte()`、`readBool()`、`readI32()`、`readI64()`、`readDouble()`、`readString()`和`readBinary()`方法。

*  **readByte()**：读取**单个字节**数据。

public byte readByte() throws TException {
      if (trans_.getBytesRemainingInBuffer() >= 1) {
        byte b = trans_.getBuffer()[trans_.getBufferPosition()];
        trans_.consumeBuffer(1);
        return b;
      }
      readAll(inoutTemp， 0， 1);
      return inoutTemp[0];
    }

*  **readBool()**：读取**布尔值**数据。

public boolean readBool() throws TException {
      return (readByte() == 1);
    }

*  **readI16()**：读取**短整型**`short`类型数据。

public short readI16() throws TException {
      byte[] buf = inoutTemp;
      int off = 0;
    
      if (trans_.getBytesRemainingInBuffer() >= 2) {
        buf = trans_.getBuffer();
        off = trans_.getBufferPosition();
        trans_.consumeBuffer(2);
      } else {
        readAll(inoutTemp， 0， 2);
      }
    
      return (short) (((buf[off] & 0xff) << 8) |
                     ((buf[off+1] & 0xff)));
    }

*  **readI32()**：读取**整型**`int`类型数据。

public int readI32() throws TException {
      byte[] buf = inoutTemp;
      int off = 0;
    
      if (trans_.getBytesRemainingInBuffer() >= 4) {
        buf = trans_.getBuffer();
        off = trans_.getBufferPosition();
        trans_.consumeBuffer(4);
      } else {
        readAll(inoutTemp， 0， 4);
      }
      return ((buf[off] & 0xff) << 24) |
             ((buf[off+1] & 0xff) << 16) |
             ((buf[off+2] & 0xff) <<  8) |
             ((buf[off+3] & 0xff));
    }

*  **readI64()**：读取**长整型**`long`类型数据。

public long readI64() throws TException {
      byte[] buf = inoutTemp;
      int off = 0;
    
      if (trans_.getBytesRemainingInBuffer() >= 8) {
        buf = trans_.getBuffer();
        off = trans_.getBufferPosition();
        trans_.consumeBuffer(8);
      } else {
        readAll(inoutTemp， 0， 8);
      }
    
      return ((long)(buf[off]   & 0xff) << 56) |
             ((long)(buf[off+1] & 0xff) << 48) |
             ((long)(buf[off+2] & 0xff) << 40) |
             ((long)(buf[off+3] & 0xff) << 32) |
             ((long)(buf[off+4] & 0xff) << 24) |
             ((long)(buf[off+5] & 0xff) << 16) |
             ((long)(buf[off+6] & 0xff) <<  8) |
             ((long)(buf[off+7] & 0xff));
    }

*  **readDouble()**：读取**双精度浮点**`double`类型数据。

public double readDouble() throws TException {
      return Double.longBitsToDouble(readI64());
    }

*  **readString()**：读取**字符串类型**的数据，首先读取并校验`4`字节的**字符串长度**，然后检查`NIO`**缓冲区**中是否有对应长度的字节**未消费**。如果有，直接从**缓冲区**中读取；否则，从**传输通道**中读取数据。

public String readString() throws TException {
      int size = readI32();
      checkStringReadLength(size);
    
      if (trans_.getBytesRemainingInBuffer() >= size) {
        try {
          String s = new String(trans_.getBuffer()， trans_.getBufferPosition()， size， "UTF-8");
          trans_.consumeBuffer(size);
          return s;
        } catch (UnsupportedEncodingException e) {
          throw new TException("JVM DOES NOT SUPPORT UTF-8");
        }
      }
    
      return readStringBody(size);
    }

如果是从**传输通道**中读取数据，查看`readStringBody()`方法：

public String readStringBody(int size) throws TException {
      try {
        byte[] buf = new byte[size];
        trans_.readAll(buf， 0， size);
        return new String(buf， "UTF-8");
      } catch (UnsupportedEncodingException uex) {
        throw new TException("JVM DOES NOT SUPPORT UTF-8");
      }
    }

*  **readBinary()**：读取**二进制数组**类型数据，和**字符串读取**类似，返回一个`ByteBuffer`字节缓存对象。

public ByteBuffer readBinary() throws TException {
      int size = readI32();
      checkStringReadLength(size);
    
      if (trans_.getBytesRemainingInBuffer() >= size) {
        ByteBuffer bb = ByteBuffer.wrap(trans_.getBuffer()， trans_.getBufferPosition()， size);
        trans_.consumeBuffer(size);
        return bb;
      }
    
      byte[] buf = new byte[size];
      trans_.readAll(buf， 0， size);
      return ByteBuffer.wrap(buf);
    }

(d). 每个字段数据读取完成后，都需要再读取一个**字段结束标记**。

public void readFieldEnd() {}

(e). 当所有字段读取完成后，需要通过`readStructEnd()`再读入一个**结构完成标记**。

public void readStructEnd() {}

(f). 读取结束后，同样需要校验在`Thrift IDL`中定义为`required`的字段是否为空，是否合法。

# 总结 #

其实到这里，对于`Thrift`的**序列化机制**和**反序列化机制**的**具体实现**和**高效性**，相信各位已经有了比较深入的认识！

--------------------

欢迎关注技术公众号： 零壹技术栈

![10548396-035e78bdc34c7525][]

零壹技术栈

本帐号将持续分享后端技术干货，包括虚拟机基础，多线程编程，高性能框架，异步、缓存和消息中间件，分布式和微服务，架构学习和进阶等学习资料和文章。

[12738336-e02dcc94678a589d.png]: /images/20220411/d3ac60c62d264e4faf2873e46053f3bf.png
[12738336-6bd07e5c0b2bed90.png]: /images/20220411/981c1c8cd909424cb33ace98d5c18f36.png
[12738336-7e0478eba65070cb.png]: /images/20220411/8fbecd038f9a4eb684ee3abc6f28b96d.png
[12738336-1cb912231ccc7c03.png]: /images/20220411/29e8ea7e4392480684d59f46b3316dc5.png
[12738336-1f793be5505cbdeb.png]: /images/20220411/943b3667d60e4dc180dfaf384829896e.png
[12738336-cba1f4fbcc4c1d52.png]: /images/20220411/235bf6fb403046128a2038453a616241.png
[10548396-035e78bdc34c7525]: /images/20220411/2fad095cd9324267ad8463b44b9d3a4f.png