JAVA RPC (六) 之thrift反序列化RPC消息体

我们来看一下服务端的简单实现，直接上thrift代码，很直观的来看一看thrift的server到底干了些什么

 public boolean process(TProtocol in, TProtocol out) throws TException {
        TMessage msg = in.readMessageBegin();
        ProcessFunction fn = (ProcessFunction)this.processMap.get(msg.name);
        if (fn == null) {
            TProtocolUtil.skip(in, (byte)12);
            in.readMessageEnd();
            TApplicationException x = new TApplicationException(1, "Invalid method name: '" + msg.name + "'");
            out.writeMessageBegin(new TMessage(msg.name, (byte)3, msg.seqid));
            x.write(out);
            out.writeMessageEnd();
            out.getTransport().flush();
            return true;
        } else {
            fn.process(msg.seqid, in, out, this.iface);
            return true;
        }
    }

TMessage msg = in.readMessageBegin();这段代码的意思是从client端获取到二进制数据时候，获取Tmessage实例，和client的wirteMessage方法进行对应，聪明的小伙伴这个时候一定会想到这个是怎么解析的
为什么没有解析消息体长度和消息体内容的部分代码，不要着急我们一步一步渗透，readMessageBegin核心代码如下

 public TMessage readMessageBegin() throws TException {
        int size = this.readI32();
        if (size < 0) {
            int version = size & -65536;
            if (version != -2147418112) {
                throw new TProtocolException(4, "Bad version in readMessageBegin");
            } else {
                return new TMessage(this.readString(), (byte)(size & 255), this.readI32());
            }
        } else if (this.strictRead_) {
            throw new TProtocolException(4, "Missing version in readMessageBegin, old client?");
        } else {
            return new TMessage(this.readStringBody(size), this.readByte(), this.readI32());
        }
    }

int size = this.readI32();是做了些什么，接着往下看

public int readI32() throws TException {
        byte[] buf = this.i32rd;
        int off = 0;
        if (this.trans_.getBytesRemainingInBuffer() >= 4) {
            buf = this.trans_.getBuffer();
            off = this.trans_.getBufferPosition();
            this.trans_.consumeBuffer(4);
        } else {
            this.readAll(this.i32rd, 0, 4);
        }

        return (buf[off] & 255) << 24 | (buf[off + 1] & 255) << 16 | (buf[off + 2] & 255) << 8 | buf[off + 3] & 255;
    }

这个地方代码就很清晰了，原来是从trans里面或取得字节流数据。

private int readAll(byte[] buf, int off, int len) throws TException {
        this.checkReadLength(len);
        return this.trans_.readAll(buf, off, len);
    }

继续能翻到最终的代码解析部分

private void readFrame() throws TTransportException {
        this.transport_.readAll(this.i32buf, 0, 4);
        int size = decodeFrameSize(this.i32buf);
        if (size < 0) {
            throw new TTransportException("Read a negative frame size (" + size + ")!");
        } else if (size > this.maxLength_) {
            throw new TTransportException("Frame size (" + size + ") larger than max length (" + this.maxLength_ + ")!");
        } else {
            byte[] buff = new byte[size];
            this.transport_.readAll(buff, 0, size);
            this.readBuffer_.reset(buff);
        }
    }

这里就很明显了，首先read一个四个字节的长度，这个int类型代表着后面要跟着接收的消息体的长度，来源是client的发送内容，然后在根据消息体长度在读出来所有的内容，然后缓存到readBuffer_中，然后再读取内容的时候直接从readBuffer_中获取字节流就可以了。

好了，服务端接收二进制数据解析的关键点就在这里了,接下来开始，我将用大量的篇幅开始讲解我的企业级RPC框架，满满的干货，感兴趣的小伙伴去我码云给个star吧！！！

https://gitee.com/a1234567891/koalas-rpc

koalas-RPC 个人作品，提供大家交流学习，有意见请私信，欢迎拍砖。客户端采用thrift协议，服务端支持netty和thrift的TThreadedSelectorServer半同步半异步线程模型，支持动态扩容，服务上下线，权重动态，可用性配置，页面流量统计等，持续为个人以及中小型公司提供可靠的RPC框架技术方案

更多学习内容请加高级java QQ群:825199617