Thrift之TProtocol系列TCompactProtocol解析

TCompactProtocol协议作为TBinaryProtocol协议的升级强化版，都作为二进制编码传输方式，采用了一种乐器MIDI文件的编码方法（wiki，百度下），简单介绍下两种思想：

1: ZigZag有符号数编码，如表格所示：

编码前	编码后
0	0
-1	1
1	2
-2	3
2	4
-3	5

其效果等效于正数等于原先 * 2，负数变正数。

32bits int =  (i << 1) ^ (i >> 31), 64bits long = (l << 1) ^ (l >> 63)

:VLQ(variable-length quantity)编码：

           即一字节的最高位（MHB）为标志位，不参与具体的内容，意思数值的大小仅仅有其它七位来表示。当最高位bit为1时，表示下一个byte也是该数值的内容（下一个byte的低七位bits）;当最高位bit为0时，下一个byte不参与其中。通过这样的方式，而不是int固定的4个bytes,long 8个bytes来讲，对于小数，能节约不少的空间大小；但凡事有利有弊，当数值比较大时，就要占用更多的空间，例如较大的int ,需要5bytes,较大的long需要10bytes.

   两者的结合 ：

当VLQ编码遇到负数时，例如：long -1; 0XFFFFFFFFFFFFFFFF,就需要10bytes了，通过和ZigZag的结合，吧负数转变相应的正数。当正数，负数的 |数值|较小时，都可以通过两者的结合，有效的压缩占用的空间大小。但同上，数值较大不可避免的占用比平常正常编码更多的空间。

源码分析：

首先来看一下int32,long64的ZigZag编码：

  private long longToZigzag(long l) {
    return (l << 1) ^ (l >> 63);
  }

  /**
   * Convert n into a zigzag int. This allows negative numbers to be
   * represented compactly as a varint.
   */
  private int intToZigZag(int n) {
    return (n << 1) ^ (n >> 31);//正数 n << 1 扩大两倍 ， n >> 31 = 0 ， ^ 0 不变 ，2 * n ;
  }

再看看int32,long64的varint写法：

 byte[] i32buf = new byte[5]; //int32 最大需要5个字节
  private void writeVarint32(int n) throws TException {
    int idx = 0; //index flag
    while (true) {
      if ((n & ~0x7F) == 0) { // if (n <= 2^7) 1byte
        i32buf[idx++] = (byte)n;
        // writeByteDirect((byte)n);
        break;
        // return;
      } else {
        i32buf[idx++] = (byte)((n & 0x7F) | 0x80); 、//else if(n > 2^ 7) 按小端方式给byte第八位贴上1标签，存放在buf。
        // writeByteDirect((byte)((n & 0x7F) | 0x80));
        n >>>= 7; //逻辑右移7bit，再次判断，loop
      }
    }
    trans_.write(i32buf, 0, idx); //吧buf写入传输层
  }

  /**
   * Write an i64 as a varint. Results in 1-10 bytes on the wire.
   */
  byte[] varint64out = new byte[10];//最大需要10bytes
  private void writeVarint64(long n) throws TException {
    int idx = 0;
    while (true) {
      if ((n & ~0x7FL) == 0) { //注意这边的 ~0x7FL(不能写成0x7F)
        varint64out[idx++] = (byte)n;
        break;
      } else {
        varint64out[idx++] = ((byte)((n & 0x7F) | 0x80));
        n >>>= 7;
      }
    }
    trans_.write(varint64out, 0, idx);
  }

上面注解说明了varint的系统操作，预分配最大字节buffer,然后按照小端方式写入VLQ编码后实际内容。再来看看系统是怎么结合两者的：

 public void writeI32(int i32) throws TException {
    writeVarint32(intToZigZag(i32)); //先调intToZigZag转换，在write VLQ。
  }

  /**
   * Write an i64 as a zigzag varint.
   */
  public void writeI64(long i64) throws TException {
    writeVarint64(longToZigzag(i64));
  }

   public void writeI16(short i16) throws TException { //i16先按int32 zigzag编码转换 然后按VLQ转换
    writeVarint32(intToZigZag(i16));
  }

我们先系统的看一下TCompactProtocol按什么方法写入Thrift内部数据类型的，然后再看message的写法，一下是thrift内部数据类型，i16,i32,i64已经看完，在来看看别的：

  private static class Types {
    public static final byte BOOLEAN_TRUE   = 0x01;
    public static final byte BOOLEAN_FALSE  = 0x02;
    public static final byte BYTE           = 0x03;
    public static final byte I16            = 0x04;
    public static final byte I32            = 0x05;
    public static final byte I64            = 0x06;
    public static final byte DOUBLE         = 0x07;
    public static final byte BINARY         = 0x08;
    public static final byte LIST           = 0x09;
    public static final byte SET            = 0x0A;
    public static final byte MAP            = 0x0B;
    public static final byte STRUCT         = 0x0C;
  }

boolean:

  public void writeBool(boolean b) throws TException {
    if (booleanField_ != null) {
      // we haven't written the field header yet
      writeFieldBeginInternal(booleanField_, b ? Types.BOOLEAN_TRUE : Types.BOOLEAN_FALSE);
      booleanField_ = null;
    } else {
      // we're not part of a field, so just write the value.
      writeByteDirect(b ? Types.BOOLEAN_TRUE : Types.BOOLEAN_FALSE);//按照上面对应的boolean_yes,boolean_no字节值写入。
    }
  }

TCompactProtocol写入Boolean分两种情况，1：该boolean值为TStruct中的内部成员时TField时，得写入header数据（即内容和数据类型压缩在一起写）；2 ：如果不为TField内部类型的话，直接按byte写入。关于TStruct和TField的细节请参照上篇。

具体tstruct写入，稍后分析。

byte:

public void writeByte(byte b) throws TException {
    writeByteDirect(b);//one byte 直接写入。
  }

 private byte[] byteDirectBuffer = new byte[1];
  private void writeByteDirect(byte b) throws TException {
    byteDirectBuffer[0] = b;
    trans_.write(byteDirectBuffer);
  }

double:

  public void writeDouble(double dub) throws TException {
    byte[] data = new byte[]{0, 0, 0, 0, 0, 0, 0, 0}; //8个字节
    fixedLongToBytes(Double.doubleToLongBits(dub), data, 0); //double 转long bit 分布，然后按照fix64编码传输。
    trans_.write(data);
  }

  private void fixedLongToBytes(long n, byte[] buf, int off) {
    buf[off+0] = (byte)( n        & 0xff);
    buf[off+1] = (byte)((n >> 8 ) & 0xff);
    buf[off+2] = (byte)((n >> 16) & 0xff);
    buf[off+3] = (byte)((n >> 24) & 0xff);
    buf[off+4] = (byte)((n >> 32) & 0xff);
    buf[off+5] = (byte)((n >> 40) & 0xff);
    buf[off+6] = (byte)((n >> 48) & 0xff);
    buf[off+7] = (byte)((n >> 56) & 0xff);
  }

可以看出double类型，先按Double.doubletoLongBits()转换后，按照fixed64编码写入（8字节小端写入），如上。

bytearray:

 public void writeBinary(ByteBuffer bin) throws TException {
    int length = bin.limit() - bin.position();//计算数据len
    writeBinary(bin.array(), bin.position() + bin.arrayOffset(), length);
  }

private void writeBinary(byte[] buf, int offset, int length) throws TException {
    writeVarint32(length); //按VLQ编码写入len值，这里没有使用zigzag编码（zigzag编码主要解决负数VLQ编码占用大空间的情况，这里len不为负，直接VLQ写入）
    trans_.write(buf, offset, length);//写入实际内buff中内容
  }

string:

 public void writeString(String str) throws TException {
    try {
      byte[] bytes = str.getBytes("UTF-8");//utf-8编码，得到字节数组
      writeBinary(bytes, 0, bytes.length);//抵用writeBinary,see 上面
    } catch (UnsupportedEncodingException e) {
      throw new TException("UTF-8 not supported!");
    }
  }

容器类型：

SetTag：

public void writeSetBegin(TSet set) throws TException {
    writeCollectionBegin(set.elemType, set.size);//set类型，长度值
  }

type byte:

public final class TType {
  public static final byte STOP   = 0;
  public static final byte VOID   = 1;//java中没有这种类型，这里存在只是为了别的语言，可能
  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;
  public static final byte SET    = 14;
  public static final byte LIST   = 15;
  public static final byte ENUM   = 16;//低下static {}中，该类型也没用到。 所以4bits 够用了
}

 protected void writeCollectionBegin(byte elemType, int size) throws TException {
    if (size <= 14) { // 1110
      writeByteDirect(size << 4 | getCompactType(elemType));//size <= 14时，size << 4 | 对应的TTyte，压缩从一个byte写入。
    } else {
      writeByteDirect(0xf0 | getCompactType(elemType));// 1111 0000| ttype ，按one byte写入
      writeVarint32(size);// VLQ编码写入len
    }
  }

getCompactType(xx):

 private byte getCompactType(byte ttype) {
    return ttypeToCompactType[ttype];
  }

static {
    ttypeToCompactType[TType.STOP] = TType.STOP;
    ttypeToCompactType[TType.BOOL] = Types.BOOLEAN_TRUE;
    ttypeToCompactType[TType.BYTE] = Types.BYTE;
    ttypeToCompactType[TType.I16] = Types.I16;
    ttypeToCompactType[TType.I32] = Types.I32;
    ttypeToCompactType[TType.I64] = Types.I64;
    ttypeToCompactType[TType.DOUBLE] = Types.DOUBLE;
    ttypeToCompactType[TType.STRING] = Types.BINARY;
    ttypeToCompactType[TType.LIST] = Types.LIST;
    ttypeToCompactType[TType.SET] = Types.SET;
    ttypeToCompactType[TType.MAP] = Types.MAP;
    ttypeToCompactType[TType.STRUCT] = Types.STRUCT;
  }

public void writeListEnd() throws TException {} //no-op 空操作，走个形式而已

list tag：

 public void writeListBegin(TList list) throws TException {
    writeCollectionBegin(list.elemType, list.size);
  }

public void writeListEnd() throws TException {}

同上，就不重复了。

map tag:

public void writeMapBegin(TMap map) throws TException {
    if (map.size == 0) {//size == 0
      writeByteDirect(0); //直接写入one byte 0完事。
    } else {
      writeVarint32(map.size); //VLQ写入长度
      writeByteDirect(getCompactType(map.keyType) << 4 | getCompactType(map.valueType)); //one byte 写入 keyType(TType)，valueType(TType)  (keyType << 4 | valueType) 与avro的map不同，其key
    }                                                                                    //type只能为string类型。
  }

wirteMapEnd()也是no-op操作就不贴了。

介绍完内置类型的写入方式，可以介绍写message了。

public void writeMessageBegin(TMessage message) throws TException {
    writeByteDirect(PROTOCOL_ID); // 1000 0010 one byte protocol_id
    writeByteDirect((VERSION & VERSION_MASK) | ((message.type << TYPE_SHIFT_AMOUNT) & TYPE_MASK));// ((0000 0001 & 0001 1111) | (type << 5)) & 1110 0000); one byte高三位messageType |
    writeVarint32(message.seqid);                                                          //低五位version bits,   VLQ编码写入message 的sequence increment id.
    writeString(message.name);  //消息名，即方法名。
  }

 private static final byte PROTOCOL_ID = (byte)0x82;//1000 0010
  private static final byte VERSION = 1;
  private static final byte VERSION_MASK = 0x1f; // 0001 1111
  private static final byte TYPE_MASK = (byte)0xE0; // 1110 0000
  private static final byte TYPE_BITS = 0x07; // 0000 0111
  private static final int  TYPE_SHIFT_AMOUNT = 5;

这里的version应该为了以后的version更新。byte类型的messageType（call, execption, oneway,reply）具体请见上篇TBinaryProtocol分析。为了发消息的完整性，还是贴出TServiceClient的sendBase()步骤：

 protected void sendBase(String methodName, TBase args) throws TException {
    oprot_.writeMessageBegin(new TMessage(methodName, TMessageType.CALL, ++seqid_));
    args.write(oprot_);
    oprot_.writeMessageEnd();
    oprot_.getTransport().flush();
  }

现在该进行TBASE的write（）了，即方法参数和返回值的封装类写，还是以hello.thrift为例：

hellostring_args的write（）：

public void write(org.apache.thrift.protocol.TProtocol oprot) throws org.apache.thrift.TException {
      schemes.get(oprot.getScheme()).getScheme().write(oprot, this);
    }

schema的write():

public void write(org.apache.thrift.protocol.TProtocol oprot, helloString_args struct) throws org.apache.thrift.TException {
        struct.validate();

        oprot.writeStructBegin(STRUCT_DESC);
        if (struct.para != null) {
          oprot.writeFieldBegin(PARA_FIELD_DESC);
          oprot.writeString(struct.para);
          oprot.writeFieldEnd();
        }
        oprot.writeFieldStop();
        oprot.writeStructEnd();
      }

 private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("helloString_args");// 方法参数封装类的TStruct表示。

 private static final org.apache.thrift.protocol.TField PARA_FIELD_DESC = new org.apache.thrift.protocol.TField("para", org.apache.thrift.protocol.TType.STRING, (short)1);

ok,此处的oprot为TCompactProtocol,看看他的writeStructBegin():

 public void writeStructBegin(TStruct struct) throws TException {
    lastField_.push(lastFieldId_);记住上次write struct 最后的field id.
    lastFieldId_ = 0; //从本次参数写开始。
  }

private ShortStack lastField_ = new ShortStack(15); //用于存放Tstructs中的field id（也就是thrift定义文件中service方法参数的标号 1：，2：）;用于跟踪当前struct或者之前struct的field id

接下来，写writeFieldBegin()吧：

 public void writeFieldBegin(TField field) throws TException {
    if (field.type == TType.BOOL) { //如果该方法参数为boolean类型，
      // we want to possibly include the value, so we'll wait.
      booleanField_ = field; //这里先做下标记，等会和具体boolean值一块写，压缩嘛！一开始介绍些基本数据类型（上面）的boolean的两种情况，第一种指当boolean值为Tfield的话，压缩一下，跟这里相结合，
    } else {                 //这里先记录下header metadata,等写实际内容时，即writeBoolean在一块写。
      writeFieldBeginInternal(field, (byte)-1);
    }
  }

private void writeFieldBeginInternal(TField field, byte typeOverride) throws TException {
    // short lastField = lastField_.pop();

    // if there's a type override, use that. // -1获得其内置数据类型，如果非-1情况，（指的是boolean）直接写入其byte值 ，true 0x01,false 0x02
    byte typeToWrite = typeOverride == -1 ? getCompactType(field.type) : typeOverride; // typeOverride为写Boolean值，特设的，对其优化，one byte写入

    // check if we can use delta encoding for the field id 增量式编码前提，用one byte ４ＭＳＢ来做增量式编码，所有field id之间的差不能大于15.每次写Tstruct（即一个方法参数的封装类，其中可能含有很多参数)
    if (field.id > lastFieldId_ && field.id - lastFieldId_ <= 15) { // 因为每次写struct时，都会设置last_fieldid_ = 0,所以都是一次方法RPC调用参数表示ＩＤ之间的比较。不会出现上次ＲＰＣ方法调用的参数ｉｄ和
      // write them together　　　　　　　　　　　　　　　　　　　　　　／／本次ＲＰＣ方法调用参数ｉｄ的比较。　
      writeByteDirect((field.id - lastFieldId_) << 4 | typeToWrite);　　／／本次field id和上次field id做增量 << 4和复写标志做 |，用一个byte传输，压缩空间。
    } else {
      // write them separate
      writeByteDirect(typeToWrite); //分开写 one byte 复写标志。
      writeI16(field.id); //i16 （zigzag + vlq编码）写入，参数个数最大2^16个。
    }

    lastFieldId_ = field.id; //重新复制lastfield_id
    // lastField_.push(field.id);
  }

然后就是写具体的参数值内容了，写完后写上writeFieldEnd()操作；

structs所有的参数都写完后，调用writeFieldStop():

 public void writeFieldStop() throws TException {
    writeByteDirect(TType.STOP);// one byte value 0,占位符吧，标志读完了。
  }

writeStructEnd():

  public void writeStructEnd() throws TException {
    lastFieldId_ = lastField_.pop();//重新写structs时，会吧这值压入stack,并重新附上0.
  }

public void writeMessageEnd() throws TException {}

读操作就不分析了，朋友们可以参照了去看看。