thrift教学java,Thrift入门及Java实例演示

最新推荐文章于 2023-07-19 15:01:39 发布
最新推荐文章于 2023-07-19 15:01:39 发布
阅读量524 收藏 1
点赞数
文章标签： thrift教学java

目录：

概述

下载配置

基本概念

数据类型

服务端编码基本步骤

客户端编码基本步骤

数据传输协议

实例演示(java)

thrift生成代码

实现接口Iface

TSimpleServer服务模型

TThreadPoolServer 服务模型

TNonblockingServer 服务模型

THsHaServer服务模型

异步客户端

[一]、概述

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客户端和服务器通信的无缝跨编程语言。

推荐值得一看的文章：

[二]、下载配置

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

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

XHTML

org.apache.thrift

libthrift

0.8.0

1

2

3

4

5

org.apache.thrift

libthrift

0.8.0

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)

}

1

2

3

4

5

namespacejavacom.micmiu.thrift.demo

serviceHelloWorldService{

stringsayHello(1:stringusername)

}

目录结构如下：

G:\test\thrift>tree /F

卷 other 的文件夹 PATH 列表

卷序列号为 D238-BE47

G:.

demoHello.thrift

demouser.thrift

thrift-0.8.0.exe

没有子文件夹

1

2

3

4

5

6

7

8

9

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-genjava./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

1

2

3

4

5

6

7

8

9

10

11

12

13

14

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中增加如下内容：

XHTML

org.apache.thrift

libthrift

0.8.0

org.slf4j

slf4j-log4j12

1.5.8

1

2

3

4

5

6

7

8

9

10

org.apache.thrift

libthrift

0.8.0

org.slf4j

slf4j-log4j12

1.5.8

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";

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

packagecom.micmiu.thrift.demo;

importorg.apache.thrift.TException;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloWorldImplimplementsHelloWorldService.Iface{

publicHelloWorldImpl(){

}

@Override

publicStringsayHello(Stringusername)throwsTException{

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(

new HelloWorldImpl());

// HelloWorldService.Processor tprocessor =

// new HelloWorldService.Processor(

// 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();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

packagecom.micmiu.thrift.demo;

importorg.apache.thrift.TProcessor;

importorg.apache.thrift.protocol.TBinaryProtocol;

importorg.apache.thrift.protocol.TCompactProtocol;

importorg.apache.thrift.protocol.TJSONProtocol;

importorg.apache.thrift.protocol.TSimpleJSONProtocol;

importorg.apache.thrift.server.TServer;

importorg.apache.thrift.server.TSimpleServer;

importorg.apache.thrift.transport.TServerSocket;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloServerDemo{

publicstaticfinalintSERVER_PORT=8090;

publicvoidstartServer(){

try{

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

TProcessortprocessor=newHelloWorldService.Processor(

newHelloWorldImpl());

// HelloWorldService.Processor tprocessor =

// new HelloWorldService.Processor(

// new HelloWorldImpl());

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

TServerSocketserverTransport=newTServerSocket(SERVER_PORT);

TServer.ArgstArgs=newTServer.Args(serverTransport);

tArgs.processor(tprocessor);

tArgs.protocolFactory(newTBinaryProtocol.Factory());

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

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

TServerserver=newTSimpleServer(tArgs);

server.serve();

}catch(Exceptione){

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

e.printStackTrace();

}

}

/**

* @param args

*/

publicstaticvoidmain(String[]args){

HelloServerDemoserver=newHelloServerDemo();

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");

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

packagecom.micmiu.thrift.demo;

importorg.apache.thrift.TException;

importorg.apache.thrift.protocol.TBinaryProtocol;

importorg.apache.thrift.protocol.TCompactProtocol;

importorg.apache.thrift.protocol.TJSONProtocol;

importorg.apache.thrift.protocol.TProtocol;

importorg.apache.thrift.transport.TSocket;

importorg.apache.thrift.transport.TTransport;

importorg.apache.thrift.transport.TTransportException;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloClientDemo{

publicstaticfinalStringSERVER_IP="localhost";

publicstaticfinalintSERVER_PORT=8090;

publicstaticfinalintTIMEOUT=30000;

/**

*

* @param userName

*/

publicvoidstartClient(StringuserName){

TTransporttransport=null;

try{

transport=newTSocket(SERVER_IP,SERVER_PORT,TIMEOUT);

// 协议要和服务端一致

TProtocolprotocol=newTBinaryProtocol(transport);

// TProtocol protocol = new TCompactProtocol(transport);

// TProtocol protocol = new TJSONProtocol(transport);

HelloWorldService.Clientclient=newHelloWorldService.Client(

protocol);

transport.open();

Stringresult=client.sayHello(userName);

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

}catch(TTransportExceptione){

e.printStackTrace();

}catch(TExceptione){

e.printStackTrace();

}finally{

if(null!=transport){

transport.close();

}

}

}

/**

* @param args

*/

publicstaticvoidmain(String[]args){

HelloClientDemoclient=newHelloClientDemo();

client.startClient("Michael");

}

}

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

HelloWorld TSimpleServer start ....

1

HelloWorldTSimpleServerstart....

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

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

1

Thrifyclientresult=:Hi,Michaelwelcometomyblogwww.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(

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();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

packagecom.micmiu.thrift.demo;

importorg.apache.thrift.TProcessor;

importorg.apache.thrift.protocol.TBinaryProtocol;

importorg.apache.thrift.server.TServer;

importorg.apache.thrift.server.TThreadPoolServer;

importorg.apache.thrift.transport.TServerSocket;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloServerDemo{

publicstaticfinalintSERVER_PORT=8090;

publicvoidstartServer(){

try{

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

TProcessortprocessor=newHelloWorldService.Processor(

newHelloWorldImpl());

TServerSocketserverTransport=newTServerSocket(SERVER_PORT);

TThreadPoolServer.ArgsttpsArgs=newTThreadPoolServer.Args(

serverTransport);

ttpsArgs.processor(tprocessor);

ttpsArgs.protocolFactory(newTBinaryProtocol.Factory());

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

TServerserver=newTThreadPoolServer(ttpsArgs);

server.serve();

}catch(Exceptione){

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

e.printStackTrace();

}

}

/**

* @param args

*/

publicstaticvoidmain(String[]args){

HelloServerDemoserver=newHelloServerDemo();

server.startServer();

}

}

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

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

1

Thrifyclientresult=:Hi,Michaelwelcometomyblogwww.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(

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();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

packagecom.micmiu.thrift.demo;

importorg.apache.thrift.TProcessor;

importorg.apache.thrift.protocol.TCompactProtocol;

importorg.apache.thrift.server.TNonblockingServer;

importorg.apache.thrift.server.TServer;

importorg.apache.thrift.transport.TFramedTransport;

importorg.apache.thrift.transport.TNonblockingServerSocket;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloServerDemo{

publicstaticfinalintSERVER_PORT=8090;

publicvoidstartServer(){

try{

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

TProcessortprocessor=newHelloWorldService.Processor(

newHelloWorldImpl());

TNonblockingServerSockettnbSocketTransport=newTNonblockingServerSocket(

SERVER_PORT);

TNonblockingServer.ArgstnbArgs=newTNonblockingServer.Args(

tnbSocketTransport);

tnbArgs.processor(tprocessor);

tnbArgs.transportFactory(newTFramedTransport.Factory());

tnbArgs.protocolFactory(newTCompactProtocol.Factory());

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

TServerserver=newTNonblockingServer(tnbArgs);

server.serve();

}catch(Exceptione){

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

e.printStackTrace();

}

}

/**

* @param args

*/

publicstaticvoidmain(String[]args){

HelloServerDemoserver=newHelloServerDemo();

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");

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

packagecom.micmiu.thrift.demo;

importorg.apache.thrift.TException;

importorg.apache.thrift.protocol.TCompactProtocol;

importorg.apache.thrift.protocol.TProtocol;

importorg.apache.thrift.transport.TFramedTransport;

importorg.apache.thrift.transport.TSocket;

importorg.apache.thrift.transport.TTransport;

importorg.apache.thrift.transport.TTransportException;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloClientDemo{

publicstaticfinalStringSERVER_IP="localhost";

publicstaticfinalintSERVER_PORT=8090;

publicstaticfinalintTIMEOUT=30000;

/**

*

* @param userName

*/

publicvoidstartClient(StringuserName){

TTransporttransport=null;

try{

transport=newTFramedTransport(newTSocket(SERVER_IP,

SERVER_PORT,TIMEOUT));

// 协议要和服务端一致

TProtocolprotocol=newTCompactProtocol(transport);

HelloWorldService.Clientclient=newHelloWorldService.Client(

protocol);

transport.open();

Stringresult=client.sayHello(userName);

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

}catch(TTransportExceptione){

e.printStackTrace();

}catch(TExceptione){

e.printStackTrace();

}finally{

if(null!=transport){

transport.close();

}

}

}

/**

* @param args

*/

publicstaticvoidmain(String[]args){

HelloClientDemoclient=newHelloClientDemo();

client.startClient("Michael");

}

}

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

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

1

Thrifyclientresult=:Hi,Michaelwelcometomyblogwww.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(

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();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

packagecom.micmiu.thrift.demo;

importorg.apache.thrift.TProcessor;

importorg.apache.thrift.protocol.TBinaryProtocol;

importorg.apache.thrift.protocol.TCompactProtocol;

importorg.apache.thrift.server.THsHaServer;

importorg.apache.thrift.server.TNonblockingServer;

importorg.apache.thrift.server.TServer;

importorg.apache.thrift.server.TSimpleServer;

importorg.apache.thrift.server.TThreadPoolServer;

importorg.apache.thrift.transport.TFramedTransport;

importorg.apache.thrift.transport.TNonblockingServerSocket;

importorg.apache.thrift.transport.TServerSocket;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloServerDemo{

publicstaticfinalintSERVER_PORT=8090;

publicvoidstartServer(){

try{

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

TProcessortprocessor=newHelloWorldService.Processor(

newHelloWorldImpl());

TNonblockingServerSockettnbSocketTransport=newTNonblockingServerSocket(

SERVER_PORT);

THsHaServer.ArgsthhsArgs=newTHsHaServer.Args(tnbSocketTransport);

thhsArgs.processor(tprocessor);

thhsArgs.transportFactory(newTFramedTransport.Factory());

thhsArgs.protocolFactory(newTBinaryProtocol.Factory());

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

TServerserver=newTHsHaServer(thhsArgs);

server.serve();

}catch(Exceptione){

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

e.printStackTrace();

}

}

/**

* @param args

*/

publicstaticvoidmain(String[]args){

HelloServerDemoserver=newHelloServerDemo();

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(

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();

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

packagecom.micmiu.thrift.demo;

importorg.apache.thrift.TProcessor;

importorg.apache.thrift.protocol.TCompactProtocol;

importorg.apache.thrift.server.TNonblockingServer;

importorg.apache.thrift.server.TServer;

importorg.apache.thrift.transport.TFramedTransport;

importorg.apache.thrift.transport.TNonblockingServerSocket;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloServerDemo{

publicstaticfinalintSERVER_PORT=8090;

publicvoidstartServer(){

try{

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

TProcessortprocessor=newHelloWorldService.Processor(

newHelloWorldImpl());

TNonblockingServerSockettnbSocketTransport=newTNonblockingServerSocket(

SERVER_PORT);

TNonblockingServer.ArgstnbArgs=newTNonblockingServer.Args(

tnbSocketTransport);

tnbArgs.processor(tprocessor);

tnbArgs.transportFactory(newTFramedTransport.Factory());

tnbArgs.protocolFactory(newTCompactProtocol.Factory());

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

TServerserver=newTNonblockingServer(tnbArgs);

server.serve();

}catch(Exceptione){

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

e.printStackTrace();

}

}

/**

* @param args

*/

publicstaticvoidmain(String[]args){

HelloServerDemoserver=newHelloServerDemo();

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 {

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");

}

}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

packagecom.micmiu.thrift.demo;

importjava.util.concurrent.CountDownLatch;

importjava.util.concurrent.TimeUnit;

importorg.apache.thrift.TException;

importorg.apache.thrift.async.AsyncMethodCallback;

importorg.apache.thrift.async.TAsyncClientManager;

importorg.apache.thrift.protocol.TCompactProtocol;

importorg.apache.thrift.protocol.TProtocolFactory;

importorg.apache.thrift.transport.TNonblockingSocket;

importorg.apache.thrift.transport.TNonblockingTransport;

importcom.micmiu.thrift.demo.HelloWorldService.AsyncClient.sayHello_call;

/**

* blog http://www.micmiu.com

*

* @author Michael

*

*/

publicclassHelloAsynClientDemo{

publicstaticfinalStringSERVER_IP="localhost";

publicstaticfinalintSERVER_PORT=8090;

publicstaticfinalintTIMEOUT=30000;

/**

*

* @param userName

*/

publicvoidstartClient(StringuserName){

try{

TAsyncClientManagerclientManager=newTAsyncClientManager();

TNonblockingTransporttransport=newTNonblockingSocket(SERVER_IP,

SERVER_PORT,TIMEOUT);

TProtocolFactorytprotocol=newTCompactProtocol.Factory();

HelloWorldService.AsyncClientasyncClient=newHelloWorldService.AsyncClient(

tprotocol,clientManager,transport);

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

CountDownLatchlatch=newCountDownLatch(1);

AsynCallbackcallBack=newAsynCallback(latch);

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

asyncClient.sayHello(userName,callBack);

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

booleanwait=latch.await(30,TimeUnit.SECONDS);

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

}catch(Exceptione){

e.printStackTrace();

}

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

}

publicclassAsynCallbackimplementsAsyncMethodCallback{

privateCountDownLatchlatch;

publicAsynCallback(CountDownLatchlatch){

this.latch=latch;

}

@Override

publicvoidonComplete(sayHello_callresponse){

System.out.println("onComplete");

try{

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

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

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

}catch(TExceptione){

e.printStackTrace();

}catch(Exceptione){

e.printStackTrace();

}finally{

latch.countDown();

}

}

@Override

publicvoidonError(Exceptionexception){

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

latch.countDown();

}

}

/**

* @param args

*/

publicstaticvoidmain(String[]args){

HelloAsynClientDemoclient=newHelloAsynClientDemo();

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.

1

2

3

4

5

6

7

Clientstart.....

callmethodsayHellostart...

callmethodsayHello....end

onComplete

AsynCallresult=:Hi,Michaelwelcometomyblogwww.micmiu.com

latch.await=:true

startClientend.

————

卜卜卜布补
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
thrift 架构的Java的小例子 demo
07-31
此文件为自己在Mac电脑上写的thrift的demo，使用maven 管理了小程序，并用thrift生成了源码，其中对thrift生成的源码，把override注销了，其他的没处理，如果感兴趣参考博客：https://www.cnblogs.com/aspirant/p/9391714.html
thrift 教程
u012049463的专栏
09-29 3915
thrift开发教程编写thrift文件srifut.thrift:  namespace java  com.unj.srifut service SrifutService{ string testCase1(1:i32 id,2:string name); void testCase2(1:i32 id,2:string name,3:string password); }     stru
Java中使用Thrift
Hanhahahahah的博客
07-19 1218
需要注意的是，transport 客户端要和服务端对应，比如如果要对 NIO 模型的服务端进行调研，transport 就必须使用 TFramedTransport或TFastFramedTransport。业务代码中只需要注入 SimpleService.Iface，并直接调用接口方法，而完全不需要关注内部逻辑实现。通过 thrift compiler 生成 java 代码。client端可以直接调用接口，二不用关心具体的实现类。之后将相应的 Iface 注册到 IOC 容器中即可。
thrift初探(java)（—）
ccoran的博客
02-27 219
1 介绍 thrift一个RPC框架，可以用来远程通信 2 生成接口代码 1.下载thrift，thrift-0.10.0.exe 2.将编写的hello.thrift文件，放置在和下载好的thrift-0.10.0.exe同一个目录之下， 然后执行如下操作即可产生相关代码~ thrift文件的相关规范见 https://blog.csdn.net/finallygo/article/detai...
Thrift之java实例
深之JohnChen的专栏
07-04 1077
Thrift之java实例
Thrift入门及Java实例演示
02-07
Thrift入门及Java实例演示,文档及java演示源代码。包括thrift-0.11.0.exe
Java thrift服务器和客户端创建实例代码
08-30
Thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。接下来通过本文给大家介绍Java thrift服务器和客户端创建实例代码，需要的朋友参考下吧
Java通过Thrift框架实现通讯的示例代码
最新发布
09-05
技术分享：Java通过Thrift框架实现通讯的示例代码
thrift 的 java 和 python结合例子
02-06
一个java和python的thrift例子，其中java作为服务端，python作为客户端
thrift开发入门java程序
12-26
Thrift作为可伸缩的跨语言服务开发框架，网上的资源较少，这里是一个简单的入门小程序，文件中的mylib下包含了依赖的jar包，并且在file目录下放了一个简单的thrift文件和生成thrift-0.9.0.exe工具，直接使用 thrift-...
采用java操作thrift代码示例
03-24
采用java操作thrift代码示例
java thrift使用指南_Thrift使用指南
weixin_26717737的博客
02-16 1133
1. 内容概要本文档比较全面的介绍了thrift(关于thrift框架的介绍，参考我这篇文章：Thrift框架介绍)语法，代码生成结构和应用经验。本文主要讲述的对象是thrift文件，并未涉及其client和server的编写方法(关于client和server的编写方法，可参考我这篇文章：使用ThriftRPC编写程序)。2. 语法参考2.1 TypesThrift类型系统包括预定义基本类型，用...
Thrift使用教程（Java版本）
wuxiaopengnihao1的博客
07-24 3918
Thrift是一个跨语言的服务部署框架，最初由Facebook于2007年开发，2008年进入Apache开源项目。Thrift通过一个中间语言(IDL,接口定义语言)来定义RPC的接口和数据类型，然后通过一个编译器生成不同语言的代码（目前支持C++,Java,Python,PHP,Ruby,Erlang,Perl,Haskell,C#,Cocoa,Smalltalk和OCaml）,并由生成的代码负责RPC协议层和传输层的实现。并由生成的代码负责RPC协议层和传输层的实现。...
Thrift框架入门（Java）
qq_42031483的博客
10-09 3195
定义 Thrift框架是什么？ 答：thrift是二进制的高性能的通讯中间件，支持数据(对象)序列化和多种类型的RPC服务。 Thrift框架解决了什么问题？ 答：它提供了一套解决方案，可以解决各系统间大数据量的传输通信以及系统之间语言环境不同，需要跨平台的问题。 Thrift的特点是什么？ 答： Thrift是一个服务端和客户端的架构体系；需要你在系统中搭建好通信双方的接口逻辑。 Thrift 具有自己内部定义的传输协议规范(TProtocol)和传输数据标准(TTransports)， Thrif
Thrift入门初探--thrift安装及java入门实例
weixin_34391445的博客
02-21 158
　　公司的一些平台服务框架底层封装了thrift提供服务,最近项目不是很紧,于是研究了一下,刚刚入门,理解得不深,写这篇博文来整理一下思路. 什么是thrift? 　　简单来说,是Facebook公布的一款开源跨语言的RPC框架. 　　那么问题来了. 　　什么是RPC框架? 　　　　RPC全称为Remote Procedure Call,意为远程过程调用. 　　　　假设有两台服务器A,B.A服务器...
thrift的安装和Java编写thrift
u014515854的博客
12-03 1383
一、Thrift的安装（MAC）1、安装Homebrew/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"注意 关于最新版mac(OSX High Sierra 10.13 )/usr/local权限问题，请看如何关掉SIP。安装好后运行:brew u
thrift java实例_精选实例：Thrift 实例教程（Java）
weixin_39647471的博客
02-22 535
一、 About Thriftthrift 是一种可伸缩的跨语言服务的发展软件框架。它结合了功能强大的软件堆栈的代码生成引擎，以建设服务，工作效率和无缝地与 C + +，C#，Java，Python，PHP 和 Ruby 结合。thrift 是 facebook 开发的，我们现在把它作为开源软件使用。thrift 允许你定义一个简单的定义文件中的数据类型和服务接口。以作为输入文件，编译器生成代码用...
Thrift基础教程
小识的博客
03-28 1373
下载 LZ下载的是windows版本，只有一个exe文件，LZ重命名为thritf.exe，可以将exe文件所在的路径加入到环境变量中，这样在命令行中直接就可可以运行thrift这个命令，LZ没有配置，所以每次跑到exe所在的文件运行这个命令，最后直接写了个脚本，省得每次用命令行，只要点这个脚本就能运行 @echo off D:\thrift\thrift -v --gen java --...
java thrift_Thrift入门及Java实例演示【转】
weixin_42171208的博客
02-24 295
概述Thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引擎，以构建在 C++、Java、Python、PHP、Ruby、Erlang、Perl、Haskell、C#、Cocoa、JavaScript、Node.js、Smalltalk、and OCaml 等等编程语言间无缝结合的、高效的服务。Thrift最初由facebook开发，07年四月开放源...
thrift java 实例
06-01
好的，以下是一个简单的 Thrift Java 实例，展示了如何使用 Thrift 进行跨语言通信。 1. 编写 Thrift IDL 文件 定义一个 Thrift 接口，使用 Thrift IDL 语言编写一个服务接口文件，例如 Example.thrift： ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值