thrift说明和测试

1下载：http://www.apache.org/dyn/closer.cgi?path=/thrift/0.9.2/thrift-0.9.2.exe
 

2 创建 ：demoHello.thrift 

namespace java xdg.luozhonghua.thrift.demo
service  HelloWorldService {
  string sayHello(1:string username)
}

3：命令：  E:\thrift>thrift -r -gen java ./demoHello.thrift

 

4：结果：          gen-java

目录：

  • 概述
  • 下载配置
  • 基本概念
    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

推荐值得一看的文章：

[二]、下载配置

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

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

XHTML

1

2

3

4

5

<dependency>

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

  <artifactId>libthrift</artifactId>

  <version>0.8.0</version>

</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 ,内容如下：

1

2

3

4

5

namespace
java
com.micmiu.thrift.demo

 

service  HelloWorldService
{

  string
sayHello(1:string
username)

}

目录结构如下：

1

2

3

4

5

6

7

8

9

G:\test\thrift&gt;tree /F

卷 other 的文件夹 PATH 列表

卷序列号为 D238-BE47

G:.

    demoHello.thrift

    demouser.thrift

    thrift-0.8.0.exe

 

没有子文件夹

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

1

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

生成后的目录结构如下：

1

2

3

4

5

6

7

8

9

10

11

12

13

14

G:\test\thrift&gt;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

1

2

3

4

5

6

7

8

9

10

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

2. 实现接口Iface

java代码：HelloWorldImpl.java

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

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

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

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&lt;HelloWorldService.Iface&gt;(

new
HelloWorldImpl());

//
HelloWorldService.Processor&lt;HelloWorldService.Iface&gt; tprocessor =

//
new HelloWorldService.Processor&lt;HelloWorldService.Iface&gt;(

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

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

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

HelloWorld
TSimpleServer
start
....

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

1

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

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

4.TThreadPoolServer 服务模型

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

编写服务端代码：HelloServerDemo.java

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

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&lt;HelloWorldService.Iface&gt;(

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代码和之前的一样，只要数据传输的协议一致即可，客户端测试成功，结果如下：

1

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

5.TNonblockingServer 服务模型

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

编写服务端代码：HelloServerDemo.java

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

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&lt;HelloWorldService.Iface&gt;(

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

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

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

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

6.THsHaServer服务模型

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

编写服务端代码：HelloServerDemo.java

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

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&lt;HelloWorldService.Iface&gt;(

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

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

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&lt;HelloWorldService.Iface&gt;(

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

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

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&lt;sayHello_call&gt; {

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

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/

时间： 2024-08-18 10:52:54

thrift说明和测试的相关文章

common-pool2 学习：thrift连接池的另一种实现

对象池是一种很实用的技术,经典的例子就是数据库连接池.去年曾经从零开始写过一个thrift客户端连接池.如果不想重造轮子,可以直接在apache开源项目commons-pool的基础上开发.  步骤: 一.定义对象工厂 package test.cn.mwee.service.paidui.pool; import org.apache.commons.pool2.BasePooledObjectFactory; import org.apache.commons.pool2.PooledObj

Protobuf 和 Thrift对比

Protobuf 和 Thrift 简介 google protobuf  Protocol buffers are Google's language-neutral, platform-neutral, extensible mechanism for serializing structured data – think XML, but smaller, faster, and simpler. You define how you want your data to be struct

基于thrift的微服务框架

前一阵开源过一个基于spring-boot的rest微服务框架,今天再来一篇基于thrift的微服务加框,thrift是啥就不多了,大家自行百度或参考我之前介绍thrift的文章, thrift不仅支持tcp/ip协议的rpc调用,也支持http协议的rest服务调用,同一个项目中甚至可同时支持这二种方式.thrift项目2007年由facebook开源以来,已经有无数成功的应用,完全可以基于这一框架来设计自己的服务架构,示意图如下: github上我开源了基于thrift的微服务框架,地址:h

Hive Metastore Thrift Server Partition的压力测试

测试环境: 虚拟机10.1.77.84 四核Intel(R) Xeon(R) CPU E5649  @ 2.53GHz,8G内存 起单台metastore server JVM args : -Xmx7000m -XX:ParallelGCThreads=8 -XX:+UseConcMarkSweepGC 测试表Schema: table name: metastore_stress_testing # col_name data_type comment a string None # Par

Apache Thrift入门（安装、测试与java程序编写）

安装Apache Thrift ubuntu linux运行: #!/bin/bash #下载 wget http://mirrors.cnnic.cn/apache/thrift/0.9.1/thrift-0.9.1.tar.gz tar zxvf thrift-0.9.1.tar.gz cd thrift-0.9.1.tar.gz ./configure make make install #编译java依赖包 cd lib/java ant 安装ubuntu依赖 sudo apt-get

thrift和java交互案例和结果

代码结构: 1>>>>>>  demoHello.thrift: namespace java xdg.luozhonghua.thrift.service /*  struct UserProfile { 1: i32 uid = 1, 2: string name = "User1", 3: string blurb, 4: list<i32> subNodeList,       5: map<i32,string> s

HBase Thrift接口的C++客户端

hbase-thrift项目是对HBase Thrift接口的封装,屏蔽底层的细节,使用户可以方便地通过HBase Thrift接口访问HBase集群,同时基于此对C++客户端读写的效率进行了简单的测试.该项目目前基于的是HBase thrift接口,至于HBase 0.94版本中的HBase thrift2接口,后续再考虑进一步的支持. 前提条件 1)下载,解压,安装 thrift-0.8.0. wget https://dist.apache.org/repos/dist/release/t

Thrift的TProtocol类体系原理及源码详解：稠密协议类TDenseProtocol

这个协议类不建议投入到实际的生产环境(除非自己做了很强的压力和全面的测试).这 个密集协议的最大作用就是尽可能使用小的空间,密集协议类有两种类型的实例对象,一种 是独立的,它不被使用在rpc通信中,而只是用于编码和解码:另一种是非独立的实例类型, 它可以用于rpc通信,不过现在还不支持这种类型的实例. 要使用这个密集协议类来 进行编码和解码必须支持Thrift自己实现的一直特殊的记录数据类型形式:就是type_spec属 性,它的主要作用就是用于本地化反射机制来进行读写数据. 最佳的实践方法如下

分布式测试框架架构与思考(1)奠基

"工欲善其事必先利其器".无论是哪个行业,这都是一句至理名言,软件测试当然也不例外.这也正是分布式测试框架(下文简称DST)设计的初衷. DST是海量数据项目背景下,为了解决测试集管理.运行.查询和测试执行.控制以及监控.日志数据的收集整理的一个通用型测试与分析平台.这个平台既包含了传统测试框架的特点也包含了自身的开创性思想.作为DST从前端界面到后端服务的亲身经历和开发者,下面我将从技术选型.架构设计.功能点分析.使用场景以及周边支持工具这几个角度来对DST测试平台做一个总结,进一步