Apache Thrift系列详解(一) - 概述与入门

左手的ㄟ右手 2022-05-11 10:36 167阅读 0赞

# 前言 #

`Thrift`是一个**轻量级**、**跨语言**的**远程服务调用**框架，最初由`Facebook`开发，后面进入`Apache`开源项目。它通过自身的`IDL`**中间语言**, 并借助**代码生成引擎**生成各种主流语言的`RPC`**服务端**/**客户端**模板代码。

`Thrift`支持多种不同的**编程语言**，包括`C++`、`Java`、`Python`、`PHP`、`Ruby`等，本系列主要讲述基于`Java`语言的`Thrift`的配置方式和具体使用。

# 正文 #

## Thrift的技术栈 ##

`Thrift`对**软件栈**的定义非常的清晰, 使得各个组件能够**松散的耦合**, 针对不同的应用场景, 选择不同是方式去搭建服务。

![Apache_thrift_architecture.png][]

`Thrift`**软件栈**分层**从下向上**分别为：**传输层**(`Transport Layer`)、**协议层**(`Protocol Layer`)、**处理层**(`Processor Layer`)和**服务层**(`Server Layer`)。

*  **传输层**(`Transport Layer`)：传输层负责直接从网络中**读取**和**写入**数据，它定义了具体的**网络传输协议**；比如说`TCP/IP`传输等。
 *  **协议层**(`Protocol Layer`)：协议层定义了**数据传输格式**，负责网络传输数据的**序列化**和**反序列化**；比如说`JSON`、`XML`、**二进制数据**等。
 *  **处理层**(`Processor Layer`)：处理层是由具体的`IDL`（**接口描述语言**）生成的，封装了具体的**底层网络传输**和**序列化方式**，并委托给用户实现的`Handler`进行处理。
 *  **服务层**(`Server Layer`)：整合上述组件，提供具体的**网络线程/IO服务模型**，形成最终的服务。

## Thrift的特性 ##

### (一) 开发速度快 ###

通过编写`RPC`接口`Thrift IDL`文件，利用**编译生成器**自动生成**服务端骨架**(`Skeletons`)和**客户端桩**(`Stubs`)。从而省去开发者**自定义**和**维护接口编解码**、**消息传输**、**服务器多线程模型**等基础工作。

*  服务端：只需要按照**服务骨架**即**接口**，编写好具体的**业务处理程序**(`Handler`)即**实现类**即可。
 *  客户端：只需要拷贝`IDL`定义好的**客户端桩**和**服务对象**，然后就像调用本地对象的方法一样调用远端服务。

### (二) 接口维护简单 ###

通过维护`Thrift`格式的IDL（**接口描述语言**）文件（注意写好注释），即可作为给`Client`使用的接口文档使用，也**自动生成**接口代码，始终保持代码和文档的一致性。且`Thrift`协议可灵活支持**接口**的**可扩展性**。

### (三) 学习成本低 ###

因为其来自`Google Protobuf`开发团队，所以其`IDL`文件风格类似`Google Protobuf`，且更加**易读易懂**；特别是`RPC`**服务接口**的风格就像写一个**面向对象**的`Class`一样简单。

初学者只需参照：[http://thrift.apache.org/][http_thrift.apache.org]，一个多小时就可以理解`Thrift IDL`文件的语法使用。

### (四) 多语言/跨语言支持 ###

`Thrift`支持`C++`、 `Java`、`Python`、`PHP`、`Ruby`、`Erlang`、`Perl`、`Haskell`、`C#`、`Cocoa`、`JavaScript`、`Node.js`、`Smalltalk`等多种语言，即可生成上述语言的**服务器端**和**客户端程序**。

对于我们经常使用的`Java`、`PHP`、`Python`、`C++`支持良好，虽然对`iOS`环境的`Objective-C`(`Cocoa`)支持稍逊，但也完全满足我们的使用要求。

### (五) 稳定/广泛使用 ###

`Thrift`在很多开源项目中已经被验证是**稳定**和**高效**的，例如`Cassandra`、`Hadoop`、`HBase`等；国外在`Facebook`中有广泛使用，国内包括百度、美团小米、和饿了么等公司。

![Service_use_thrift.png][]

## Thrift的数据类型 ##

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的传输层 ##

常用的传输层有以下几种：

*  TSocket：使用**阻塞式**`I/O`进行传输，是最常见的模式
 *  TNonblockingTransport：使用**非阻塞方式**，用于构建**异步客户端**
 *  TFramedTransport：使用**非阻塞方式**，按**块的大小**进行传输，类似于`Java`中的`NIO`

## Thrift的服务端类型 ##

*  TSimpleServer：**单线程**服务器端，使用标准的**阻塞式**`I/O`
 *  TThreadPoolServer：**多线程**服务器端，使用标准的**阻塞式**`I/O`
 *  TNonblockingServer：**单线程**服务器端，使用**非阻塞式**`I/O`
 *  THsHaServer：**半同步半异步**服务器端，基于**非阻塞式**`IO`读写和**多线程**工作任务处理
 *  TThreadedSelectorServer：**多线程选择器**服务器端，对`THsHaServer`在**异步**`IO`模型上进行增强

## Thrift入门示例 ##

### (一) 编写Thrift IDL文件 ###

a). 下载`0.10.0`的`Thrift IDL`编译器，下载地址：[http://thrift.apache.org/docs/install。][http_thrift.apache.org_docs_install] 通过**编译生成器**生成`.java`接口的类文件。

![Thrift_code_generator_compiler.png][]

b). 下载`Windows`安装环境的`.exe`文件，将`thrift.exe`的路径加入环境变量中。在`Idea`上安装`Thrift`编辑插件。

![Thrift_idea_plugin.png][]

c). 编写`hello.thrift`的`IDL`文件：

service HelloWorldService { string say(1: string username) }

d). 使用代码生成工具生成代码，执行以下命令：

thrift -gen java hello.thrift

e). 由于未指定代码生成的目标目录，生成的类文件默认存放在`gen-java`目录下。这里生成一个`HelloWorldService.java`类文件，文件大小超过数千行，下面截取一部分**核心代码**。

public class HelloWorldService { public interface Iface { public String say(String username) throws org.apache.thrift.TException; } public interface AsyncIface { public void say(String username, org.apache.thrift.async.AsyncMethodCallback<String> resultHandler) throws org.apache.thrift.TException; } public static class Client extends org.apache.thrift.TServiceClient implements Iface { public static class Factory implements org.apache.thrift.TServiceClientFactory<Client> { public Factory() { } public Client getClient(org.apache.thrift.protocol.TProtocol prot) { return new Client(prot); } public Client getClient(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) { return new Client(iprot, oprot); } } public Client(org.apache.thrift.protocol.TProtocol prot) { super(prot, prot); } public Client(org.apache.thrift.protocol.TProtocol iprot, org.apache.thrift.protocol.TProtocol oprot) { super(iprot, oprot); } public String say(String username) throws org.apache.thrift.TException { send_say(username); return recv_say(); } // 省略..... } public static class AsyncClient extends org.apache.thrift.async.TAsyncClient implements AsyncIface { public static class Factory implements org.apache.thrift.async.TAsyncClientFactory<AsyncClient> { private org.apache.thrift.async.TAsyncClientManager clientManager; private org.apache.thrift.protocol.TProtocolFactory protocolFactory; public Factory(org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.protocol.TProtocolFactory protocolFactory) { this.clientManager = clientManager; this.protocolFactory = protocolFactory; } public AsyncClient getAsyncClient(org.apache.thrift.transport.TNonblockingTransport transport) { return new AsyncClient(protocolFactory, clientManager, transport); } } public AsyncClient(org.apache.thrift.protocol.TProtocolFactory protocolFactory, org.apache.thrift.async.TAsyncClientManager clientManager, org.apache.thrift.transport.TNonblockingTransport transport) { super(protocolFactory, clientManager, transport); } public void say(String username, org.apache.thrift.async.AsyncMethodCallback<String> resultHandler) throws org.apache.thrift.TException { checkReady(); say_call method_call = new say_call(username, resultHandler, this, ___protocolFactory, ___transport); this.___currentMethod = method_call; ___manager.call(method_call); } // 省略..... } // 省略..... }

对于开发人员而言，使用原生的`Thrift`框架，仅需要关注以下四个核心**内部接口/类**：`Iface`, `AsyncIface`, `Client`和`AsyncClient`。

*  **Iface**：**服务端**通过实现`HelloWorldService.Iface`接口，向**客户端**的提供具体的**同步**业务逻辑。
 *  **AsyncIface**：**服务端**通过实现`HelloWorldService.Iface`接口，向**客户端**的提供具体的**异步**业务逻辑。
 *  **Client**：**客户端**通过`HelloWorldService.Client`的实例对象，以**同步**的方式**访问服务端**提供的服务方法。
 *  **AsyncClient**：**客户端**通过`HelloWorldService.AsyncClient`的实例对象，以**异步**的方式**访问服务端**提供的服务方法。

### (二) 新建Maven工程 ###

a). 新建`maven`工程，引入`thrift`的依赖，这里使用的是版本`0.10.0`。

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

b). 将生成类的`HelloWorldService.java`源文件拷贝进项目源文件目录中，并实现`HelloWorldService.Iface`的定义的`say()`方法。

HelloWorldServiceImpl.java

public class HelloWorldServiceImpl implements HelloWorldService.Iface { @Override public String say(String username) throws TException { return "Hello " + username; } }

c). 服务器端程序编写：

SimpleServer.java

public class SimpleServer { public static void main(String[] args) throws Exception { ServerSocket serverSocket = new ServerSocket(ServerConfig.SERVER_PORT); TServerSocket serverTransport = new TServerSocket(serverSocket); HelloWorldService.Processor processor = new HelloWorldService.Processor<HelloWorldService.Iface>(new HelloWorldServiceImpl()); TBinaryProtocol.Factory protocolFactory = new TBinaryProtocol.Factory(); TSimpleServer.Args tArgs = new TSimpleServer.Args(serverTransport); tArgs.processor(processor); tArgs.protocolFactory(protocolFactory); // 简单的单线程服务模型 一般用于测试 TServer tServer = new TSimpleServer(tArgs); System.out.println("Running Simple Server"); tServer.serve(); } }

d). 客户端程序编写：

SimpleClient.java

public class SimpleClient { public static void main(String[] args) { TTransport transport = null; try { transport = new TSocket(ServerConfig.SERVER_IP, ServerConfig.SERVER_PORT, ServerConfig.TIMEOUT); TProtocol protocol = new TBinaryProtocol(transport); HelloWorldService.Client client = new HelloWorldService.Client(protocol); transport.open(); String result = client.say("Leo"); System.out.println("Result =: " + result); } catch (TException e) { e.printStackTrace(); } finally { if (null != transport) { transport.close(); } } } }

e). 运行服务端程序，**服务端**在**指定端口**监听**客户端**的**连接请求**，控制台输出启动日志：

![Thrift_Simple_Server_Running.png][]

f). 运行客户端程序，**客户端**通过网络请求`HelloWorldService`的`say()`方法的**具体实现**，控制台输出返回结果：

![Thrift_Simple_Client_Running.png][]

这里使用的一个基于**单线程同步**的**简单服务模型**，一般仅用于入门学习和测试！

# 总结 #

本文对`Thrift`的概念做了相关介绍，体验了一番`thrift`程序如何编写！

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

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

![image][]

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

[Apache_thrift_architecture.png]: http://ols3fdyll.bkt.clouddn.com/Apache_thrift_architecture.png
[http_thrift.apache.org]: http://thrift.apache.org/
[Service_use_thrift.png]: http://ols3fdyll.bkt.clouddn.com/Service_use_thrift.png
[http_thrift.apache.org_docs_install]: http://thrift.apache.org/docs/install%E3%80%82
[Thrift_code_generator_compiler.png]: http://ols3fdyll.bkt.clouddn.com/Thrift_code_generator_compiler.png
[Thrift_idea_plugin.png]: http://ols3fdyll.bkt.clouddn.com/Thrift_idea_plugin.png
[Thrift_Simple_Server_Running.png]: http://ols3fdyll.bkt.clouddn.com/Thrift_Simple_Server_Running.png
[Thrift_Simple_Client_Running.png]: http://ols3fdyll.bkt.clouddn.com/Thrift_Simple_Client_Running.png
[image]: /images/20220511/baac7ae4364c469f9737d56050698eec.png