Thrift 介绍

1、前言

Thrift是一个跨语言的服务部署框架，最初由Facebook于2007年开发，2008年进入Apache开源项目。Thrift通过一个中间语言(IDL, 接口定义语言)来定义RPC的接口和数据类型，然后通过一个编译器生成不同语言的代码（目前支持C++,Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, Smalltalk和OCaml）,并由生成的代码负责RPC协议层和传输层的实现。

本文组织结构如下：1）引言 2）架构3）支持的数据传输格式、数据传输方式和服务模型 4）Thrift安装 5）利用Thift部署服务

关于thrift使用方法的介绍，参考我这篇文章：Thrift使用指南 。

关于thrift client和server的编写方法，可参考我这篇文章：使用Thrift RPC编写程序 。

2、架构

Thrift实际上是实现了C/S模式，通过代码生成工具将接口定义文件生成服务器端和客户端代码（可以为不同语言），从而实现服务端和客户端跨语言的支持。用户在Thirft描述文件中声明自己的服务，这些服务经过编译后会生成相应语言的代码文件，然后用户实现服务（客户端调用服务，服务器端提服务）便可以了。其中protocol（协议层, 定义数据传输格式，可以为二进制或者XML等）和transport（传输层，定义数据传输方式，可以为TCP/IP传输，内存共享或者文件共享等）被用作运行时库。上图的详细解释参考引用【1】。

3、 支持的数据传输格式、数据传输方式和服务模型

（1）支持的传输格式

TBinaryProtocol – 二进制格式.

TCompactProtocol – 压缩格式

TJSONProtocol – JSON格式

TSimpleJSONProtocol –提供JSON只写协议, 生成的文件很容易通过脚本语言解析。

TDebugProtocol – 使用易懂的可读的文本格式，以便于debug

（2） 支持的数据传输方式

TSocket -阻塞式socker

TFramedTransport – 以frame为单位进行传输，非阻塞式服务中使用。

TFileTransport – 以文件形式进行传输。

TMemoryTransport – 将内存用于I/O. java实现时内部实际使用了简单的ByteArrayOutputStream。

TZlibTransport – 使用zlib进行压缩， 与其他传输方式联合使用。当前无java实现。

（3）支持的服务模型

TSimpleServer – 简单的单线程服务模型，常用于测试

TThreadPoolServer – 多线程服务模型，使用标准的阻塞式IO。

TNonblockingServer – 多线程服务模型，使用非阻塞式IO（需使用TFramedTransport数据传输方式）

4、 Thrift安装

下载：http://incubator.apache.org/thrift/download/

安装要求：

Unix/linux 系统，windows+cygwin

C++语言：g++、boost

java 语言：JDK、Apache Ant

其他语言：Python、PHP、Perl, etc…

编译安装：./configure –》make –》make install

1、 利用Thrift部署服务

主要流程：编写服务说明，保存到.thrift文件–》根据需要， 编译.thrift文件，生成相应的语言源代码–》根据实际需要， 编写client端和server端代码。

（1）.thrift文件编写

一般将服务放到一个.thrift文件中，服务的编写语法与C语言语法基本一致，在.thrift文件中有主要有以下几个内容：变量声明、数据声明（struct）和服务接口声明（service, 可以继承其他接口）。

下面分析Thrift的tutorial中带的例子tutorial.thrift

包含头文件：

59行：include “shared.thrift”
–

指定目标语言：

65行：namespace cpp tutorial
–

定义变量：

80行：const i32 INT32CONSTANT = 9853
–

定义结构体：

103行：struct Work {

1: i32 num1 = 0,

2: i32 num2,

3: Operation op,

4: optional string comment,

}
—

定义服务：

service Calculator extends shared.SharedService {

void ping(),

i32 add(1:i32 num1, 2:i32 num2),

i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),

oneway void zip()

}

     要生成C++代码：./thrift --gen cpp tutorial.thrift，结果代码存放在gen-cpp目录下

     要生成java代码：./thrift --gen java tutorial.thrift，结果代码存放在gen-java目录下
      ….. 

（2） client端和server端代码编写

client端和sever端代码要调用编译.thrift生成的中间文件。

下面分析cpp文件下面的CppClient.cpp和CppServer.cpp代码

在client端，用户自定义CalculatorClient类型的对象（用户在.thrift文件中声明的服务名称是Calculator， 则生成的中间代码中的主类为CalculatorClient）， 该对象中封装了各种服务，可以直接调用（如client.ping()）, 然后thrift会通过封装的rpc调用server端同名的函数。

在server端，需要实现在.thrift文件中声明的服务中的所有功能，以便处理client发过来的请求。

 

 

 

 

 

 

 

 

 

一、ubuntu下thrift的安装

1.下载源代码
http://thrift.apache.org/download/
下载最新版本thrift-0.8.0.tar.gz

2.安装boost库
sudo apt-get install libboost-dev libboost-dbg libboost-doc bcp libboost-*
 
3.安装其他相关工具包
sudo apt-get install libboost-dev libboost-test-dev libboost-program-options-dev libevent-dev automake libtool flex bison pkg-config g++ libssl-dev ant
如果需要支持java，需要安装jdk，配置java环境变量。
 
4.解压文件，进入目录thrift-0.8.0安装
./configure --with-cpp --with-boost --without-python --without-csharp --with-java --without-erlang --without-perl --with-php --without-php_extension --without-ruby --without-haskell  --without-go

make
sudo make install
要支持java，需要编译生成jar包，到lib/java目录下，执行ant命令。将在lib/java/build目录下生成libthrift-0.8.0.jar和libthrift-0.8.0-javadoc.jar。编译过程中，可能出错，需要检查lib/java/build/tools/maven-ant-tasks-2.1.3.jar是否正确下载。
 
5.测试
直接输入thrift命令，看是否有用法提示
 
二、thrift自带的测试样例
进入tutorial文件夹，shared.thrift和tutorial.thrift是接口定义文件。
thrift -r --gen java tutorial.thrift
thirft -r --gen cpp tutorial.thrift
执行这两条命令可以生成gen-java和gen-cpp两个文件夹，这些是thrift编译器自动生成的代码。
 
然后到java目录下，执行ant命令，编译成功后，在两个不同的窗口下执行以下命令：
./JavaServer
./JavaClient simple
 
进入cpp目录下，执行make命令，如果编译出错，第一个错误是
/usr/local/include/thrift/protocol/TBinaryProtocol.tcc:147:35: error: there are no arguments to ‘htons’ that depend on a template parameter, so a declaration of ‘htons’ must be available
则修改Makefile，加上编译选项-DHAVE_NETINET_IN_H
server: CppServer.cpp
        g++ -DHAVE_NETINET_IN_H -o CppServer -I${THRIFT_DIR} -I${BOOST_DIR}  -I../gen-cpp -L${LIB_DIR} -lthrift CppServer.cpp ${GEN_SRC}
 
client: CppClient.cpp
        g++ -DHAVE_NETINET_IN_H -o CppClient -I${THRIFT_DIR} -I${BOOST_DIR}  -I../gen-cpp -L${LIB_DIR} -lthrift CppClient.cpp ${GEN_SRC}
编译通过生，将生成CppClient和CppServer两个可执行程序。同样，在两个不同的窗口执行以下命令：
./CppServer
./CppClient
而且java和c++的Client和Server都可以交叉运行。比如运行JavaServer和CppClient也能得到同样的结果。以此达到了多语言的相互调用。
 
三、Hello World
仿照tutorial，写一个简单的hello world。在tutorial平级目录下，建立目录hello，这里只是为了测试需要。
服务端用java，客户端用java和c++。
 
1. 编写tt.thrift
namespace java demo
namespace cpp demo
 
service Hello{
  string helloString(1:string para)
}
 
2. 编译生成代码
thrift -r --gen java tt.thrift
thrift -r --gen cpp tt.thrift
生成gen-java和gen-cpp两个文件夹
gen-cpp下有如下文件
Hello.cpp  Hello.h  Hello_server.skeleton.cpp  tt_constants.cpp  tt_constants.h  tt_types.cpp  tt_types.h
其中Hello.h,Hello.cpp中定义了远程调用的接口，实现了底层通信。可以在Hello.h中找到客户端远程调用需要用到的类HelloClient，调用方法：
void helloString(std::string& _return, const std::string& para);
这个跟thrift文件中申明的方法有点不一定，返回参数是通过引用传回来的。
Hello_server.skeleton.cpp将实现Hello.h的服务端接口，如果要用c++作为服务端，还需要将这个文件拷出去，重命名，实现类HelloHandler的方法helloString，远程调用方法的业务逻辑也就写在helloString中。可能还需要改main函数中的端口信息。
gen-java/demo下只有Hello.java一个文件，它定义了服务端和客户端的接口，实现了底层的通信。
 
3. 编写java服务端和客户端
仿照tutorial，在hello目录下建立java目录，将tutorial/java/下的一些文件和目录拷到hello/java下
build.xml JavaClient  JavaServer  src
删除src下所有文件，在src下编写代码。
 
1） HelloImpl.java 远程过程调用的业务逻辑
import demo.*;
import org.apache.thrift.TException;
 
class HelloImpl implements Hello.Iface {
 public HelloImpl() {}
 public String helloString(String para) throws org.apache.thrift.TException {
        //各种业务逻辑
         return "hello " + para;
 }
}
 
2) Server.java  服务端程序
import demo.*;
import java.io.IOException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TBinaryProtocol.Factory;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TThreadPoolServer.Args;
import org.apache.thrift.server.TThreadPoolServer;
import org.apache.thrift.transport.TServerSocket;
import org.apache.thrift.transport.TTransportException;
 
public class Server {
private void start() {
try {
    TServerSocket serverTransport = new TServerSocket(7911);
    Hello.Processor processor = new Hello.Processor(new HelloImpl());
    Factory protFactory = new TBinaryProtocol.Factory(true, true);
    Args args = new Args(serverTransport);
    args.processor(processor);
    args.protocolFactory(protFactory);
    TServer server = new TThreadPoolServer(args);
    //TServer server = new TThreadPoolServer(processor, serverTransport, protFactory);
    System.out.println("Starting server on port 7911 ...");
    server.serve();
 
   } catch (TTransportException e) {
    e.printStackTrace();
   } catch (Exception e) {
    e.printStackTrace();
}
}
 
public static void main(String args[]) {
    Server srv = new Server();
    srv.start();
}
}
 
3) Client.java 客户端程序
import demo.*;
import java.io.IOException;
import org.apache.thrift.*;
import org.apache.thrift.protocol.*;
import org.apache.thrift.transport.*;
 
public class Client {
      public static void main(String [] args) {
           try {
                    TTransport transport = new TSocket("localhost", 7911);
                    TProtocol protocol = new TBinaryProtocol(transport);
                    Hello.Client client = new Hello.Client(protocol);
                    transport.open();
                    System.out.println("Client calls hello");
                    System.out.println(client.helloString("world"));
                    transport.close();
               } catch (TException x) {
                    x.printStackTrace();
               }
        }
}
 
4) 修改 build.xml
<project name="hello" default="hello" basedir=".">
 
  <description>Thrift Hello</description>
 
  <property name="src" location="src" />
  <property name="gen" location="../gen-java" />
  <property name="build" location="build" />
 
  <path id="libs.classpath">
    <fileset dir="http://www.cnblogs.com/lib/java/build">
      <include name="*.jar" />
      <exclude name="-test.jar" />
    </fileset>
    <fileset dir="http://www.cnblogs.com/lib/java/build/lib">
      <include name="*.jar" />
    </fileset>
  </path>
  <path id="build.classpath">
    <path refid="libs.classpath" />
    <pathelement path="${gen}" />
  </path>
 
  <target name="init">
    <tstamp />
    <mkdir dir="${build}"/>
  </target>
 
  <target name="compile" depends="init">
    <javac srcdir="${gen}" destdir="${build}" classpathref="libs.classpath" />
    <javac srcdir="${src}" destdir="${build}" classpathref="build.classpath" />
  </target>
 
  <target name="hello" depends="compile">
    <jar jarfile="hello.jar" basedir="${build}"/>
  </target>
 
  <target name="clean">
    <delete dir="${build}" />
    <delete file="hello.jar" />
  </target>
 
</project>
 
5) 编译
ant
将生成build文件夹
Client.class  demo  hello  HelloImpl.class  hello.jar  Server.class
 
6) 修改执行脚本
JavaClient
java -cp http://www.cnblogs.com/lib/java/build/lib/*:http://www.cnblogs.com/lib/java/build/*:hello.jar Client
JavaServer
java -cp http://www.cnblogs.com/lib/java/build/lib/*:http://www.cnblogs.com/lib/java/build/*:hello.jar Server
 
4. 编写c++客户端
同样仿照tutorial，将tutorial/cpp中的Makefile和CppClient.cpp拷到hello/cpp下。
 
1) 将CppClient.cpp重命名为Client.cpp，并修改
#include <stdio.h>
#include <unistd.h>
#include <sys/time.h>
 
#include <protocol/TBinaryProtocol.h>
#include <transport/TSocket.h>
#include <transport/TTransportUtils.h>
 
#include "../gen-cpp/Hello.h"
#include <string>
 
using namespace std;
using namespace apache::thrift;
using namespace apache::thrift::protocol;
using namespace apache::thrift::transport;
 
using namespace demo;
 
using namespace boost;
 
int main(int argc, char** argv) {
  shared_ptr<TTransport> socket(new TSocket("localhost", 7911));
  shared_ptr<TTransport> transport(new TBufferedTransport(socket));
  shared_ptr<TProtocol> protocol(new TBinaryProtocol(transport));
  HelloClient client(protocol);
 
  try {
    transport->open();
 
    string ret;
    client.helloString(ret, "world");
    printf("%s\n", ret.c_str());
 
    transport->close();
  } catch (TException &tx) {
    printf("ERROR: %s\n", tx.what());
  }
 
}
 
2). 修改Makefile
BOOST_DIR = /usr/local/boost/include/boost-1_33_1/
THRIFT_DIR = /usr/local/include/thrift
LIB_DIR = /usr/local/lib
 
GEN_SRC = ../gen-cpp/tt_types.cpp ../gen-cpp/Hello.cpp
 
default: client
 
client: Client.cpp
        g++ -DHAVE_NETINET_IN_H -o client -I${THRIFT_DIR} -I${BOOST_DIR}  -I../gen-cpp -L${LIB_DIR} -lthrift Client.cpp ${GEN_SRC}
 
clean:
        $(RM) -r client
 
3). 编译
make
生成可执行文件client
 
5. 运行程序
运行服务端程序，java目录下：./JavaServer
运行客户端程序，cpp目录下：./client
这样c++程序通过 client.helloString(ret, "client") 可以调用服务端的java接口String helloString(String para)。
从而实现了远程多语言调用。
一个不会敲代码的程序员

 

 

 

 

 

 

 

 

 

 

 

 

 

 

一 前言
　　Thrift是facebook技术核心框架之一，不同开发语言开发的服务可以通过该框架实现通信。Thrift通过接口定义语言 (interface definition language，IDL) 来定义数据类型和服务，Thrift接口定义文件由Thrift代码编译器生成thrift目标语言的代码（目前支持C++,Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, Smalltalk和OCaml），并由生成的代码负责RPC协议层和传输层的实现。

　　简而言之，开发者只需准备一份thrift脚本，通过thrift code generator（像gcc那样输入一个命令）就能生成所要求的开发语言代码。不支持windows。

　　Thrift侧重点是构建跨语言的可伸缩的服务，特点就是支持的语言多，同时提供了完整的RPC service framework，可以很方便的直接构建服务，不需要做太多其他的工作。服务端可以根据需要编译成simple | thread-pool | threaded | nonblocking等方式；

　　本文档参考：Thrift types, Thrift IDL， Thrift:The Missing Guide.

二 语法参考

　2.1 类型

　　Thrift类型系统包括预定义基本类型，用户自定义结构体，容器类型，异常和服务定义。

　2.1.1 基本类型

bool: 布尔值 (true or false), one byte

byte: 有符号字节

i16: 16位有符号整型

i32: 32位有符号整型

i64: 64位有符号整型

double: 64位浮点型

string: Encoding agnostic text or binary string

Note that： Thrift不支持无符号整型，因为Thrift目标语言没有无符号整型，无法转换。

　2.1.2 容器（Containers）

　　Thrift容器与流行编程语言的容器类型相对应，采用Java泛型风格。它有3种可用容器类型：

list<t1>: 元素类型为t1的有序表，容许元素重复。（有序表ordered list不知道如何理解？排序的？c++的vector不排序）

set<t1>:元素类型为t1的无序表，不容许元素重复。

map<t1,t2>: 键类型为t1，值类型为t2的kv对，键不容许重复。

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

　2.1.3 结构体和异常（Structs and Exceptions）
　　Thrift结构体在概念上类似于（similar to）C语言结构体类型--将相关属性封装在一起的简便方式。Thrift结构体将会被转换成面向对象语言的类。

　　异常在语法和功能上类似于（equivalent to）结构体，差别是异常使用关键字exception而不是struct声明。但它在语义上不同于结构体：当定义一个RPC服务时，开发者可能需要声明一个远程方法抛出一个异常。

　　结构体和异常的声明将在下一节介绍。

　2.1.4 服务（Services）
　　服务的定义方法在语义(semantically)上等同于面向对象语言中的接口。Thrift编译器会产生执行这些接口的client和server stub。具体参见下一节。

　2.2 类型定义（Typedef)
　　Thrift支持C/C++类型定义。

 　　typedef i32 MyInteger // a　　typedef T ReT // b
　　说明：a.  末尾没有逗号。b.   struct也可以使用typedef。

　2.3 枚举（Enums）
　　很多语言都有枚举，意义都一样。比如，当定义一个消息类型时，它只能是预定义的值列表中的一个，可以用枚举实现。

enum TweetType {TWEET, // (1) 　　RETWEET = 2, // (2)DM = 0xa, // (3) 　　REPLY} // (4)struct Tweet { 1: required i32 userId; 2: required string userName; 3: required string text; 4: optional Location loc; 5: optional TweetType tweetType = TweetType.TWEET; // (5) 16: optional string language = "english" }

　　说明：

　　(1).  编译器默认从0开始赋值

　　(2).  可以赋予某个常量某个整数

　　(3).  允许常量是十六进制整数

　　(4).  末尾没有分号

　　(5).  给常量赋缺省值时，使用常量的全称

　　注意，不同于protocal buffer，thrift不支持枚举类嵌套，枚举常量必须是32位的正整数

　2.4 注释（Comment）
　　Thrift支持shell风格, C多行风格和Java/C++单行风格。

# This is a valid comment.  // C++/Java style single-line comments work just as well.
　2.5 名字空间（Namespace）
　　Thrift中的命名空间类似于C++中的namespace和java中的package，它们提供了一种组织（隔离）代码的简便方式。名字空间也可以用于解决类型定义中的名字冲突。

　　由于每种语言均有自己的命名空间定义方式（如python中有module）, thrift允许开发者针对特定语言定义namespace：　　

namespace cpp com.example.project // (1)namespace java com.example.project // (2)namespace php com.example.project 
　　(1)． 转化成namespace com { namespace example { namespace project {

　　(2)．  转换成package com.example.project

 

　2.6 Includes
　　便于管理、重用和提高模块性/组织性，我们常常分割Thrift定义在不同的文件中。包含文件搜索方式与c++一样。Thrift允许文件包含其它thrift文件，用户需要使用thrift文件名作为前缀访问被包含的对象，如：

include "tweet.thrift" // （1）...struct TweetSearchResult { 1: tweet.Tweet tweet; // （2）}
　　说明：

　　（1）．  thrift文件名要用双引号包含，末尾没有逗号或者分号

　　（2）．  注意tweet前缀

　2.7 常量（Constant)
　　Thrift允许定义跨语言使用的常量，复杂的类型和结构体可使用JSON形式表示。

const i32 INT_CONST = 1234; // （1）
　　说明：

　　（1） 分号可有可无。支持16进制。

　2.8 结构体定义（Defining Struct）
　　struct是Thrift IDL中的基本组成块，由域组成，每个域有唯一整数标识符，类型，名字和可选的缺省参数组成。如定义一个类似于Twitter服务：

struct Tweet { 1: required i32 userId; // (1) 2: required string userName; // (2) 3: required string text; 4: optional Location loc; // (3) 16: optional string language = "english" // (4)} struct Location { // (5) 1: required double latitude; 2: required double longitude;}

 (1) 每个域有一个唯一的正整数标识符；

 (2) 每个域可标识为required或optional；

 (3) 结构体可以包含其它结构体

 (4) 域可有默认值，与required或optional无关。

 (5) Thrift文件可以定义多个结构体，并在同一文件中引用，也可加入文件限定词在其它Thrift文件中引用。

　　如上所见，消息定义中的每个域都有一个唯一数字标签，这些数字标签在传输时用来确定域，一旦使用消息类型，标签不可改变。（随着项目的进展，可以要变更Thrift文件，最好不要改变原有的数字标签）

　　规范的struct定义中的每个域均会使用required或者optional关键字进行标识。如果required标识的域没有赋值，Thrift将给予提示；如果optional标识的域没有赋值，该域将不会被序列化传输；如果某个optional标识域有缺省值而用户没有重新赋值，则该域的值一直为缺省值；如果某个optional标识域有缺省值或者用户已经重新赋值，而不设置它的__isset为true，也不会被序列化传输。（不被序列化传输的后果是什么？为空为零？还是默认值，下次试试）

　　与services不同，结构体不支持继承。

2.9 服务定义（Defining Services）
　　在流行的序列化/反序列化框架（如protocal buffer）中，Thrift是少有的提供多语言间RPC服务的框架。这是Thrift的一大特色。

　　Thrift编译器会根据选择的目标语言为server产生服务接口代码，为client产生stubs。

service Twitter { // A method definition looks like C code. It has a return type, arguments, // and optionally a list of exceptions that it may throw. Note that argument // lists and exception list are specified using the exact same syntax as // field lists in structs. void ping(), // (1) bool postTweet(1:Tweet tweet); // (2)TweetSearchResult searchTweets(1:string query); // (3)  // The 'oneway' modifier indicates that the client only makes a request and // does not wait for any response at all. Oneway methods MUST be void.oneway void zip() // (4)}

　(1) 有点乱，接口支持以逗号和分号结束；
　(2) 参数可以是基本类型和结构体；（参数是cosnt的，转换为c++语言是const&）
　(3) 返回值同参数一样；
　(4) 返回值是void，注意oneway；
Note that:参数列表的定义与结构体一样。服务支持继承。