`
luozhonghua2014
  • 浏览: 62454 次
文章分类
社区版块
存档分类
最新评论

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
serviceHelloWorldService {
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.

————




分享到：
| maven搭建多模块项目和管理
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    thrift环境搭建(内附thrift运行环境可执行程序、搭建说明文本)

    在本文中，我们将详细介绍如何搭建Thrift开发环境，并提供可执行程序和搭建说明文本。 1. **下载与安装** 首先，你需要从Thrift官方网站或Apache镜像站点下载适合你操作系统的最新版本的Thrift源代码包。解压后，...

    Windows下QT使用Thrift的样例

    通过学习和分析这个样例，开发者可以快速掌握在Windows环境下使用QT、Thrift和Boost进行服务开发的方法。 总之，这个样例项目提供了一个很好的起点，帮助开发者了解如何在Windows上用QT与Thrift协同工作，同时利用...

    一个Thrift的学习测试项目，服务器端实现从PLC进行采集数据，推送到Thrift，以接口的形式对外公开数据.zip

    本项目“一个Thrift的学习测试项目”是针对Thrift技术的一个实践应用，通过它我们可以深入理解Thrift的工作原理以及如何在实际项目中部署和使用。 首先，Thrift提供了一种定义服务接口的IDL（接口定义语言），允许...

    windows环境下thrift.exe的使用

    然后，你可以通过在命令行输入`thrift --version`来验证安装是否成功，如果能看到Thrift的版本信息，说明已经安装好了。 接下来，我们需要了解Thrift IDL（Interface Definition Language）。IDL文件通常以`.thrift...

    thrift 0.9.2

    - 文档：详细说明如何使用 Thrift，包括安装指南、API 参考和示例代码。 - 测试用例：用于验证 Thrift 的功能和性能。 通过这个压缩包，你可以开始学习和使用 Thrift 来构建自己的跨语言服务，体验其强大的序列化...

    CSS_namespace_thrift接口文档

    可能还涵盖了如何在实际编码过程中引用这些接口，以及如何测试和调试相关的Thrift服务。 总的来说，理解Thrift的命名空间对于有效地利用Thrift构建分布式系统至关重要。开发者需要了解如何在IDL中定义命名空间，...

    zookeeper + thrift实现的RPC 服务治理框架演示

    服务治理框架，一般存在与RPC的上一层，用来在大量RPC服务至上，协调客户端和服务器的调用工作。...相关的设计和代码说明，请参见我的博客。另外，工程已经测试过了，可以直接下载导入eclipse运行，您需要maven的支持。

    benchmarks:Protocol Buffers 和 Thrift 的基准测试

    如何运行基准测试克隆存储库： $ git clone $ cd benchmarks $ git submodule init $ git submodule update 按照此处的说明安装 Thrift 的依赖项： 构建并运行基准测试： $ mkdir build $ cd build $ cmake .....

    Learning Apache Thrift

    在实践环节，作者可能会详细解释如何在具体的应用场景中部署和运行Thrift服务，以及如何对Thrift服务进行测试和维护。 总之，《Learning Apache Thrift》是一本适合对分布式系统有兴趣的开发人员的实践指南，它不仅...

    C#通过thrift连接hbase操作步骤

    6. **验证连接**：最后，通过HBase的shell命令验证表数据，然后运行C#客户端，如果显示的数据与shell中查询的结果一致，说明C#通过Thrift成功连接到了HBase。 在实际操作中，需要注意的是，所有的IP地址、端口号、...

    光荣之路K神Selenium自动化测试框架开源代码

    总的来说，这个开源框架提供了一个全面的测试环境，涵盖了Web、移动应用和接口测试的关键领域，对于学习自动化测试和提升测试效率具有很高的参考价值。开发者可以通过研究和实践这些代码，深入理解Selenium的用法，...

    IF4031-Thrift-IRC

    6. `.travis.yml` 或 `appveyor.yml`：持续集成配置文件，用于自动化测试和构建。 通过这个项目，学习者可以深入理解分布式系统的设计，掌握Thrift框架的使用，以及如何处理网络协议如IRC。这不仅锻炼了编程能力，...

    ThriftTest.zip

    通过“ThriftTest”这个实例，我们可以学习如何设置Thrift服务，编写服务端和客户端代码，以及如何在实际环境中部署和测试Thrift应用程序。这对于理解Thrift的工作原理和提升跨语言服务开发能力非常有帮助。

    PATApacheThrift:使用Apache Thrift的简单聊天服务

    使用Apache Thrift的简单聊天服务 ＃由...制作： 约书亚（Joshua Bezaleel）Abednego（13512013） 穆罕默德·雷扎（Muhammad Reza Irvanda）（13512042） #Requires Java开发工具包1.8 ＃安装说明 打开您的IDE...

    talool-thrift-api:Talool 服务 API (WAR)

    Talool服务的具体功能和接口没有在标题和描述中详细说明，但通常包括数据的增删查改、业务逻辑处理等。开发者需要查阅源代码或者相关的文档来了解每个接口的用途和使用方式。 7. **性能优化**： 由于Thrift的高...

    基于springboot的thrift的rpc, 服务发现基于etcd，路由基于ribbon.zip

    可以用于毕业设计（项目源码+项目说明）目前在window10/11测试环境一切正常，用于演示的图片和部署教程说明都在压缩包里

    IRC-ApacheThrift:一个使用Apache Thrift基于RPC的简单IRC应用程序

    IF4031任务分布式应用程序开发“使用Apache Thrift的简单聊天应用程序” Hayyu'Luthfi Hanifah（13512080）Choirunnisa Fatima（13512084） ##安装/构建说明在每个项目根目录（ChatServer或ChatClient）上，运行...

    RPC调用框架比较分析

    - **protobuf-rpc-readme.txt** 提供了关于Protobuf RPC的使用说明和指南。 - **protobuf-rpc-pro-demo-1.1.0及源码.zip** 包含了一个基于Protobuf实现的RPC框架的示例项目和源代码，版本为1.1.0，可以帮助开发者...

    ThriftIRC:用Apache Thrift非常简单地实现类似IRC的程序

    用Apache Thrift非常简单地实现类似IRC的程序 生成说明：-使用NetBeans IDE打开项目-生成之前选择项目主文件（客户端或服务器）-生成程序 安装说明：-不适用 如何使用程序：-打开cmd / terminal并输入：java -jar ...

    Benchmark_zh-1.pdf

    Titan虽然提供了批量加载的建议和系统设置，但缺乏一个直接的原始文件到数据库加载的语言，因此需要借助其他技术如Cassandra Thrift来完成。 查询性能测试表明，TigerGraph在响应时间上对Neo4j和Titan具有显著的...

Magicbox
Global site tag (gtag.js) - Google Analytics