Thrift入门

Thrift

编译命令

在thrift.exe下执行thrift -r -gen java 文件名.thrift

thrift.exe下载地址:https://thrift.apache.org/download

Thrift 脚本可定义的数据类型包括以下几种类型：

基本类型

1. bool：布尔值，true 或 false，对应 Java 的 boolean
2. byte：8 位有符号整数，对应 Java 的 byte
3. i16：16 位有符号整数，对应 Java 的 short
4. i32：32 位有符号整数，对应 Java 的 int
5. i64：64 位有符号整数，对应 Java 的 long
6. double：64 位浮点数，对应 Java 的 double
7. string：未知编码文本或二进制字符串，对应 Java 的 String

容器类型

1. list：对应 Java 的 ArrayList
2. set：对应 Java 的 HashSet
3. map：对应 Java 的 HashMap

异常类型

exception：对应 Java 的 Exception

结构体类型

struct：定义公共的对象，类似于 C 语言中的结构体定义，在 Java 中是一个 JavaBean

服务类型：

service：对应服务的类

协议

• TBinaryProtocol —— 二进制编码格式进行数据传输

• TCompactProtocol —— 高效率的、密集的二进制编码格式进行数据传输

  使用 TCompactProtocol 协议构建的 HelloServiceServer.java

  TCompactProtocol.Factory proFactory = new TCompactProtocol.Factory();

  使用 TCompactProtocol 协议的 HelloServiceClient.java

  TCompactProtocol protocol = new TCompactProtocol(transport);

• TJSONProtocol —— 使用 JSON 的数据编码协议进行数据传输

  使用 TJSONProtocol 协议构建的 HelloServiceServer.java

  TJSONProtocol.Factory proFactory = new TJSONProtocol.Factory();

  使用 TJSONProtocol 协议的 HelloServiceClient.java

  TJSONProtocol protocol = new TJSONProtocol(transport);

• TSimpleJSONProtocol —— 只提供 JSON 只写的协议，适用于通过脚本语言解析

传输层

TSocket —— 使用阻塞式 I/O 进行传输，是最常见的模式

TFramedTransport —— 使用非阻塞方式，按块的大小进行传输，类似于 Java 中的 NIO

注意：

若使用 TFramedTransport 传输层，其服务器必须修改为非阻塞的服务类型，客户端只需替换清单 4 中 TTransport 部分，代码如下，清单 9 中 TNonblockingServerTransport 类是构建非阻塞 socket 的抽象类，TNonblockingServerSocket 类继承 TNonblockingServerTransport

使用 TFramedTransport 传输层构建的 HelloServiceServer.java

TNonblockingServerTransport serverTransport; 
serverTransport = new TNonblockingServerSocket(10005); 
Hello.Processor processor = new Hello.Processor(new HelloServiceImpl()); 
TServer server = new TNonblockingServer(processor, serverTransport); 
System.out.println("Start server on port 10005 ..."); 
server.serve();

使用 TFramedTransport 传输层的 HelloServiceClient.java

TTransport transport = new TFramedTransport(new TSocket("localhost", 10005));

服务端类型

TSimpleServer —— 单线程服务器端使用标准的阻塞式 I/O

TServerSocket serverTransport = new TServerSocket(7911); 
TProcessor processor = new Hello.Processor(new HelloServiceImpl()); 
TServer server = new TSimpleServer(processor, serverTransport); 
System.out.println("Start server on port 7911..."); 
server.serve();

TThreadPoolServer —— 多线程服务器端使用标准的阻塞式 I/O

TNonblockingServer —— 多线程服务器端使用非阻塞式 I/O

Thrift 异步客户端构建

Thrift 提供非阻塞的调用方式，可构建异步客户端。在这种方式中，Thrift 提供了新的类 TAsyncClientManager 用于管理客户端的请求，在一个线程上追踪请求和响应，同时通过接口 AsyncClient 传递标准的参数和 callback 对象，服务调用完成后，callback 提供了处理调用结果和异常的方法。

CallBack 的实现：MethodCallback.java

package service.callback; 
import org.apache.thrift.async.AsyncMethodCallback; 
public class MethodCallback implements AsyncMethodCallback { 
        Object response = null; 
        public Object getResult() { 
        	// 返回结果值
        	return this.response; 
        } 
        // 处理服务返回的结果值
        @Override 
        public void onComplete(Object response) { 
        	this.response = response; 
        } 
        // 处理调用服务过程中出现的异常
        @Override 
        public void onError(Throwable throwable) { 
        } 
}

onComplete 方法接收服务处理后的结果，此处我们将结果 response 直接赋值给 callback 的私有属性 response。onError 方法接收服务处理过程中抛出的异常，此处未对异常进行处理

创建非阻塞服务器端实现代码，将 HelloServiceImpl 作为具体的处理器传递给异步 Thrift 服务器，代码如下:

package service.server; 
import org.apache.thrift.server.TNonblockingServer; 
import org.apache.thrift.server.TServer; 
import org.apache.thrift.transport.TNonblockingServerSocket; 
import org.apache.thrift.transport.TNonblockingServerTransport; 
import org.apache.thrift.transport.TTransportException; 
import service.demo.Hello; 
import service.demo.HelloServiceImpl; 
public class HelloServiceAsyncServer { 
        /** 
         * 启动 Thrift 异步服务器
         * @param args 
        */ 
       public static void main(String[] args) { 
			TNonblockingServerTransport serverTransport; 
        	try { 
        		serverTransport = new TNonblockingServerSocket(10005); 
        		Hello.Processor processor = new Hello.Processor( 
        		new HelloServiceImpl()); 
        		TServer server = new TNonblockingServer(processor, serverTransport); 
        		System.out.println("Start server on port 10005 ..."); 
        		server.serve(); 
        	} catch (TTransportException e) { 
        		e.printStackTrace(); 
        	} 
        } 
}

HelloServiceAsyncServer 通过 java.nio.channels.ServerSocketChannel 创建非阻塞的服务器端等待客户端的连接。

创建异步客户端实现代码，调用 Hello.AsyncClient 访问服务端的逻辑实现，将 MethodCallback 对象作为参数传入调用方法中，代码如下：

package service.client;
import java.io.IOException;
import org.apache.thrift.async.AsyncMethodCallback;
import org.apache.thrift.async.TAsyncClientManager;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocolFactory;
import org.apache.thrift.transport.TNonblockingSocket;
import org.apache.thrift.transport.TNonblockingTransport;
import service.callback.MethodCallback;
import service.demo.Hello;

public class HelloServiceAsyncClient {
    /**
     * 调用 Hello 服务
     *
     * @param args
     */
    public static void main(String[] args) throws Exception {
        try {
            TAsyncClientManager clientManager = new TAsyncClientManager();
            TNonblockingTransport transport = new TNonblockingSocket("localhost", 10005);
            TProtocolFactory protocol = new TBinaryProtocol.Factory();
            Hello.AsyncClient asyncClient = new Hello.AsyncClient(protocol,clientManager, transport);
            System.out.println("Client calls .....");
            MethodCallback callBack = new MethodCallback();
            asyncClient.helloString("Hello World", callBack);
            Object res = callBack.getResult();
            while (res == null) {
                res = callBack.getResult();
            }
            System.out.println(((Hello.AsyncClient.helloString_call) res).getResult());
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}