thrift通讯框架

一. Thrift 的初识

1.什么是thrift?

简单来说,是Facebook公布的一款开源跨语言的RPC框架.

那么问题来了.

2.什么是RPC框架？

      RPC全称为Remote Procedure Call,意为远程过程调用.

　　假设有两台服务器A,B.A服务器上部署着一个应用a,B服务器上部署着一个应用b,现在a希望能够调用b应用的某个函数(方法),但是二者不在同一个进程内,不能直接调用,就需要通过网络传输,在AB服务器之间建一条网络传输通道,a把参数传过去,b接收到参数调用自己的方法,得到结果,再通过网络传回给a,简单讲就是A通过网络来调用B的过程.这个过程要涉及的东西很多,比如多线程,Socket,序列化反序列化,网络I/O,很复杂,于是牛掰的程序员把这些封装起来做成一套框架,供大家使用,就是RPC框架.

        一言以蔽之，RPC 是一种通过网络从远程计算机程序上请求服务的方式，它使得开发包括网络分布式多程序在内的应用程序更加容易。

 

二. Thrift 的特点

 

        Thrift 最初是由 Facebook 开发用做系统内各语言之间的 RPC 通信的一个可扩展且跨语言的软件框架，它结合了功能强大的软件堆栈和代码生成引擎，允许定义一个简单的定义文件中的数据类型和服务接口，以作为输入文件，编译器生成代码用来方便地生成RPC客户端和服务器通信的无缝跨编程语言。

       Thrift 是 IDL 描述性语言的一个具体实现，适用于程序对程序静态的数据交换，需要先确定好数据结构。

       Thrift 是完全静态化的，当数据结构发生变化时，必须重新编辑IDL文件、代码生成再编译载入的流程，跟其他IDL工具相比较可以视为是 Thrift 的弱项。Thrift 适用于搭建大型数据交换及存储的通用工具，在大型系统中的内部数据传输上相对于 JSON 和 XML 无论在性能、传输大小上有明显的优势。

   注意， Thrift 不仅仅是个高效的序列化工具，它是一个完整的 RPC 框架体系！

2.1 堆栈结构

如图 下图，Thrift 包含一个完整的堆栈结构用于构建客户端和服务器端。

       其中代码框架层是根据 Thrift 定义的服务接口描述文件生成的客户端和服务器端代码框架，数据读写操作层是根据 Thrift 文件生成代码实现数据的读写操作。

2.2 client/server调用流程

首先来看下 Thrift 服务端是如何启动并提供服务的，如下图

      上图所示是 HelloServiceServer 启动的过程，以及服务被客户端调用时服务器的响应过程。我们可以看到，程序调用了 TThreadPoolServer 的 serve() 方法后，server 进入阻塞监听状态，其阻塞在 TServerSocket 的 accept()方法上。当接收到来自客户端的消息后，服务器发起一个新线程处理这个消息请求，原线程再次进入阻塞状态。在新线程中，服务器通过 TBinaryProtocol 协议读取消息内容，调用 HelloServiceImpl 的 helloVoid() 方法，并将结果写入 helloVoid_result 中传回客户端。

 

在服务启动后，客户端就开始调用其服务，如图 

       上图展示的是 HelloServiceClient 调用服务的过程，以及接收到服务器端的返回值后处理结果的过程。我们可以看到，程序调用了 Hello.Client 的 helloVoid() 方法，在 helloVoid() 方法中，通过 send_helloVoid() 方法发送对服务的调用请求，通过 recv_helloVoid() 方法接收服务处理请求后返回的结果。

 

2.3数据类型了解

Thrift 支持几大类数据结构：基本类型、结构体和异常类型、容器类型、服务类型。

基本类型：

bool：布尔值 (true or false), one byte byte：有符号字节 i16：16位有符号整型 i32：32位有符号整型 i64：64位有符号整型 double：64位浮点型 string：未知编码或者二进制的字符串

 

 

 

 

 

 

结构体和异常类型：

Thrift 结构体 (struct) 在概念上类似于 C 语言结构体类型，在 java 中 Thrift 结构体将会被转换成面向对象语言的类。struct 的定义如下：

struct UserDemo { 　　1: i32 id; 　　2: string name; 　　3: i32 age = 25; 　　4： string phone; }

 

 

 

 

 

struct 具有以下特性：

1.struct 不能继承，但是可以嵌套，不能嵌套自己   其成员都是有明确类型 2.成员是被正整数编号过的，其中的编号使不能重复的，这个是为了在传输过程中编码使用（详情往下看备注1） 3.成员分割符可以是逗号（,）或是分号（;），而且可以混用，但是为了清晰期间，建议在定义中只使用一种，比如java学习者可以就使用逗号（;） 4.字段会有optional和required之分（详情往下看备注2） 5.每个字段可以设置默认值 6.同一文件可以定义多个struct，也可以定义在不同的文件，进行include引入

 

 

 

 

 

 

 

 

备注1：数字标签作用非常大，随着项目开发的不断发展，也许字段会有变化，但是建议不要轻易修改这些数字标签，修改之后如果没有同步客户端和服务器端会让一方解析出问题。

备注2：关于 struct 字段类型，规范的 struct 定义中的每个域均会使用 required 或者 optional 关键字进行标识，但是如果不指定则为无类型，可以不填充该值，但是在序列化传输的时候也会序列化进去。其中 optional 是不填充则不序列化，required 是必须填充也必须序列化。如果 required 标识的域没有赋值，Thrift 将给予提示；如果 optional 标识的域没有赋值，该域将不会被序列化传输；如果某个 optional 标识域有缺省值而用户没有重新赋值，则该域的值一直为缺省值；如果某个 optional 标识域有缺省值或者用户已经重新赋值，而不设置它的 __isset 为 true，也不会被序列化传输。
异常在语法和功能上相当于结构体，差别是异常使用关键字 exception 而不是 struct 声明。它在语义上不同于结构体：当定义一个 RPC 服务时，开发者可能需要声明一个远程方法抛出一个异常。

 

容器类型

Thrift 容器与目前流行编程语言的容器类型相对应，有3种可用容器类型：

1.list<t>：元素类型为t的有序表，容许元素重复。对应java的ArrayList 2.set<t>：元素类型为t的无序表，不容许元素重复。对应java的HashSet 3.map<t,t>：键类型为t，值类型为t的kv对，键不容许重复。对对应Java的HashMap

 

 

 

 

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

 

服务类型

服务的定义方法在语义上等同于面向对象语言中的接口。Thrift 编译器会产生执行这些接口的 client 和 server 存根（详情下一节会具体描述）。下面我们就举个简单的例子解释 service 如何定义：

service QuerySrv{ 　　/** 　　* 本方法实现根据名字和年龄来找到对应的用户信息 　　*/ 　　UserDemo qryUser(1:string name, 2:i32 age);   　　/** 　　* 本方法实现根据id找到对应用户的手机号码 　　*/ 　　string queryPhone(1:i32 id); }

 

 

 

 

 

 

 

在上面的例子中我们定义了一个 service 类型的结构，里面包含两个方法的定义。

在定义 services 的时候，我们还需要了解一下规则：

1.继承类必须实现这些方法 2.参数可以是基本类型或者结构体 3.所有的参数都是const类型，不能作为返回值 4.返回值可以是void（oneway的返回值一定是void） 5.服务支持继承，一个service可使用extends关键字继承另一个service 6.服务不支持重载

 

 

 

 

 

枚举类型

enum TweetType { TWEET, // 编译器默认从1开始赋值 RETWEET = 2, // 可以赋予某个常量某个整数 DM = 0xa, //允许常量是十六进制整数 REPLY // 末尾没有逗号 } struct Tweet { 1: required i32 userId; 2: required string userName; 3: required string text; 4: optional Location loc; 5: optional TweetType tweetType = TweetType.TWEET // 给常量赋缺省值时，使用常量的全称 16: optional string language = "english" }

 

 

 

 

 

 

 

 

 

 

 

 

常量类型

Thrift允许用户定义常量，复杂的类型和结构体可使用JSON形式表示

const i32 INT_CONST = 1234; // 分号是可选的 const map<string,string> MAP_CONST = {"hello": "world", "goodnight": "moon"}

 

 

 

 

PS：跟C语言类似，Thrift也支持typedef语句，例如：

typedef i32 MyInteger

 

 

 

命名空间

       Thrift 中的命名空间类似于 java 中的 package，它们提供了一种组织（隔离）代码的简便方式。名字空间也可以用于解决类型定义中的名字冲突。

 

2.4 传输体系

传输协议

           Thrift 支持多种传输协议，用户可以根据实际需求选择合适的类型。Thrift 传输协议上总体可划分为文本 (text) 和二进制 (binary) 传输协议两大类，一般在生产环境中使用二进制类型的传输协议为多数（相对于文本和 JSON 具有更高的传输效率）。常用的协议包含：

1.TBinaryProtocol：是Thrift的默认协议，使用二进制编码格式进行数据传输，基本上直接发送原始数据 2.TCompactProtocol：压缩的、密集的数据传输协议，基于Variable-length quantity的zigzag 编码格式 3.TJSONProtocol：以JSON (JavaScript Object Notation)数据编码协议进行数据传输 4.TDebugProtocol：常常用以编码人员测试，以文本的形式展现方便阅读

 

 

 

 

 

关于以上几种类型的传输协议，如果想更深入更具体的了解其实现及工作原理，可以参考站外相关文章《thrift源码研究》。

 

传输方式

与传输协议一样，Thrift 也支持几种不同的传输方式。
1. TSocket：阻塞型 socket，用于客户端，采用系统函数 read 和 write 进行读写数据。
2. TServerSocket：非阻塞型 socket，用于服务器端，accecpt 到的 socket 类型都是 TSocket（即阻塞型 socket）。
3. TBufferedTransport 和 TFramedTransport 都是有缓存的，均继承TBufferBase，调用下一层 TTransport 类进行读写操作吗，结构极为相似。其中 TFramedTransport 以帧为传输单位，帧结构为：4个字节（int32_t）+传输字节串，头4个字节是存储后面字节串的长度，该字节串才是正确需要传输的数据，因此 TFramedTransport 每传一帧要比 TBufferedTransport 和 TSocket 多传4个字节。
4. TMemoryBuffer 继承 TBufferBase，用于程序内部通信用，不涉及任何网络I/O，可用于三种模式：（1）OBSERVE模式，不可写数据到缓存；（2）TAKE_OWNERSHIP模式，需负责释放缓存；（3）COPY模式，拷贝外面的内存块到TMemoryBuffer。
5. TFileTransport 直接继承 TTransport，用于写数据到文件。对事件的形式写数据，主线程负责将事件入列，写线程将事件入列，并将事件里的数据写入磁盘。这里面用到了两个队列，类型为 TFileTransportBuffer，一个用于主线程写事件，另一个用于写线程读事件，这就避免了线程竞争。在读完队列事件后，就会进行队列交换，由于由两个指针指向这两个队列，交换只要交换指针即可。它还支持以 chunk（块）的形式写数据到文件。
6. TFDTransport 是非常简单地写数据到文件和从文件读数据，它的 write 和 read 函数都是直接调用系统函数 write 和 read 进行写和读文件。
7. TSimpleFileTransport 直接继承 TFDTransport，没有添加任何成员函数和成员变量，不同的是构造函数的参数和在 TSimpleFileTransport 构造函数里对父类进行了初始化（打开指定文件并将fd传给父类和设置父类的close_policy为CLOSE_ON_DESTROY）。
8. TZlibTransport 跟 TBufferedTransport 和 TFramedTransport一样，调用下一层 TTransport 类进行读写操作。它采用<zlib.h>提供的 zlib 压缩和解压缩库函数来进行压解缩，写时先压缩再调用底层 TTransport 类发送数据，读时先调用 TTransport 类接收数据再进行解压，最后供上层处理。
9. TSSLSocket 继承 TSocket，阻塞型 socket，用于客户端。采用 openssl 的接口进行读写数据。checkHandshake(）函数调用 SSL_set_fd 将 fd 和 ssl 绑定在一起，之后就可以通过 ssl 的 SSL_read和SSL_write 接口进行读写网络数据。
10. TSSLServerSocket 继承 TServerSocket，非阻塞型 socket， 用于服务器端。accecpt 到的 socket 类型都是 TSSLSocket 类型。
11. THttpClient 和 THttpServer 是基于 Http1.1 协议的继承 Transport 类型，均继承 THttpTransport，其中 THttpClient 用于客户端，THttpServer 用于服务器端。两者都调用下一层 TTransport 类进行读写操作，均用到TMemoryBuffer 作为读写缓存，只有调用 flush() 函数才会将真正调用网络 I/O 接口发送数据。

 

TTransport 是所有 Transport 类的父类，为上层提供了统一的接口而且通过 TTransport 即可访问各个子类不同实现，类似多态。

 

三. 选择 java server 的艺术

Thrift 包含三个主要的组件：protocol（传输协议），transport（传输方式） 和 server。

注：还有一个处理层processor(处理层)

其中，protocol 定义了消息是怎样序列化的；transport 定义了消息是怎样在客户端和服务器端之间通信的；server 用于从 transport 接收序列化的消息，根据 protocol 反序列化之，调用用户定义的消息处理器，并序列化消息处理器的响应，然后再将它们写回 transport。

Thrift 模块化的结构使得它能提供各种 server 实现。下面列出了 Java 中可用的 server 实现：

1.TSimpleServer 2.TNonblockingServer 3.THsHaServer 4.TThreadedSelectorServer 5.TThreadPoolServer

 

 

 

 

       有多个选择固然是很好的，但如果不清楚个中差别则是个灾难。所以接下来就谈谈这些 server 之间的区别，并通过一些简单的测试以说明它们的性能特点。

TSimpleServer

TSimplerServer 接受一个连接，处理连接请求，直到客户端关闭了连接，它才回去接受一个新的连接。正因为它只在一个单独的线程中以阻塞 I/O 的方式完成这些工作，所以它只能服务一个客户端连接，其他所有客户端在被服务器端接受之前都只能等待。

TSimpleServer 主要用于测试目的，不要在生产环境中使用它！

TNonblockingServer vs. THsHaServer

TNonblockingServer 使用非阻塞的 I/O 解决了 TSimpleServer 一个客户端阻塞其他所有客户端的问题。它使用了 java.nio.channels.Selector，通过调用 select()，它使得你阻塞在多个连接上，而不是阻塞在单一的连接上。当一或多个连接准备好被接受/读/写时，select() 调用便会返回。TNonblockingServer 处理这些连接的时候，要么接受它，要么从它那读数据，要么把数据写到它那里，然后再次调用 select() 来等待下一个可用的连接。通用这种方式，server 可同时服务多个客户端，而不会出现一个客户端把其他客户端全部“饿死”的情况。
然而，还有个棘手的问题：所有消息是被调用 select() 方法的同一个线程处理的。假设有10个客户端，处理每条消息所需时间为100毫秒，那么，latency 和吞吐量分别是多少？当一条消息被处理的时候，其他9个客户端就等着被 select，所以客户端需要等待1秒钟才能从服务器端得到回应，吞吐量就是10个请求/秒。如果可以同时处理多条消息的话，会很不错吧？
因此，THsHaServer（半同步/半异步的 server）就应运而生了。它使用一个单独的线程来处理网络I/O，一个独立的 worker 线程池来处理消息。这样，只要有空闲的 worker 线程，消息就会被立即处理，因此多条消息能被并行处理。用上面的例子来说，现在的 latency 就是100毫秒，而吞吐量就是100个请求/秒。
为了演示做了一个测试，有10客户端和一个修改过的消息处理器——它的功能仅仅是在返回之前简单地 sleep 100 毫秒。使用的是有10个 worker 线程的 THsHaServer。消息处理器的代码看上去就像下面这样：

public ResponseCode sleep() throws TException{       try {         Thread.sleep(100);     } catch (Exception ex) {     }     return ResponseCode.Success; }

 

 

 

 

 

结果正如我们想像的那样，THsHaServer 能够并行处理所有请求，而 TNonblockingServer 只能一次处理一个请求。

THsHaServer vs. TThreadedSelectorServer

Thrift 0.8 引入了另一种 server 实现，即 TThreadedSelectorServer。它与 THsHaServer 的主要区别在于，TThreadedSelectorServer 允许你用多个线程来处理网络 I/O。它维护了两个线程池，一个用来处理网络 I/O，另一个用来进行请求的处理。当网络 I/O 是瓶颈的时候，TThreadedSelectorServer 比 THsHaServer 的表现要好。为了展现它们的区别进行一个测试，令其消息处理器在不做任何工作的情况下立即返回，以衡量在不同客户端数量的情况下的平均 latency 和吞吐量。对 THsHaServer，使用32个 worker 线程；对 TThreadedSelectorServer，使用16个 worker 线程和16个 selector 线程。

结果显示，TThreadedSelectorServer 比 THsHaServer 的吞吐量高得多，并且维持在一个更低的 latency 上。

 

TThreadedSelectorServer vs. TThreadPoolServer

最后，还剩下 TThreadPoolServer。TThreadPoolServer 与其他三种 server 不同的是：

有一个专用的线程用来接受连接 一旦接受了一个连接，它就会被放入 ThreadPoolExecutor 中的一个 worker 线程里处理。 worker 线程被绑定到特定的客户端连接上，直到它关闭。一旦连接关闭，该 worker 线程就又回到了线程池中。 你可以配置线程池的最小、最大线程数，默认值分别是5（最小）和 Integer.MAX_VALUE（最大）。

 

 

 

 

 

这意味着，如果有1万个并发的客户端连接，你就需要运行1万个线程。所以它对系统资源的消耗不像其他类型的 server 一样那么“友好”。此外，如果客户端数量超过了线程池中的最大线程数，在有一个 worker 线程可用之前，请求将被一直阻塞在那里。

我们已经说过，TThreadPoolServer 的表现非常优异。在我正在使用的计算机上，它可以支持1万个并发连接而没有任何问题。如果你提前知道了将要连接到你服务器上的客户端数量，并且你不介意运行大量线程的话，TThreadPoolServer 对你可能是个很好的选择。

我想你可以从上面的描述可以帮你做出决定：哪一种 Thrift server 适合你。

TThreadedSelectorServer 对大多数案例来说都是个安全之选。如果你的系统资源允许运行大量并发线程的话，建议你使用 TThreadPoolServer。

 

四. 实践一下

 

上面已经介绍了很多理论知识了，很多同学还是不知道如何使用呢！好吧，是时候表演真正的技术了（LOL...）。

所谓大道至简，讲的就是最简单的代码就是最优美的代码，只要功能强悍，最简单的代码也掩盖不了它出众的气质。下面就来给大伙儿讲讲如何使用 Thrift 强大的代码生成引擎来生成 java 代码，并通过详细的步骤实现 Thrift Server 和 Client 调用。

步骤一：首先从官网中下载对应的 Window 平台编译器。使用 IDL 描述语言建立 .thrift 文件。本文提供一个实现简单功能的测试案例，如下所示：

/** * 文件名为TestQry.thrift * 实现功能：创建一个查询结果struct和一个服务接口service * 基于：thrift-0.9.2 **/ namespace java com.thrift struct QryResult {         /**         *返回码, 1成功，0失败         */         1:i32 code;         /**         *响应信息         */         2:string msg; } service TestQry{         /**         * 测试查询接口，当qryCode值为1时返回"成功"的响应信息，qryCode值为其他值时返回"失败"的响应信息         * @param qryCode测试参数         */         QryResult qryTest(1:i32 qryCode) }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

步骤二：将上述 TestQry.thrift 文件与 thrift-0.11.0.exe 放在同一目录，如下：

在命令提示符 CMD 中进入文件目录所在目录，执行代码生成命令：

thrift-0.11.0.exe -r -gen java TestQry.thrift

 

 

执行之后，我们在文件夹中可以看到生成的 java 代码

步骤三：接下来我们新建 Maven Project（注意：JDK 版本1.5及以上），将上一步骤生成的代码拷贝到项目，并在 pom.xml 中加载 Thrift 的依赖，如下

<dependency> 　　　　<groupId>org.apache.thrift</groupId> 　　　　<artifactId>libthrift</artifactId> 　　　　<version>0.11.0</version> 　　</dependency>

 

 

 

 

步骤四：创建 QueryImp.java 实现 TestQry.Iface 接口，关键代码如下

public class QueryImp implements TestQry.Iface{ 　　@Override 　　public QryResult qryTest(int qryCode) throws TException { 　　　　QryResult result = new QryResult(); 　　　　if(qryCode==1){ 　　　　　　result.code = 1; 　　　　　　result.msg = "success"; 　　　　}else{ 　　　　　　result.code = 0; 　　　　　　result.msg = "fail"; 　　　　} 　　　　return result; 　　} }

 

 

 

 

 

 

 

 

 

步骤五：创建 ThriftServerDemo.java 实现服务端（本例采用非阻塞I/O，二进制传输协议），关键代码如下

public class ThriftServerDemo { 　　private final static int DEFAULT_PORT = 30001; 　　private static TServer server = null; 　　public static void main(String[] args){ 　　　　try { 　　　　　　TNonblockingServerSocket socket = new TNonblockingServerSocket(DEFAULT_PORT); 　　　　　　TestQry.Processor processor = new TestQry.Processor(new QueryImp()); 　　　　　　TNonblockingServer.Args arg = new TNonblockingServer.Args(socket); 　　　　　　arg.protocolFactory(new TBinaryProtocol.Factory()); 　　　　　　arg.transportFactory(new TFramedTransport.Factory()); 　　　　　　arg.processorFactory(new TProcessorFactory(processor)); 　　　　　　server = new TNonblockingServer (arg); 　　　　　　server.serve(); 　　　　} catch (TTransportException e) { 　　　　　　e.printStackTrace(); 　　　　} 　　} }

 

 

 

 

 

 

 

 

 

 

 

 

步骤六：创建 ThriftClientDemo.java 实现客户端，关键代码如下

public class ThriftClientDemo { 　　private final static int DEFAULT_QRY_CODE = 1; 　　public static void main(String[] args){ 　　　　try { 　　　　　　TTransport tTransport = getTTransport(); 　　　　　　TProtocol protocol = new TBinaryProtocol(tTransport); 　　　　　　TestQry.Client client = new TestQry.Client(protocol); 　　　　　　QryResult result = client.qryTest(DEFAULT_QRY_CODE); 　　　　　　System.out.println("code="+result.code+" msg="+result.msg); 　　　　}catch (Exception e) { 　　　　　　e.printStackTrace(); 　　　　} 　　} 　　private static TTransport getTTransport() throws Exception{ 　　　　try{ 　　　　　　TTransport tTransport = getTTransport("127.0.0.1", 30001, 5000); 　　　　　　if(!tTransport.isOpen()){ 　　　　　　　　tTransport.open(); 　　　　　　} 　　　　　　return tTransport; 　　　　}catch(Exception e){ 　　　　　　e.printStackTrace(); 　　　　} 　　　　return null; 　　} 　　private static TTransport getTTransport(String host, int port, int timeout) { 　　　　final TSocket tSocket = new TSocket(host, port, timeout); 　　　　final TTransport transport = new TFramedTransport(tSocket); 　　　　return transport; 　　} }

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

好的，所有准备工作都已经做好了，接下来我们就来进行 Client 和 Server 的通信。先运行 ThriftServerDemo 启动 Server，然后运行 ThriftClientDemo.java 创建 Client 进行调用，当 qryCode = 1 时，结果如下

code=1 msg=success

 

 

当 qryCode = 0 时，结果如下

code=0 msg=fail

 

 

到目前为止你所看到的都不是源码分析层面的知识，本文的目的也并非在此。

参考文章

[1] 《Apache Thrift - 可伸缩的跨语言服务开发框架》

[2] 《Thrift Java Servers Compared》

出处：http://www.cnblogs.com/cyfonly/