Thrift入门及Java实例演示

作者: Michael 日期: 2012 年 6 月 14 日发表评论 (37) 查看评论

目录：

概述
下载配置
基本概念
1. 数据类型
2. 服务端编码基本步骤
3. 客户端编码基本步骤
4. 数据传输协议
实例演示（java）
1. thrift生成代码
2. 实现接口Iface
3. TSimpleServer服务模型
4. TThreadPoolServer 服务模型
5. TNonblockingServer 服务模型
6. THsHaServer服务模型
7. 异步客户端

[一]、概述

Thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引擎，以构建在 C++, Java, Python, PHP, Ruby, Erlang, Perl, Haskell, C#, Cocoa, JavaScript, Node.js, Smalltalk, and OCaml 等等编程语言间无缝结合的、高效的服务。

Thrift最初由facebook开发，07年四月开放源码，08年5月进入apache孵化器。thrift允许你定义一个简单的定义文件中的数据类型和服务接口。以作为输入文件，编译器生成代码用来方便地生成RPC客户端和服务器通信的无缝跨编程语言。

官网地址：thrift.apache.org

推荐值得一看的文章：

http://jnb.ociweb.com/jnb/jnbJun2009.html
http://wiki.apache.org/thrift
http://thrift.apache.org/static/files/thrift-20070401.pdf

[二]、下载配置

到官网下载最新版本，截止今日（2012-06-11）最新版本为0.8.0.

1. 如果是Maven构建项目的，直接在pom.xml 中添加如下内容：

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

<groupId>org.apache.thrift</groupId>

<artifactId>libthrift</artifactId>

</dependency>

2.如果自己编译lib包，把下载的压缩包解压到X:盘，然后在X:\thrift-0.8.0\lib\java 目录下运行ant进行自动编译，会在X:\thrift-0.8.0\lib\java\build\ 目录下看到编译好的lib包：libthrift-0.8.0.jar

[三]、基本概念

1.数据类型

基本类型：
- bool：布尔值，true 或 false，对应 Java 的 boolean
- byte：8 位有符号整数，对应 Java 的 byte
- i16：16 位有符号整数，对应 Java 的 short
- i32：32 位有符号整数，对应 Java 的 int
- i64：64 位有符号整数，对应 Java 的 long
- double：64 位浮点数，对应 Java 的 double
- string：utf-8编码的字符串，对应 Java 的 String
结构体类型：
- struct：定义公共的对象，类似于 C 语言中的结构体定义，在 Java 中是一个 JavaBean
容器类型：
- list：对应 Java 的 ArrayList
- set：对应 Java 的 HashSet
- map：对应 Java 的 HashMap
异常类型：
- exception：对应 Java 的 Exception
服务类型：
- service：对应服务的类

2.服务端编码基本步骤：

实现服务处理接口impl
创建TProcessor
创建TServerTransport
创建TProtocol
创建TServer
启动Server

3.客户端编码基本步骤：

创建Transport
创建TProtocol
基于TTransport和TProtocol创建 Client
调用Client的相应方法

4.数据传输协议

TBinaryProtocol : 二进制格式.
TCompactProtocol : 压缩格式
TJSONProtocol : JSON格式
TSimpleJSONProtocol : 提供JSON只写协议, 生成的文件很容易通过脚本语言解析

tips:客户端和服务端的协议要一致

[四]、实例演示

1. thrift生成代码

创建Thrift文件：G:\test\thrift\demoHello.thrift ,内容如下：

namespace java com.micmiu.thrift.demo

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

namespace java com.micmiu.thrift.demo

service HelloWorldService {

string sayHello(1:string username)

}

目录结构如下：

G:\test\thrift>tree /F
卷 other 的文件夹 PATH 列表
卷序列号为 D238-BE47
G:.
    demoHello.thrift
    demouser.thrift
    thrift-0.8.0.exe

没有子文件夹

G:\test\thrift>tree /F

卷 other 的文件夹 PATH 列表

卷序列号为 D238-BE47

G:.

demoHello.thrift

demouser.thrift

thrift-0.8.0.exe

没有子文件夹

thrift-0.8.0.exe 是官网提供的windows下编译工具，运用这个工具生成相关代码：

thrift-0.8.0.exe -r -gen java ./demoHello.thrift

1	thrift-0.8.0.exe -r -gen java ./demoHello.thrift

生成后的目录结构如下：

G:\test\thrift>tree /F
卷 other 的文件夹 PATH 列表
卷序列号为 D238-BE47
G:.
│  demoHello.thrift
│  demouser.thrift
│  thrift-0.8.0.exe
│
└─gen-java
    └─com
        └─micmiu
            └─thrift
                └─demo
                        HelloWorldService.java

G:\test\thrift>tree /F

卷 other 的文件夹 PATH 列表

卷序列号为 D238-BE47

G:.

│ demoHello.thrift

│ demouser.thrift

│ thrift-0.8.0.exe

│

└─gen-java

└─com

└─micmiu

└─thrift

└─demo

HelloWorldService.java

将生成的HelloWorldService.java 文件copy到自己测试的工程中，我的工程是用maven构建的，故在pom.xml中增加如下内容：

<dependency>
	<groupId>org.apache.thrift</groupId>
	<artifactId>libthrift</artifactId>
	<version>0.8.0</version>
</dependency>
<dependency>
	<groupId>org.slf4j</groupId>
	<artifactId>slf4j-log4j12</artifactId>
	<version>1.5.8</version>
</dependency>

<groupId>org.apache.thrift</groupId>

<artifactId>libthrift</artifactId>

</dependency>

</dependency>

2. 实现接口Iface

java代码：HelloWorldImpl.java

package com.micmiu.thrift.demo;

import org.apache.thrift.TException;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloWorldImpl implements HelloWorldService.Iface {

	public HelloWorldImpl() {
	}

	@Override
	public String sayHello(String username) throws TException {
		return "Hi," + username + " welcome to my blog www.micmiu.com";
	}

}

package com.micmiu.thrift.demo;

import org.apache.thrift.TException;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloWorldImpl implements HelloWorldService.Iface {

public HelloWorldImpl() {

}

@Override

public String sayHello(String username) throws TException {

return "Hi," + username + " welcome to my blog www.micmiu.com";

}

3.TSimpleServer服务端

简单的单线程服务模型，一般用于测试。

编写服务端server代码：HelloServerDemo.java

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TJSONProtocol;
import org.apache.thrift.protocol.TSimpleJSONProtocol;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TSimpleServer;
import org.apache.thrift.transport.TServerSocket;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloServerDemo {
	public static final int SERVER_PORT = 8090;

	public void startServer() {
		try {
			System.out.println("HelloWorld TSimpleServer start ....");

			TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
					new HelloWorldImpl());
			// HelloWorldService.Processor<HelloWorldService.Iface> tprocessor =
			// new HelloWorldService.Processor<HelloWorldService.Iface>(
			// new HelloWorldImpl());

			// 简单的单线程服务模型，一般用于测试
			TServerSocket serverTransport = new TServerSocket(SERVER_PORT);
			TServer.Args tArgs = new TServer.Args(serverTransport);
			tArgs.processor(tprocessor);
			tArgs.protocolFactory(new TBinaryProtocol.Factory());
			// tArgs.protocolFactory(new TCompactProtocol.Factory());
			// tArgs.protocolFactory(new TJSONProtocol.Factory());
			TServer server = new TSimpleServer(tArgs);
			server.serve();

		} catch (Exception e) {
			System.out.println("Server start error!!!");
			e.printStackTrace();
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HelloServerDemo server = new HelloServerDemo();
		server.startServer();
	}

}

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;

import org.apache.thrift.protocol.TBinaryProtocol;

import org.apache.thrift.protocol.TCompactProtocol;

import org.apache.thrift.protocol.TJSONProtocol;

import org.apache.thrift.protocol.TSimpleJSONProtocol;

import org.apache.thrift.server.TServer;

import org.apache.thrift.server.TSimpleServer;

import org.apache.thrift.transport.TServerSocket;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloServerDemo {

public static final int SERVER_PORT = 8090;

public void startServer() {

try {

System.out.println("HelloWorld TSimpleServer start ....");

TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(

new HelloWorldImpl());

// HelloWorldService.Processor<HelloWorldService.Iface> tprocessor =

// new HelloWorldService.Processor<HelloWorldService.Iface>(

// new HelloWorldImpl());

// 简单的单线程服务模型，一般用于测试

TServerSocket serverTransport = new TServerSocket(SERVER_PORT);

TServer.Args tArgs = new TServer.Args(serverTransport);

tArgs.processor(tprocessor);

tArgs.protocolFactory(new TBinaryProtocol.Factory());

// tArgs.protocolFactory(new TCompactProtocol.Factory());

// tArgs.protocolFactory(new TJSONProtocol.Factory());

TServer server = new TSimpleServer(tArgs);

server.serve();

} catch (Exception e) {

System.out.println("Server start error!!!");

e.printStackTrace();

}

/**

* @param args

public static void main(String[] args) {

HelloServerDemo server = new HelloServerDemo();

server.startServer();

}

编写客户端Client代码：HelloClientDemo.java

package com.micmiu.thrift.demo;

import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TJSONProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloClientDemo {

	public static final String SERVER_IP = "localhost";
	public static final int SERVER_PORT = 8090;
	public static final int TIMEOUT = 30000;

	/**
	 *
	 * @param userName
	 */
	public void startClient(String userName) {
		TTransport transport = null;
		try {
			transport = new TSocket(SERVER_IP, SERVER_PORT, TIMEOUT);
			// 协议要和服务端一致
			TProtocol protocol = new TBinaryProtocol(transport);
			// TProtocol protocol = new TCompactProtocol(transport);
			// TProtocol protocol = new TJSONProtocol(transport);
			HelloWorldService.Client client = new HelloWorldService.Client(
					protocol);
			transport.open();
			String result = client.sayHello(userName);
			System.out.println("Thrify client result =: " + result);
		} catch (TTransportException e) {
			e.printStackTrace();
		} catch (TException e) {
			e.printStackTrace();
		} finally {
			if (null != transport) {
				transport.close();
			}
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HelloClientDemo client = new HelloClientDemo();
		client.startClient("Michael");

	}

}

package com.micmiu.thrift.demo;

import org.apache.thrift.TException;

import org.apache.thrift.protocol.TBinaryProtocol;

import org.apache.thrift.protocol.TCompactProtocol;

import org.apache.thrift.protocol.TJSONProtocol;

import org.apache.thrift.protocol.TProtocol;

import org.apache.thrift.transport.TSocket;

import org.apache.thrift.transport.TTransport;

import org.apache.thrift.transport.TTransportException;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloClientDemo {

public static final String SERVER_IP = "localhost";

public static final int SERVER_PORT = 8090;

public static final int TIMEOUT = 30000;

/**

* @param userName

public void startClient(String userName) {

TTransport transport = null;

try {

transport = new TSocket(SERVER_IP, SERVER_PORT, TIMEOUT);

// 协议要和服务端一致

TProtocol protocol = new TBinaryProtocol(transport);

// TProtocol protocol = new TCompactProtocol(transport);

// TProtocol protocol = new TJSONProtocol(transport);

HelloWorldService.Client client = new HelloWorldService.Client(

protocol);

transport.open();

String result = client.sayHello(userName);

System.out.println("Thrify client result =: " + result);

} catch (TTransportException e) {

e.printStackTrace();

} catch (TException e) {

e.printStackTrace();

} finally {

if (null != transport) {

transport.close();

}

/**

* @param args

public static void main(String[] args) {

HelloClientDemo client = new HelloClientDemo();

client.startClient("Michael");

}

先运行服务端程序，日志如下：

HelloWorld TSimpleServer start ....

1	HelloWorld TSimpleServer start ....

再运行客户端调用程序，日志如下：

Thrify client result =: Hi,Michael welcome to my blog www.micmiu.com

1	Thrify client result =: Hi,Michael welcome to my blog www.micmiu.com

测试成功，和预期的返回信息一致。

4.TThreadPoolServer 服务模型

线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求。

编写服务端代码：HelloServerDemo.java

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TThreadPoolServer;
import org.apache.thrift.transport.TServerSocket;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloServerDemo {
	public static final int SERVER_PORT = 8090;

	public void startServer() {
		try {
			System.out.println("HelloWorld TThreadPoolServer start ....");

			TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
					new HelloWorldImpl());

			 TServerSocket serverTransport = new TServerSocket(SERVER_PORT);
			 TThreadPoolServer.Args ttpsArgs = new TThreadPoolServer.Args(
			 serverTransport);
			 ttpsArgs.processor(tprocessor);
			 ttpsArgs.protocolFactory(new TBinaryProtocol.Factory());

			// 线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求。
			 TServer server = new TThreadPoolServer(ttpsArgs);
			 server.serve();

		} catch (Exception e) {
			System.out.println("Server start error!!!");
			e.printStackTrace();
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HelloServerDemo server = new HelloServerDemo();
		server.startServer();
	}

}

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;

import org.apache.thrift.protocol.TBinaryProtocol;

import org.apache.thrift.server.TServer;

import org.apache.thrift.server.TThreadPoolServer;

import org.apache.thrift.transport.TServerSocket;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloServerDemo {

public static final int SERVER_PORT = 8090;

public void startServer() {

try {

System.out.println("HelloWorld TThreadPoolServer start ....");

TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(

new HelloWorldImpl());

TServerSocket serverTransport = new TServerSocket(SERVER_PORT);

TThreadPoolServer.Args ttpsArgs = new TThreadPoolServer.Args(

serverTransport);

ttpsArgs.processor(tprocessor);

ttpsArgs.protocolFactory(new TBinaryProtocol.Factory());

// 线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求。

TServer server = new TThreadPoolServer(ttpsArgs);

server.serve();

} catch (Exception e) {

System.out.println("Server start error!!!");

e.printStackTrace();

}

/**

* @param args

public static void main(String[] args) {

HelloServerDemo server = new HelloServerDemo();

server.startServer();

}

客户端Client代码和之前的一样，只要数据传输的协议一致即可，客户端测试成功，结果如下：

Thrify client result =: Hi,Michael welcome to my blog www.micmiu.com

1	Thrify client result =: Hi,Michael welcome to my blog www.micmiu.com

5.TNonblockingServer 服务模型

使用非阻塞式IO，服务端和客户端需要指定 TFramedTransport 数据传输的方式。

编写服务端代码：HelloServerDemo.java

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.TNonblockingServer;
import org.apache.thrift.server.TServer;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TNonblockingServerSocket;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloServerDemo {
	public static final int SERVER_PORT = 8090;

	public void startServer() {
		try {
			System.out.println("HelloWorld TNonblockingServer start ....");

			TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
					new HelloWorldImpl());

			TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(
					SERVER_PORT);
			TNonblockingServer.Args tnbArgs = new TNonblockingServer.Args(
					tnbSocketTransport);
			tnbArgs.processor(tprocessor);
			tnbArgs.transportFactory(new TFramedTransport.Factory());
			tnbArgs.protocolFactory(new TCompactProtocol.Factory());

			// 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式
			TServer server = new TNonblockingServer(tnbArgs);
			server.serve();

		} catch (Exception e) {
			System.out.println("Server start error!!!");
			e.printStackTrace();
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HelloServerDemo server = new HelloServerDemo();
		server.startServer();
	}

}

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;

import org.apache.thrift.protocol.TCompactProtocol;

import org.apache.thrift.server.TNonblockingServer;

import org.apache.thrift.server.TServer;

import org.apache.thrift.transport.TFramedTransport;

import org.apache.thrift.transport.TNonblockingServerSocket;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloServerDemo {

public static final int SERVER_PORT = 8090;

public void startServer() {

try {

System.out.println("HelloWorld TNonblockingServer start ....");

TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(

new HelloWorldImpl());

TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(

SERVER_PORT);

TNonblockingServer.Args tnbArgs = new TNonblockingServer.Args(

tnbSocketTransport);

tnbArgs.processor(tprocessor);

tnbArgs.transportFactory(new TFramedTransport.Factory());

tnbArgs.protocolFactory(new TCompactProtocol.Factory());

// 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式

TServer server = new TNonblockingServer(tnbArgs);

server.serve();

} catch (Exception e) {

System.out.println("Server start error!!!");

e.printStackTrace();

}

/**

* @param args

public static void main(String[] args) {

HelloServerDemo server = new HelloServerDemo();

server.startServer();

}

编写客户端代码：HelloClientDemo.java

package com.micmiu.thrift.demo;

import org.apache.thrift.TException;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;
import org.apache.thrift.transport.TTransportException;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloClientDemo {

	public static final String SERVER_IP = "localhost";
	public static final int SERVER_PORT = 8090;
	public static final int TIMEOUT = 30000;

	/**
	 *
	 * @param userName
	 */
	public void startClient(String userName) {
		TTransport transport = null;
		try {
			transport = new TFramedTransport(new TSocket(SERVER_IP,
					SERVER_PORT, TIMEOUT));
			// 协议要和服务端一致
			TProtocol protocol = new TCompactProtocol(transport);
			HelloWorldService.Client client = new HelloWorldService.Client(
					protocol);
			transport.open();
			String result = client.sayHello(userName);
			System.out.println("Thrify client result =: " + result);
		} catch (TTransportException e) {
			e.printStackTrace();
		} catch (TException e) {
			e.printStackTrace();
		} finally {
			if (null != transport) {
				transport.close();
			}
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HelloClientDemo client = new HelloClientDemo();
		client.startClient("Michael");

	}

}

package com.micmiu.thrift.demo;

import org.apache.thrift.TException;

import org.apache.thrift.protocol.TCompactProtocol;

import org.apache.thrift.protocol.TProtocol;

import org.apache.thrift.transport.TFramedTransport;

import org.apache.thrift.transport.TSocket;

import org.apache.thrift.transport.TTransport;

import org.apache.thrift.transport.TTransportException;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloClientDemo {

public static final String SERVER_IP = "localhost";

public static final int SERVER_PORT = 8090;

public static final int TIMEOUT = 30000;

/**

* @param userName

public void startClient(String userName) {

TTransport transport = null;

try {

transport = new TFramedTransport(new TSocket(SERVER_IP,

SERVER_PORT, TIMEOUT));

// 协议要和服务端一致

TProtocol protocol = new TCompactProtocol(transport);

HelloWorldService.Client client = new HelloWorldService.Client(

protocol);

transport.open();

String result = client.sayHello(userName);

System.out.println("Thrify client result =: " + result);

} catch (TTransportException e) {

e.printStackTrace();

} catch (TException e) {

e.printStackTrace();

} finally {

if (null != transport) {

transport.close();

}

/**

* @param args

public static void main(String[] args) {

HelloClientDemo client = new HelloClientDemo();

client.startClient("Michael");

}

客户端的测试成功，结果如下：

Thrify client result =: Hi,Michael welcome to my blog www.micmiu.com

1	Thrify client result =: Hi,Michael welcome to my blog www.micmiu.com

6.THsHaServer服务模型

半同步半异步的服务端模型，需要指定为： TFramedTransport 数据传输的方式。

编写服务端代码：HelloServerDemo.java

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.THsHaServer;
import org.apache.thrift.server.TNonblockingServer;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TSimpleServer;
import org.apache.thrift.server.TThreadPoolServer;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TNonblockingServerSocket;
import org.apache.thrift.transport.TServerSocket;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloServerDemo {
	public static final int SERVER_PORT = 8090;

	public void startServer() {
		try {
			System.out.println("HelloWorld THsHaServer start ....");

			TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
					new HelloWorldImpl());

			TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(
					SERVER_PORT);
			THsHaServer.Args thhsArgs = new THsHaServer.Args(tnbSocketTransport);
			thhsArgs.processor(tprocessor);
			thhsArgs.transportFactory(new TFramedTransport.Factory());
			thhsArgs.protocolFactory(new TBinaryProtocol.Factory());

			//半同步半异步的服务模型
			TServer server = new THsHaServer(thhsArgs);
			server.serve();

		} catch (Exception e) {
			System.out.println("Server start error!!!");
			e.printStackTrace();
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HelloServerDemo server = new HelloServerDemo();
		server.startServer();
	}

}

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;

import org.apache.thrift.protocol.TBinaryProtocol;

import org.apache.thrift.protocol.TCompactProtocol;

import org.apache.thrift.server.THsHaServer;

import org.apache.thrift.server.TNonblockingServer;

import org.apache.thrift.server.TServer;

import org.apache.thrift.server.TSimpleServer;

import org.apache.thrift.server.TThreadPoolServer;

import org.apache.thrift.transport.TFramedTransport;

import org.apache.thrift.transport.TNonblockingServerSocket;

import org.apache.thrift.transport.TServerSocket;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloServerDemo {

public static final int SERVER_PORT = 8090;

public void startServer() {

try {

System.out.println("HelloWorld THsHaServer start ....");

TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(

new HelloWorldImpl());

TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(

SERVER_PORT);

THsHaServer.Args thhsArgs = new THsHaServer.Args(tnbSocketTransport);

thhsArgs.processor(tprocessor);

thhsArgs.transportFactory(new TFramedTransport.Factory());

thhsArgs.protocolFactory(new TBinaryProtocol.Factory());

//半同步半异步的服务模型

TServer server = new THsHaServer(thhsArgs);

server.serve();

} catch (Exception e) {

System.out.println("Server start error!!!");

e.printStackTrace();

}

/**

* @param args

public static void main(String[] args) {

HelloServerDemo server = new HelloServerDemo();

server.startServer();

}

客户端代码和上面 4 中的类似，只要注意传输协议一致以及指定传输方式为TFramedTransport。

7.异步客户端

编写服务端代码：HelloServerDemo.java

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.server.TNonblockingServer;
import org.apache.thrift.server.TServer;
import org.apache.thrift.transport.TFramedTransport;
import org.apache.thrift.transport.TNonblockingServerSocket;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloServerDemo {
	public static final int SERVER_PORT = 8090;

	public void startServer() {
		try {
			System.out.println("HelloWorld TNonblockingServer start ....");

			TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(
					new HelloWorldImpl());

			TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(
					SERVER_PORT);
			TNonblockingServer.Args tnbArgs = new TNonblockingServer.Args(
					tnbSocketTransport);
			tnbArgs.processor(tprocessor);
			tnbArgs.transportFactory(new TFramedTransport.Factory());
			tnbArgs.protocolFactory(new TCompactProtocol.Factory());

			// 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式
			TServer server = new TNonblockingServer(tnbArgs);
			server.serve();

		} catch (Exception e) {
			System.out.println("Server start error!!!");
			e.printStackTrace();
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HelloServerDemo server = new HelloServerDemo();
		server.startServer();
	}

}

package com.micmiu.thrift.demo;

import org.apache.thrift.TProcessor;

import org.apache.thrift.protocol.TCompactProtocol;

import org.apache.thrift.server.TNonblockingServer;

import org.apache.thrift.server.TServer;

import org.apache.thrift.transport.TFramedTransport;

import org.apache.thrift.transport.TNonblockingServerSocket;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloServerDemo {

public static final int SERVER_PORT = 8090;

public void startServer() {

try {

System.out.println("HelloWorld TNonblockingServer start ....");

TProcessor tprocessor = new HelloWorldService.Processor<HelloWorldService.Iface>(

new HelloWorldImpl());

TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(

SERVER_PORT);

TNonblockingServer.Args tnbArgs = new TNonblockingServer.Args(

tnbSocketTransport);

tnbArgs.processor(tprocessor);

tnbArgs.transportFactory(new TFramedTransport.Factory());

tnbArgs.protocolFactory(new TCompactProtocol.Factory());

// 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式

TServer server = new TNonblockingServer(tnbArgs);

server.serve();

} catch (Exception e) {

System.out.println("Server start error!!!");

e.printStackTrace();

}

/**

* @param args

public static void main(String[] args) {

HelloServerDemo server = new HelloServerDemo();

server.startServer();

}

编写客户端Client代码：HelloAsynClientDemo.java

package com.micmiu.thrift.demo;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

import org.apache.thrift.TException;
import org.apache.thrift.async.AsyncMethodCallback;
import org.apache.thrift.async.TAsyncClientManager;
import org.apache.thrift.protocol.TCompactProtocol;
import org.apache.thrift.protocol.TProtocolFactory;
import org.apache.thrift.transport.TNonblockingSocket;
import org.apache.thrift.transport.TNonblockingTransport;

import com.micmiu.thrift.demo.HelloWorldService.AsyncClient.sayHello_call;

/**
 * blog http://www.micmiu.com
 *
 * @author Michael
 *
 */
public class HelloAsynClientDemo {

	public static final String SERVER_IP = "localhost";
	public static final int SERVER_PORT = 8090;
	public static final int TIMEOUT = 30000;

	/**
	 *
	 * @param userName
	 */
	public void startClient(String userName) {
		try {
			TAsyncClientManager clientManager = new TAsyncClientManager();
			TNonblockingTransport transport = new TNonblockingSocket(SERVER_IP,
					SERVER_PORT, TIMEOUT);

			TProtocolFactory tprotocol = new TCompactProtocol.Factory();
			HelloWorldService.AsyncClient asyncClient = new HelloWorldService.AsyncClient(
					tprotocol, clientManager, transport);
			System.out.println("Client start .....");

			CountDownLatch latch = new CountDownLatch(1);
			AsynCallback callBack = new AsynCallback(latch);
			System.out.println("call method sayHello start ...");
			asyncClient.sayHello(userName, callBack);
			System.out.println("call method sayHello .... end");
			boolean wait = latch.await(30, TimeUnit.SECONDS);
			System.out.println("latch.await =:" + wait);
		} catch (Exception e) {
			e.printStackTrace();
		}
		System.out.println("startClient end.");
	}

	public class AsynCallback implements AsyncMethodCallback<sayHello_call> {
		private CountDownLatch latch;

		public AsynCallback(CountDownLatch latch) {
			this.latch = latch;
		}

		@Override
		public void onComplete(sayHello_call response) {
			System.out.println("onComplete");
			try {
				// Thread.sleep(1000L * 1);
				System.out.println("AsynCall result =:"
						+ response.getResult().toString());
			} catch (TException e) {
				e.printStackTrace();
			} catch (Exception e) {
				e.printStackTrace();
			} finally {
				latch.countDown();
			}
		}

		@Override
		public void onError(Exception exception) {
			System.out.println("onError :" + exception.getMessage());
			latch.countDown();
		}
	}

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		HelloAsynClientDemo client = new HelloAsynClientDemo();
		client.startClient("Michael");

	}

}

package com.micmiu.thrift.demo;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

import org.apache.thrift.TException;

import org.apache.thrift.async.AsyncMethodCallback;

import org.apache.thrift.async.TAsyncClientManager;

import org.apache.thrift.protocol.TCompactProtocol;

import org.apache.thrift.protocol.TProtocolFactory;

import org.apache.thrift.transport.TNonblockingSocket;

import org.apache.thrift.transport.TNonblockingTransport;

import com.micmiu.thrift.demo.HelloWorldService.AsyncClient.sayHello_call;

/**

* blog http://www.micmiu.com

* @author Michael

public class HelloAsynClientDemo {

public static final String SERVER_IP = "localhost";

public static final int SERVER_PORT = 8090;

public static final int TIMEOUT = 30000;

/**

* @param userName

public void startClient(String userName) {

try {

TAsyncClientManager clientManager = new TAsyncClientManager();

TNonblockingTransport transport = new TNonblockingSocket(SERVER_IP,

SERVER_PORT, TIMEOUT);

TProtocolFactory tprotocol = new TCompactProtocol.Factory();

HelloWorldService.AsyncClient asyncClient = new HelloWorldService.AsyncClient(

tprotocol, clientManager, transport);

System.out.println("Client start .....");

CountDownLatch latch = new CountDownLatch(1);

AsynCallback callBack = new AsynCallback(latch);

System.out.println("call method sayHello start ...");

asyncClient.sayHello(userName, callBack);

System.out.println("call method sayHello .... end");

boolean wait = latch.await(30, TimeUnit.SECONDS);

System.out.println("latch.await =:" + wait);

} catch (Exception e) {

e.printStackTrace();

}

System.out.println("startClient end.");

}

public class AsynCallback implements AsyncMethodCallback<sayHello_call> {

private CountDownLatch latch;

public AsynCallback(CountDownLatch latch) {

this.latch = latch;

}

@Override

public void onComplete(sayHello_call response) {

System.out.println("onComplete");

try {

// Thread.sleep(1000L * 1);

System.out.println("AsynCall result =:"

+ response.getResult().toString());

} catch (TException e) {

e.printStackTrace();

} catch (Exception e) {

e.printStackTrace();

} finally {

latch.countDown();

}

@Override

public void onError(Exception exception) {

System.out.println("onError :" + exception.getMessage());

latch.countDown();

}

/**

* @param args

public static void main(String[] args) {

HelloAsynClientDemo client = new HelloAsynClientDemo();

client.startClient("Michael");

}

先运行服务程序，再运行客户端程序，测试结果如下：

Client start .....
call method sayHello start ...
call method sayHello .... end
onComplete
AsynCall result =:Hi,Michael welcome to my blog www.micmiu.com
latch.await =:true
startClient end.

Client start .....

call method sayHello start ...

call method sayHello .... end

onComplete

AsynCall result =:Hi,Michael welcome to my blog www.micmiu.com

latch.await =:true

startClient end.

————

原创文章，转载请注明： 转载自micmiu – 软件开发+生活点滴[ http://www.micmiu.com/ ]

本文链接地址: http://www.micmiu.com/soa/rpc/thrift-sample/

RPCapache, RPC, Thrift

← Apache Ivy入门

JRobin绘制指定时间段的流量图 →

发表评论？

37 条评论。

123.。。。 2017 年 9 月 11 日在下午 6:00

博主你好，我想问一下，thrift中的ssl传输你有用过吗？

回复
chenfeng 2017 年 5 月 31 日在下午 5:05

😛 😀 😳
博主可有C#客户端java服务端的样例么？最近在弄这个thrift，头疼

回复
大胡子 2017 年 3 月 5 日在下午 8:40

请教博主，HelloWorldService.java这个文件copy到哪个路径下了？还有，你新建的HelloServerDemo.java，又放到哪个路径下了？

请指教，多谢！

回复
麦子 2016 年 11 月 1 日在下午 2:29

感谢，分享，赞一个！

回复
jing 2016 年 7 月 27 日在下午 12:09

请问楼主，在代码的哪部门进行二进制传输了

回复
Kaka 2016 年 1 月 5 日在下午 9:50

请问你的大于小于用&lt &gt ；而不直接用呢

回复
- Done++ 2017 年 3 月 21 日在上午 10:21
  
  转义的作用防止跟冲突了
  
  回复
while.for 2015 年 11 月 5 日在下午 5:56

对nifty有研究么？几乎木有什么资料。。。抓狂ing…

回复
- Michael 2015 年 11 月 6 日在下午 4:57
  
  还个还真没有接触过
  
  回复
东辉 2015 年 9 月 27 日在下午 8:05

非常感谢

回复
东辉 2015 年 9 月 27 日在下午 8:00

非常好，最近项目中应用到Thrift。学习了，程序也可以跑起来！

回复
kou 2015 年 8 月 20 日在下午 5:27

谢谢啦

回复
水煮鱼 2015 年 8 月 17 日在下午 12:00

非常不错,刚刚接触这个东西。看了博主的文章懂了些基础的东西。感谢

回复
abc 2015 年 5 月 8 日在上午 10:56

楼主有qq吗

回复
leo 2015 年 4 月 30 日在上午 11:57

使用 thrift 工具生成的java 文件加载到项目中提示出现大量的：
Error:(383, 20) java: service.demo.Hello.Processor.helloString不是抽象的, 并且未覆盖org.apache.thrift.ProcessFunction中的抽象方法isOneway()
错误信息。请教楼主怎么破？

回复
zhxh007 2015 年 4 月 25 日在下午 2:02

楼主用的eclispe么，什么主题啊，挺好看的

回复
颜颜 2014 年 12 月 1 日在下午 11:53

请教下博主用半异步半同步的时候我开启了多个服务每个都指定了一个端口号然后客户端链接的时候一到执行实现服务接口的方法时就客户端保持了。。既不往下运行也不停止。。。。可能是什么原因造成的呢。。谢谢啦！

回复
- Michael 2014 年 12 月 9 日在下午 11:15
  
  既不继续运行也不停止，这只是个表面现象，要找到真正原因（死锁、挂起还是。。。）才能解决
  
  回复
原 2014 年 11 月 6 日在上午 11:52

博主你好，7的代码和5的代码有什么区别呢？

回复
- Michael 2014 年 11 月 24 日在下午 4:32
  
  没有实际对比过，估计差异不大，最好看看官方这两个版本的说明
  
  回复
glutton 2014 年 4 月 4 日在上午 11:49

博主你好，文章非常有用
就是在最后一个例子，我的异步客户端输出如下：
Client start …..
call method sayHello start …
call method sayHello …. end
latch.await =:false
startClient end.

没有获得和您一样的结果，大约是什么原因呢？感谢

回复
- nicheng 2018 年 2 月 26 日在下午 4:23
  
  让主线程 sleep 一下
  
  回复
glutton 2014 年 4 月 4 日在上午 11:48

博主你好，文章非常有用
就是在最后一个例子，我的异步客户端输出如下：

回复
清风 2014 年 3 月 31 日在下午 6:08

请问 Thrift的数据是如何进行传递的
和普通的WebService的区别仅在于 WS传递的是XML 而Thrift传递的是thrift包？
thrift的封包解包和WS的有什么区别
为什么thrift比用CXF实现的WS要快（PS.我自己做了个实验，前者的耗时大概是后者的1/3到1/10）

回复
- Michael 2014 年 3 月 31 日在下午 11:00
  
  thrift的传输数据采用二进制格式，相比xml、json 体积更小，对于高并发、大数据量更有优势
  
  回复
milan111 2013 年 5 月 28 日在上午 10:22

非常感谢！受益匪浅！
您给出的例子都是java通信的，那如果我想用java调用nodejs或者nodejs调用java该怎么写呢？有类似的例子吗？

回复
- Michael 2013 年 5 月 30 日在上午 10:07
  
  这个目前没有例子的
  
  回复
qq663550185 2013 年 1 月 14 日在下午 7:00

请问在服务端有遇到过这种情况么？
Thrift error occurred during processing of message.
org.apache.thrift.TException: Message length exceeded: 2
at org.apache.thrift.protocol.TBinaryProtocol.checkReadLength(TBinaryProtocol.java:393)
at org.apache.thrift.protocol.TBinaryProtocol.readAll(TBinaryProtocol.java:377)
at org.apache.thrift.protocol.TBinaryProtocol.readI16(TBinaryProtocol.java:278)
at org.apache.thrift.protocol.TBinaryProtocol.readFieldBegin(TBinaryProtocol.java:229)

回复
- Michael 2013 年 1 月 14 日在下午 10:53
  
  没有遇到过的，看错误信息好像是消息读取时有问题
  
  回复
jose 2012 年 10 月 16 日在下午 5:24

请教一个问题
假如有2个service 如
HelloWorldService1
HelloWorldService2.

那么server端的code 如何写
System.out.println(“HelloWorld TNonblockingServer start ….”);
22

23
TProcessor tprocessor = new HelloWorldService.Processor(
24
new HelloWorldImpl());
25

26
TNonblockingServerSocket tnbSocketTransport = new TNonblockingServerSocket(
27
SERVER_PORT);
28
TNonblockingServer.Args tnbArgs = new TNonblockingServer.Args(
29
tnbSocketTransport);
30
tnbArgs.processor(tprocessor);
31
tnbArgs.transportFactory(new TFramedTransport.Factory());
32
tnbArgs.protocolFactory(new TCompactProtocol.Factory());
TServer server = new THsHaServer(thhsArgs);
40
server.serve();

这段代码是把 HelloWorldService 启动了，如何还想启动一个service 怎么办？

谢谢赐教！

回复
- Michael 2012 年 10 月 16 日在下午 6:09
  
  如果你想在一个port上起多个好像不行（我没有深入研究过），实在不行可以把两个service的接口合并成一个
  
  回复
jose 2012 年 10 月 16 日在下午 5:14

写的不错 😛

回复
dhpasa 2012 年 9 月 13 日在下午 2:51

可以啦接着看下去，呵呵。thank u

回复
dhpasa 2012 年 9 月 13 日在下午 2:37

生成代码具体是怎么实现的啊？看不明白 😥

回复
- Michael 2012 年 9 月 13 日在下午 2:48
  
  那一步没有看懂？我好想写得已经很详细了
  
  回复
程序娃娃 2012 年 6 月 27 日在下午 5:33

非常感谢

回复
- Michael 2012 年 6 月 28 日在上午 9:51
  
  🙂 以后可以多多交流
  
  回复

micmiu – 软件开发+生活点滴