Another Java Geek

在Thrift的Java库中，读写字符串的编码固定为UTF-8，要想以其它编码（如GBK）来传输字符串不是很灵活（在C/C++中不存在这个问题，因为C/C++中的字符串无非是字节序列）。例如，java版的TCompactProtocol中的readString和writeString代码如下：

public String readString() throws TException {
    int length = readVarint32();
    if (length == 0) {
      return "";
    }
    try {
        if (trans_.getBytesRemainingInBuffer() >= length) {
            String str = new String(trans_.getBuffer(), trans_.getBufferPosition(), length, "UTF-8");
            trans_.consumeBuffer(length);
            return str;
        } else {
            return new String(readBinary(length), "UTF-8");
        }
    } catch (UnsupportedEncodingException e) {
        throw new TException("UTF-8 not supported!");
    }
}

public void writeString(String str) throws TException {
    try {
        byte[] bytes = str.getBytes("UTF-8");
        writeBinary(bytes, 0, bytes.length);
    } catch (UnsupportedEncodingException e) {
        throw new TException("UTF-8 not supported!");
    }
}

以非UTF-8编码传输字符串，看似一个很普遍的需求，但在其自带库中竟然没有支持，在它的JIRA上，我找到了一个有人很早提交的Issue：Support non-UTF-8 in Java and C#，状态是： won’t fix。
提出这个问题的人建议如下：

Thrift的Java和C#类库都假定所有字符串都是UTF-8编码，而下面的方案或许会更好一些:
* 给TProtocol中的readString和writeString方法传一个encoding参数，默认值为UTF-8。
* 生成的struct reader和writer在读写字符串时将encoding参数传递给TProtocol对象。
* 使用一个默认的类型注解覆盖默认的UTF-8编码。
* 除Python3之外，其它所有语言都忽略这个注解。

这个提议非常符合我们的需求，可惜，由于Thrfit的开发者和参与评论的人大多都不认同将编码方案放在Thrift之中，而应当由应用程序自行处理，因此提议被否决了。

老外明显不懂中国国情嘛，众所周知，一个汉字以GBK编码是两个字节，以UTF-8编码是三个字节。这就意味着，在网络上传输中文字符串，GBK编码可以比UTF-8节省1/3的带宽（但是我们通过网络传输的数据不全是中文字符串，也有英文数字，以及数值类型，所以实际节省的没有这么多）。我们可以自己来实现一个TProtocol来支持GBK编码。

由于我们只是要修改一下读写字符串的编码，除了readString和writeString之外，当前所用的TProtocol实现类的其它接口都不变，所以应尽可能复用已有实现。遗憾的是我们使用的TCompactProtocol是final的，因此不能用继承，只好用委托（delegate）。方法是：定义一个GBKCompactProtocol类，保持和TCompactProtocol一致的接口，继承自TProtocol，内部包一个TCompactProtocol实例，除了readString和writeString方法需要重写外，其它方法调用都是直接委托给TCompactProtocol实例。代码如下：

public class GBKCompactProtocol extends TProtocol {
    public static class Factory implements TProtocolFactory {
        public Factory() {}
        public TProtocol getProtocol(TTransport trans) {
            return new GBKCompactProtocol(trans);
        }
    }

    private TCompactProtocol prot;
    public GBKCompactProtocol(TTransport trans) {
        super(null);
        this.prot = new TCompactProtocol(trans);
    }

    public String readString() throws TException {
        int length = readVarint32();
        if (length == 0) {
            return "";
        }
        try {
          if(prot.getTransport().getBytesRemainingInBuffer() >= length){
              String str = new String(prot.getTransport().getBuffer(), prot.getTransport().getBufferPosition(), length, "GBK");
              prot.getTransport().consumeBuffer(length);
              return str;
          } else {
              if (length == 0) {
                  return "";
              }
              byte[] buf = new byte[length];
              prot.getTransport().readAll(buf, 0, length);
              return new String(buf, "GBK");
          }
        } catch (UnsupportedEncodingException e) {
          throw new TException("GBK not supported!");
        }
    }

    public void writeString(String str) throws TException {
        try {
            byte[] bytes = str.getBytes("GBK");
            writeVarint32(bytes.length);
            prot.getTransport().write(bytes, 0, bytes.length);
        } catch (UnsupportedEncodingException e) {
            throw new TException("GBK not supported!");
        }
    }

    private int readVarint32() throws TException {
        int result = 0;
        int shift = 0;
        if (prot.getTransport().getBytesRemainingInBuffer() >= 5) {
            byte[] buf = prot.getTransport().getBuffer();
            int pos = prot.getTransport().getBufferPosition();
            int off = 0;
            while (true) {
                byte b = buf[pos+off];
                result |= (int) (b & 0x7f) << shift;
                if ((b & 0x80) != 0x80) break;
                shift += 7;
                off++;
            }
            prot.getTransport().consumeBuffer(off+1);
        } else {
            while (true) {
                byte b = readByte();
                result |= (int) (b & 0x7f) << shift;
                if ((b & 0x80) != 0x80) break;
                shift += 7;
            }
        }
        return result;
    }

    byte[] i32buf = new byte[5];
    private void writeVarint32(int n) throws TException {
        int idx = 0;
        while (true) {
            if ((n & ~0x7F) == 0) {
                i32buf[idx++] = (byte)n;
                break;
            } else {
                i32buf[idx++] = (byte)((n & 0x7F) | 0x80);
                n >>>= 7;
            }
        }
        prot.getTransport().write(i32buf, 0, idx);
    }

    //其它方法都是直接委托给prot的对应方法，省略
}

由于TCompactProtocol中不少方法都是private的，所以这里把readVarint32和writeVarint32的代码拷了过来，代码显得比较冗长。