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

冷不防 2022-04-11 15:00 245阅读 0赞

# 前言 #

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

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

# 正文 #

## Thrift的技术栈 ##

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

![12738336-3f8359180b9d5545.png][]

image

`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`中有广泛使用，国内包括百度、美团小米、和饿了么等公司。

![12738336-448122f092e3f466.png][]

image

## 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`接口的类文件。

![12738336-242440abdba44577.png][]

image

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

![12738336-c7a8d68c457a4bce.png][]

image

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). 运行服务端程序，**服务端**在**指定端口**监听**客户端**的**连接请求**，控制台输出启动日志：

![12738336-e1c6d6fd56ca0af5.png][]

image

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

![12738336-8565b77982b38eda.png][]

image

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

# 总结 #

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

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

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

![10548396-035e78bdc34c7525][]

image

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

[12738336-3f8359180b9d5545.png]: /images/20220411/e851c4d569c74aa5b70c9ee64d3a1117.png
[http_thrift.apache.org]: http://thrift.apache.org/
[12738336-448122f092e3f466.png]: /images/20220411/4dd5ece37b4149ceb400640da6dbc5da.png
[http_thrift.apache.org_docs_install]: http://thrift.apache.org/docs/install
[12738336-242440abdba44577.png]: /images/20220411/e9a6a6654834458daa6b2615188f581f.png
[12738336-c7a8d68c457a4bce.png]: /images/20220411/1a26847be18b4f9c8e27be209e3d2cb0.png
[12738336-e1c6d6fd56ca0af5.png]: /images/20220411/4fdfd8a66767436c8d44f955f3aec771.png
[12738336-8565b77982b38eda.png]: /images/20220411/e640bad31b534194a1c3d8ef792b1815.png
[10548396-035e78bdc34c7525]: /images/20220411/6b51a65ffb1d4e26857e4b79b3ba4f10.png