thrift框架简介

最新推荐文章于 2024-03-05 10:34:36 发布

zdxiq000

最新推荐文章于 2024-03-05 10:34:36 发布

阅读量2.6k

点赞数

分类专栏： thrift 文章标签： thrift

thrift 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1 Thrift简介

Thrift是一个跨语言的服务部署框架，最初由Facebook于2007年开发，2008年进入Apache开源项目。Thrift通过一个中间语言(IDL，接口定义语言)来定义RPC的接口和数据类型，然后通过一个编译器生成不同语言的代码（目前支持C++，Java， Python， PHP， Ruby， Erlang， Perl， Haskell， C#， Cocoa， Smalltalk和OCaml），并由生成的代码负责RPC协议层和传输层的实现。
Thrift实际上是实现了C/S模式，通过代码生成工具将接口定义文件生成服务器端和客户端代码（可以为不同语言），从而实现服务端和客户端跨语言的支持。用户在Thirft描述文件中声明自己的服务，这些服务经过编译后会生成相应语言的代码文件，然后用户实现服务（客户端调用服务，服务器端提服务）便可以了。其中protocol（协议层，定义数据传输格式，可以为二进制或者XML等）和transport（传输层，定义数据传输方式，可以为TCP/IP传输，内存共享或者文件共享等）被用作运行时库。

支持的传输格式
TBinaryProtocol – 二进制格式.
TCompactProtocol – 压缩格式
TJSONProtocol – JSON格式
TSimpleJSONProtocol –提供JSON只写协议，生成的文件很容易通过脚本语言解析。
TDebugProtocol – 使用易懂的可读的文本格式，以便于debug
支持的数据传输方式
TSocket -阻塞式socker
TFramedTransport – 以frame为单位进行传输，非阻塞式服务中使用。
TFileTransport – 以文件形式进行传输。
TMemoryTransport – 将内存用于I/O. java实现时内部实际使用了简单的ByteArrayOutput-Stream。
TZlibTransport – 使用zlib进行压缩，与其他传输方式联合使用。当前无java实现。
支持的服务模型
TSimpleServer – 简单的单线程服务模型，常用于测试
TThreadPoolServer – 多线程服务模型，使用标准的阻塞式IO。
TNonblockingServer – 多线程服务模型，使用非阻塞式IO（需使用TFramedTransport数据传输方式）

2 Thrift安装

下载

下载地址：目前最新版本v0.9.2
http://www.apache.org/dyn/closer.cgi?path=/thrift/0.9.2/thrift-0.9.2.tar.gz

安装，配置Thrift

官网教程：http://thrift.apache.org/docs/BuildingFromSource
总结下来，第1步先解压thrift-0.9.2.tar.gz，解压命令：

[user@host usr]$ tar -xvf thrift-0.9.2.tar.gz

第2步，输入以下命令：

[user@host usr]$ cd thrift-0.9.2
[user@host usr]$ ./configure  
[user@host usr]$ make #sudo make install

关于配置的问题可以查看命令：

[user@host usr]$ ./configure --help

可以关闭你不熟悉的语言，因为thrift支持的语言非常多，可以关闭一些用不到的，如python，gt4等，关闭命令为：

[user@host usr]$ ./configure --without-qt4

在install的过程中如果报一些test方面的error可以忽略，其他一些错误参见thrift安装过程中遇到的错误，欢迎补充。上面的步骤走完以后，可以在任意一个目录下输入如下命令进行测试：

[user@host usr]$ thrift -version
Thrift version 0.9.2

3 Thrift使用指南

3.1 语法参考
3.1.1 常用类型
Thrift类型系统包括预定义基本类型，用户自定义结构体，容器类型，异常和服务定义。参考官方文档。
基本类型
bool：布尔类型(true or value)，占一个字节
byte：有符号字节
i16：16位有符号整型
i32：32位有符号整型
i64：64位有符号整型
double：64位浮点数
string：未知编码或者二进制的字符串
容器类型
list容器：一个元素可重复的有序列表。会被转换成C++中的vector，Java中的ArrayList，脚本语言中的数组等。
set容器：一个元素不可重复的无序集合。会转换成C++中的set，Java中的HashSet、Python中的Set等。（熟悉PHP的同学可能会问“PHP并不支持set类型，怎么办”，在PHP语言中，thrift会将set容器转换成List。）
map容器：一个含有多个key：value键值对的结构。会被转换成C++中的map，Java中的HashMap，PHP中的关联数组，Python/Ruby中的dictionary等。
注：对于上述三种容器，其元素的类型原则上可以是任何一种thrift类型。但是值得注意的是，map的key类型需要是基础类型，因为很多开发语言并不支持map的key类型为复杂数据类型。
结构体和异常
Thrift结构体在概念上同C语言结构体类型—-一种将相关属性聚集（封装）在一起的方式。在面向对象语言中，thrift结构体被转换成类。
异常在语法和功能上类似于结构体，只不过异常使用关键字exception而不是struct关键字声明。但它在语义上不同于结构体—当定义一个RPC服务时，开发者可能需要声明一个远程方法抛出一个异常。
结构体定义的例子：

struct UserGradeInfo { 
1： required string UserName = "Anonymous";
2： required i16 UserGrade = 0;
}

可以看到，结构体中每一个域都有一个正整数标识符，这个标识符并不要求连续，但一旦定义，不建议再进行修改。另外，每个域前都会有required或optional的限定，前者表示是必填域，后者则表示是可选域。域是可以有默认值的，比如上例中的“Anonymous”和0。如果一个域设置了required，但是在实际构造结构体时又没有给这个域赋值，那么thrift会认为这是一个异常。如果一个域设置为optional且在构造结构体时没有给这个域赋值，那么在使用这个结构体时，就会忽略掉这个optional的域。
服务
服务的定义方法在语法上等同于面向对象语言中定义接口。Thrift编译器会产生实现这些接口的client和server桩。

//“Twitter”与“{”之间需要有空格！！！
service Twitter {
// 方法定义方式类似于C语言中的方式，它有一个返回值，一系列参数和可选的异常
// 列表. 注意，参数列表和异常列表定义方式与结构体中域定义方式一致.
void ping()，                                    // a
bool postTweet(1：Tweet tweet);                  // b
TweetSearchResult searchTweets(1：string query); // c
// ”oneway”标识符表示client发出请求后不必等待回复（非阻塞）直接进行下面的操作，
// ”oneway”方法的返回值必须是void
oneway void zip()                               // d
}

说明：
a．函数定义可以使用逗号或者分号标识结束
b．参数可以是基本类型或者结构体，参数是只读的（const），不可以作为返回值！！！
c．返回值可以是基本类型或者结构体
d．返回值可以是void
注意，函数中参数列表的定义方式与struct完全一样
Service支持继承，一个service可使用extends关键字继承另一个service
类型定义
Thrift支持C/C++风格的typedef：

typedef i32 MyInteger   \\a
typedef Tweet ReTweet  \\b

说明：
a. 末尾没有逗号
b. struct可以使用typedef
3.1.2 枚举类型
可以像C/C++那样定义枚举类型，如：

enum TweetType {
 TWEET，       //a
 RETWEET = 2， //b
 DM = 0xa，  //c
 REPLY
 }        //d
 struct Tweet {
 1： required i32 userId;
 2： required string userName;
 3： required string text;
 4： optional Location loc;
 5： optional TweetType tweetType = TweetType.TWEET // e
 16： optional string language = "english"
 }

说明：
a. 编译器默认从0开始赋值
b. 可以赋予某个常量某个整数
c. 允许常量是十六进制整数
d. 末尾没有逗号
e. 给常量赋缺省值时，使用常量的全称
f. 枚举常量必须是32位的正整数
3.1.3 注释
Thrfit支持shell注释风格，C/C++语言中单行或者多行注释风格
3.1.4 命名空间

namespace cpp com.example.project  // a
namespace java com.example.project // b

说明：
a．转化成namespace com { namespace example { namespace project {
b．转换成package com.example.project
3.1.5 文件包含
Thrift允许thrift文件包含，用户需要使用thrift文件名作为前缀访问被包含的对象，如：

include "tweet.thrift"           // a
...
struct TweetSearchResult {
1： list<tweet.Tweet> tweets; // b
}

说明：
a． thrift文件名要用双引号包含，末尾没有逗号或者分号
b．注意tweet前缀
3.1.6 常量
Thrift允许用户定义常量，复杂的类型和结构体可使用JSON形式表示。

const i32 INT_CONST = 1234;    // a
const map<string，string> MAP_CONST = {"hello"： "world"， "goodnight"： "moon"}

说明：
a．分号是可选的，可有可无；支持十六进制赋值。
3.2 产生代码
本节介绍thrift产生各种目标语言代码的方式。本节从几个基本概念开始，逐步引导开发者了解产生的代码是怎么样组织的，进而帮助开发者更快地明白thrift的使用方法。Thrift的网络栈如下所示：

3.2.1 Transport
Transport层提供了一个简单的网络读写抽象层。这使得thrift底层的transport从系统其它部分（如：序列化/反序列化）解耦。以下是一些Transport接口提供的方法：
open
close
read
write
flush
除了以上几个接口，Thrift使用ServerTransport接口接受或者创建原始transport对象。正如名字暗示的那样，ServerTransport用在server端，为到来的连接创建Transport对象。
open
listen
accept
close
3.2.2 Protocol
Protocol抽象层定义了一种将内存中数据结构映射成可传输格式的机制。换句话说，Protocol定义了datatype怎样使用底层的Transport对自己进行编解码。因此，Protocol的实现要给出编码机制并负责对数据进行序列化。
Protocol接口的定义如下：
writeMessageBegin(name， type， seq)
writeMessageEnd()
writeStructBegin(name)
writeStructEnd()
writeFieldBegin(name， type， id)
writeFieldEnd()
writeFieldStop()
writeMapBegin(ktype， vtype， size)
writeMapEnd()
writeListBegin(etype， size)
writeListEnd()
writeSetBegin(etype， size)
writeSetEnd()
writeBool(bool)
writeByte(byte)
writeI16(i16)
writeI32(i32)
writeI64(i64)
writeDouble(double)
writeString(string)
name， type， seq = readMessageBegin()
readMessageEnd()
name = readStructBegin()
readStructEnd()
name， type， id = readFieldBegin()
readFieldEnd()
k， v， size = readMapBegin()
readMapEnd()
etype， size = readListBegin()
readListEnd()
etype， size = readSetBegin()
readSetEnd()
bool = readBool()
byte = readByte()
i16 = readI16()
i32 = readI32()
i64 = readI64()
double = readDouble()

string = readString()
下面是一些对大部分thrift支持的语言均可用的protocol：
(1) binary：简单的二进制编码
(2) Compact：具体见THRIFT-11
(3) Json
3.2.3 Processor
Processor封装了从输入数据流中读数据和向数据数据流中写数据的操作。读写数据流用Protocol对象表示。Processor的结构体非常简单：
interface TProcessor {
bool process(TProtocol in， TProtocol out) throws TException
}
与服务相关的processor实现由编译器产生。Processor主要工作流程如下：从连接中读取数据（使用输入protocol），将处理授权给handler（由用户实现），最后将结果写到连接上（使用输出protocol）。
3.2.4 Server
Server将以上所有特性集成在一起：
（1）创建一个transport对象
（2）为transport对象创建输入输出protocol
（3）基于输入输出protocol创建processor
（4）等待连接请求并将之交给processor处理
3.3 代码示例
【编写.thrift接口文件】

/***
* .thrift文件可以引用其他.thrift文件，这样就可以方便地把一些公共结构和服务囊括进来。
* 在引用其他.thrift文件时，既可以直接引用当前文件夹下的文件，也可以引用其他路径下的
* 文件，但后者需要在thrift编译工具编译时加上-I选项来设定路径。
*
* 如果希望访问被包含的.thrift文件中的内容，则需要使用.thrift文件的文件名作为前缀，
* 比如shared.SharedObject。我们在本例中引用了文件shared.thrift。
*/
include "shared.thrift"

/**
* Thrift支持对.thrift文件中的类型设定namespace，这样可以有效避免名字冲突。
* 这种机制在C++中也叫做namespace，而在Java中叫做Package。
* thrift支持针对不同的语言设置不同的namespace，比如下面的例子。
* thrift会在生成不同语言代码时，进行相应的设置。
*/
namespace cpp tutorial
namespace go tutorial
namespace java tutorial
namespace php tutorial
namespace perl tutorial

/**
* thrift还可以使用typedef来给类型起别名。
*/
typedef i32 MyInteger

/**
* Thrift也支持定义常量。
* 对于结构复杂的常量，支持使用JSON形式来表示。
*/
const i32 MY_NUM = 9853
const map<string，string> MY_MAP = {'hello'：'world'， 'goodnight'：'moon'}

/**
* 你还可以定义枚举类型， 其被指定为32位整型。域的值是可以自定义的，而且
* 当不提供域的值时，默认会从1开始编号并递增。
*/
enum Operation {
ADD = 1，
SUBTRACT = 2，
MULTIPLY = 3，
DIVIDE = 4
}

/**
* 结构体则是一个复杂的数据类型。它由多个域组成，每个域会对应一个整数标识符，
* 每一行的格式为：一个冒号，一个类型，一个域名称和一个（非必填的）默认值。
*
* 每个域都可以设置为optional或required来表示是否为必填域，以便thrift决定是否
* 在数据传输时要包含这个域。不指定时，默认为required。
*/
struct Work {
1： i32 num1 = 0，
2： i32 num2，
3： Operation op，
4： optional string comment，
}

/**
* 在语法上，异常的定义方式和结构体是完全一样的。在发生问题时，可以抛出异常。
*/
exception InvalidOperation {
1： i32 what，
2： string why
}

/**
* 啊哈，我们现在到了最Cool的环节，即定义服务。
* （一个服务可以使用extends来继承另一个服务。）
*/
service Calculator extends shared.SharedService {

/**
* 服务中方法的定义非常类似于C语言的语法。它会包括一个返回值，
* 一个参数列表以及一个可以抛出的异常列表（可选）
* 可以提前告诉大家的是，定义参数列表的方法、定义异常列表的方法，
* 和定义结构体的方法都是相似的，可以从下面的例子中看出。
* 除了最后一个方法，其他的方法最后都要有一个逗号，大家可不要忽略这个细节。
*/

void ping()，

i32 add(1：i32 num1， 2：i32 num2)，

/**
* 在异常列表前，需要加throws关键字。
*/
i32 calculate(1：i32 logid， 2：Work w) throws (1：InvalidOperation ouch)，

/**
* 如下的这个方法有一个oneway修饰符，还记得他的作用么
* 这表示这个方法在调用后会立即返回，不会等待远端的回复。
* 要注意的是，oneway只能修饰void返回类型。
* oneway在英语里就是“单向”的意思，还是很形象滴。
*/
oneway void zip()

}
/**
* 在你使用thrift编译工具编译此文件后，
* 会在当前目录产生一个“gen-<你选择的开发语言>”
* 文件夹，比如你选择的是C++语言，则会产生gen-cpp文件夹，
* 里面放着的便是thrift帮你生成好的代码。
*/

【使用thrift编译工具】
在我们编写好thrift接口描述文件之后，thrift编译工具就要派上用场了，它的作用就是根据thrift接口描述文件来生成相应开发语言的RPC代码，以便用户可以在自己的程序中调用。
thrift编译工具的名称就是thrift，其最常见的使用方式是这样的：

thrift --gen ${开发语言} ${thrift接口描述文件}

运行了上述命令之后，就会在当前文件夹下生成一个以“gen-${开发语言}”命名的文件夹，里面便是自动生成的代码。
【thrift会自动生成哪些代码呢】
在编译之后，thrift会生成这些文件：（我们以mytime.thrift为例）

$ cd gen-cpp

$ ls -1 mytime_types.*
mytime_types.cpp
mytime_types.h

# 和数据类型有关的内容，会命名为
# ${thrift_file_name}_types.h/${thrift_file_name}_types.cpp。
# 比如你使用typedef定义了类型别名，
# 或者你定义了一个struct类型，都会在这两个文件中记录。

# 对于struct类型，有必要多说一下，thrift会针对每一个struct类型
# 生成一个对应的类，类中会包括一个构造函数、一个析构函数、
# 域变量定义、用于设置域值的__set_XXX()方法、
# 重载比较符（==，!=，<）、设定读写此结构体的方法read/write，
# 以及一个用于表示域是否设置了值的_${struct name}__isset结构体。

# 另外，还会有一个独立定义的swap方法用来进行两个结构体的值交换。

$ ls -1 mytime_constants.*
mytime_constants.cpp
mytime_constants.h

# 和常量有关的内容，会命名为
# ${thrift_file_name}_constants.h/${thrift_file_name}_constants.cpp。
# 在.h头文件中会有一个${thrift_file_name}Constants类，
# 其中会包括一个显式的构造函数，以及常量的域。
# 而在cpp文件中则会在相应的构造函数中对这个常量进行赋值。

$ ls -1 myservice*
myservice.cpp
myservice.h
myservice_server.skeleton.cpp

# 针对每一个service会产生一套对应的文件，命名为
# ${service_name}.cpp/${service_name}.h/${service_name}_server.skeleton.cpp，
# 在${service_name}.h中会看到有若干个类，他们都是以服务名作为前缀的，
# 其中包括${service_name}If、${service_name}IfFactory、
# ${service_name}IfSingletonFactory、${service_name}Null、
# ${service_name}Client、${service_name}Processor、
# ${service_name}ProcessorFactory、${service_name}Multiface。

# 另外，thrift还会针对服务中的每一个具体的方法分别产生四个对应的类，即
# ${service_name}_${method}_args、${service_name}_${method}_pargs、
# ${service_name}_${method}_result、${service_name}_${method}_presult。

# 另外，${service_name}_server.skeleton.cpp是一个server的模板例子。

【一起用thrift来做个项目！】
我们的例子很简单，就是一个“时间问答”机器人，英文叫做WhatTime，客户会向服务器端询问现在几点啦，服务器端会把现在的时间回答给客户端。就像这样：
客户端：请问，现在几点啦？
服务器端：现在是上午10点01分。
我们会在服务器端使用C++来实现，而在客户端会使用C++语言来实现。thrift接口描述文件WhatTime.thrift：

namespace cpp roctime

service TimeService {
i32 TellMeTime()
}

需要经过thrift编译工具编译：

$ thrift --gen cpp WhatTime.thrift

$ ls -1F
gen-cpp/
WhatTime.thrift

$ cd gen-cpp/
$ ls -1
TimeService.cpp
TimeService.h
TimeService_server.skeleton.cpp
WhatTime_constants.cpp
WhatTime_constants.h
WhatTime_types.cpp
WhatTime_types.h

然后，我们把server的样例文件重命名一下：

$ mv TimeService_server.skeleton.cpp server.cpp

我们将server.cpp中的TellMeTime方法做一些修改，加入报告时间的逻辑：

int32_t TellMeTime() {
// Your implementation goes here
time_t now_time = time(NULL);
return now_time;
}

好了，server.cpp完工，我们对server.cpp进行编译链接：

[user@host whatTime]$ g++ -I /home/roc/program/thrift/include -c TimeService.cpp
[user@host whatTime]$ g++ -I /home/roc/program/thrift/include -c WhatTime_constants.cpp
[user@host whatTime]$ g++ -I /home/roc/program/thrift/include -c WhatTime_types.cpp
[user@host whatTime]$ g++ -I /home/roc/program/thrift/include -c server.cpp
[user@host whatTime]$ g++ -L /home/roc/program/thrift/lib/ TimeService.o WhatTime_constants.o WhatTime_types.o server.o -o server -lthrift

如果提示找不到thrift动态链接库，那就需要把thrift的lib路径（如/home/roc/program/thrift/lib）加入到ld.so.conf中，然后执行ldconfig命令在重新将动态链接库装载到cache中。
然后就可以直接运行./server了，可以看到9090端口打开，已经开始服务了。
下面，我们继续编写客户端的代码。thrift并没有给出客户端的代码样例，所以需要自己来开发。

#include "TimeService.h"
#include <thrift/transport/TSocket.h>
#include <thrift/transport/TBufferTransports.h>
#include <thrift/protocol/TBinaryProtocol.h>

#include <iostream>
using namespace std;

using namespace apache：：thrift;
using namespace apache：：thrift：：protocol;
using namespace apache：：thrift：：transport;

using namespace roctime;

int main(int argc， char *argv[]) {
boost：：shared_ptr<TSocket> socket(new TSocket("localhost"， 9090));
boost：：shared_ptr<TTransport> transport(new TBufferedTransport(socket));
boost：：shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));

time_t mytime = 0;

TimeServiceClient client(protocol);
transport->open();
mytime = client.TellMeTime();

cout << "Now is " << ctime(&mytime) << endl;
transport->close();

return 0;
}

开发完成后，我们对client进行编译链接：

[user@host whatTime]$ g++ -I /home/roc/program/thrift/include -c TimeService.cpp
[user@host whatTime]$ g++ -I /home/roc/program/thrift/include -c WhatTime_constants.cpp
[user@host whatTime]$ g++ -I /home/roc/program/thrift/include -c WhatTime_types.cpp
[user@host whatTime]$ g++ -I /home/roc/program/thrift/include -c client.cpp
[user@host whatTime]$ g++ -L /home/roc/program/thrift/lib/ TimeService.o WhatTime_constants.o WhatTime_types.o client.o -o client -lthrift

好了，服务器端程序server和客户端程序client都生成好了，可以试着运行这个例子：
在一个终端运行服务器端程序：

[user@host whatTime]$ ./server

在另一个终端打开客户端程序：

[user@host whatTime]$ ./client
Now is Fri Nov 1 12：14：06 2013

顺利的话，你应该可以看到运行server的终端窗口会输出“Now is Fri Nov 1 12：14：06 2013”。

4 参考文档

Thirft框架介绍
 Thrift使用指南
 使用Thrift RPC编写程序
 Linux大棚版Thrift入门教程

zdxiq000

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录