`
wbj0110
  • 浏览: 1602649 次
  • 性别: Icon_minigender_1
  • 来自: 上海
文章分类
社区版块
存档分类
最新评论

Thrift入门及Java实例演示

ThriftJavarpc 
阅读更多

目录：

  • 概述
  • 下载配置
  • 基本概念
  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 中添加如下内容：

    1 <dependency>
    2   <groupId>org.apache.thrift</groupId>
    3   <artifactId>libthrift</artifactId>
    4   <version>0.8.0</version>
    5 </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 namespace java com.micmiu.thrift.demo
    2  
    3 service  HelloWorldService {
    4   string sayHello(1:string username)
    5 }

    目录结构如下：

    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下编译工具，运用这个工具生成相关代码：

    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

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

    1 <dependency>
    2     <groupId>org.apache.thrift</groupId>
    3     <artifactId>libthrift</artifactId>
    4     <version>0.8.0</version>
    5 </dependency>
    6 <dependency>
    7     <groupId>org.slf4j</groupId>
    8     <artifactId>slf4j-log4j12</artifactId>
    9     <version>1.5.8</version>
    10 </dependency>

    2. 实现接口Iface

    java代码：HelloWorldImpl.java

    1 package com.micmiu.thrift.demo;
    2  
    3 import org.apache.thrift.TException;
    4  
    5 /**
    6  * blog http://www.micmiu.com
    7  *
    8  * @author Michael
    9  *
    10  */
    11 public class HelloWorldImpl implements HelloWorldService.Iface {
    12  
    13     public HelloWorldImpl() {
    14     }
    15  
    16     @Override
    17     public String sayHello(String username) throws TException {
    18         return "Hi," + username + " welcome to my blog www.micmiu.com";
    19     }
    20  
    21 }

    3.TSimpleServer服务端

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

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

    1 package com.micmiu.thrift.demo;
    2  
    3 import org.apache.thrift.TProcessor;
    4 import org.apache.thrift.protocol.TBinaryProtocol;
    5 import org.apache.thrift.protocol.TCompactProtocol;
    6 import org.apache.thrift.protocol.TJSONProtocol;
    7 import org.apache.thrift.protocol.TSimpleJSONProtocol;
    8 import org.apache.thrift.server.TServer;
    9 import org.apache.thrift.server.TSimpleServer;
    10 import org.apache.thrift.transport.TServerSocket;
    11  
    12 /**
    13  * blog http://www.micmiu.com
    14  *
    15  * @author Michael
    16  *
    17  */
    18 public class HelloServerDemo {
    19     public static final int SERVER_PORT = 8090;
    20  
    21     public void startServer() {
    22         try {
    23             System.out.println("HelloWorld TSimpleServer start ....");
    24  
    25             TProcessor tprocessor = newHelloWorldService.Processor<HelloWorldService.Iface>(
    26                     new HelloWorldImpl());
    27             // HelloWorldService.Processor<HelloWorldService.Iface> tprocessor =
    28             // new HelloWorldService.Processor<HelloWorldService.Iface>(
    29             // new HelloWorldImpl());
    30  
    31             // 简单的单线程服务模型，一般用于测试
    32             TServerSocket serverTransport = newTServerSocket(SERVER_PORT);
    33             TServer.Args tArgs = new TServer.Args(serverTransport);
    34             tArgs.processor(tprocessor);
    35             tArgs.protocolFactory(new TBinaryProtocol.Factory());
    36             // tArgs.protocolFactory(new TCompactProtocol.Factory());
    37             // tArgs.protocolFactory(new TJSONProtocol.Factory());
    38             TServer server = new TSimpleServer(tArgs);
    39             server.serve();
    40  
    41         } catch (Exception e) {
    42             System.out.println("Server start error!!!");
    43             e.printStackTrace();
    44         }
    45     }
    46  
    47     /**
    48      * @param args
    49      */
    50     public static void main(String[] args) {
    51         HelloServerDemo server = new HelloServerDemo();
    52         server.startServer();
    53     }
    54  
    55 }

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

    1 package com.micmiu.thrift.demo;
    2  
    3 import org.apache.thrift.TException;
    4 import org.apache.thrift.protocol.TBinaryProtocol;
    5 import org.apache.thrift.protocol.TCompactProtocol;
    6 import org.apache.thrift.protocol.TJSONProtocol;
    7 import org.apache.thrift.protocol.TProtocol;
    8 import org.apache.thrift.transport.TSocket;
    9 import org.apache.thrift.transport.TTransport;
    10 import org.apache.thrift.transport.TTransportException;
    11  
    12 /**
    13  * blog http://www.micmiu.com
    14  *
    15  * @author Michael
    16  *
    17  */
    18 public class HelloClientDemo {
    19  
    20     public static final String SERVER_IP = "localhost";
    21     public static final int SERVER_PORT = 8090;
    22     public static final int TIMEOUT = 30000;
    23  
    24     /**
    25      *
    26      * @param userName
    27      */
    28     public void startClient(String userName) {
    29         TTransport transport = null;
    30         try {
    31             transport = new TSocket(SERVER_IP, SERVER_PORT, TIMEOUT);
    32             // 协议要和服务端一致
    33             TProtocol protocol = new TBinaryProtocol(transport);
    34             // TProtocol protocol = new TCompactProtocol(transport);
    35             // TProtocol protocol = new TJSONProtocol(transport);
    36             HelloWorldService.Client client = newHelloWorldService.Client(
    37                     protocol);
    38             transport.open();
    39             String result = client.sayHello(userName);
    40             System.out.println("Thrify client result =: " + result);
    41         } catch (TTransportException e) {
    42             e.printStackTrace();
    43         } catch (TException e) {
    44             e.printStackTrace();
    45         } finally {
    46             if (null != transport) {
    47                 transport.close();
    48             }
    49         }
    50     }
    51  
    52     /**
    53      * @param args
    54      */
    55     public static void main(String[] args) {
    56         HelloClientDemo client = new HelloClientDemo();
    57         client.startClient("Michael");
    58  
    59     }
    60  
    61 }

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

    HelloWorld TSimpleServer start ....

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

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

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

    4.TThreadPoolServer 服务模型

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

    编写服务端代码：HelloServerDemo.java

    1 package com.micmiu.thrift.demo;
    2  
    3 import org.apache.thrift.TProcessor;
    4 import org.apache.thrift.protocol.TBinaryProtocol;
    5 import org.apache.thrift.server.TServer;
    6 import org.apache.thrift.server.TThreadPoolServer;
    7 import org.apache.thrift.transport.TServerSocket;
    8  
    9 /**
    10  * blog http://www.micmiu.com
    11  *
    12  * @author Michael
    13  *
    14  */
    15 public class HelloServerDemo {
    16     public static final int SERVER_PORT = 8090;
    17  
    18     public void startServer() {
    19         try {
    20             System.out.println("HelloWorld TThreadPoolServer start ....");
    21  
    22             TProcessor tprocessor = newHelloWorldService.Processor<HelloWorldService.Iface>(
    23                     new HelloWorldImpl());
    24  
    25              TServerSocket serverTransport = newTServerSocket(SERVER_PORT);
    26              TThreadPoolServer.Args ttpsArgs = newTThreadPoolServer.Args(
    27              serverTransport);
    28              ttpsArgs.processor(tprocessor);
    29              ttpsArgs.protocolFactory(new TBinaryProtocol.Factory());
    30  
    31             // 线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求。
    32              TServer server = new TThreadPoolServer(ttpsArgs);
    33              server.serve();
    34  
    35         } catch (Exception e) {
    36             System.out.println("Server start error!!!");
    37             e.printStackTrace();
    38         }
    39     }
    40  
    41     /**
    42      * @param args
    43      */
    44     public static void main(String[] args) {
    45         HelloServerDemo server = new HelloServerDemo();
    46         server.startServer();
    47     }
    48  
    49 }

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

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

    5.TNonblockingServer 服务模型

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

    编写服务端代码：HelloServerDemo.java

    1 package com.micmiu.thrift.demo;
    2  
    3 import org.apache.thrift.TProcessor;
    4 import org.apache.thrift.protocol.TCompactProtocol;
    5 import org.apache.thrift.server.TNonblockingServer;
    6 import org.apache.thrift.server.TServer;
    7 import org.apache.thrift.transport.TFramedTransport;
    8 import org.apache.thrift.transport.TNonblockingServerSocket;
    9  
    10 /**
    11  * blog http://www.micmiu.com
    12  *
    13  * @author Michael
    14  *
    15  */
    16 public class HelloServerDemo {
    17     public static final int SERVER_PORT = 8090;
    18  
    19     public void startServer() {
    20         try {
    21             System.out.println("HelloWorld TNonblockingServer start ....");
    22  
    23             TProcessor tprocessor = newHelloWorldService.Processor<HelloWorldService.Iface>(
    24                     new HelloWorldImpl());
    25  
    26             TNonblockingServerSocket tnbSocketTransport = newTNonblockingServerSocket(
    27                     SERVER_PORT);
    28             TNonblockingServer.Args tnbArgs = newTNonblockingServer.Args(
    29                     tnbSocketTransport);
    30             tnbArgs.processor(tprocessor);
    31             tnbArgs.transportFactory(new TFramedTransport.Factory());
    32             tnbArgs.protocolFactory(new TCompactProtocol.Factory());
    33  
    34             // 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式
    35             TServer server = new TNonblockingServer(tnbArgs);
    36             server.serve();
    37  
    38         } catch (Exception e) {
    39             System.out.println("Server start error!!!");
    40             e.printStackTrace();
    41         }
    42     }
    43  
    44     /**
    45      * @param args
    46      */
    47     public static void main(String[] args) {
    48         HelloServerDemo server = new HelloServerDemo();
    49         server.startServer();
    50     }
    51  
    52 }

    编写客户端代码：HelloClientDemo.java

    1 package com.micmiu.thrift.demo;
    2  
    3 import org.apache.thrift.TException;
    4 import org.apache.thrift.protocol.TCompactProtocol;
    5 import org.apache.thrift.protocol.TProtocol;
    6 import org.apache.thrift.transport.TFramedTransport;
    7 import org.apache.thrift.transport.TSocket;
    8 import org.apache.thrift.transport.TTransport;
    9 import org.apache.thrift.transport.TTransportException;
    10  
    11 /**
    12  * blog http://www.micmiu.com
    13  *
    14  * @author Michael
    15  *
    16  */
    17 public class HelloClientDemo {
    18  
    19     public static final String SERVER_IP = "localhost";
    20     public static final int SERVER_PORT = 8090;
    21     public static final int TIMEOUT = 30000;
    22  
    23     /**
    24      *
    25      * @param userName
    26      */
    27     public void startClient(String userName) {
    28         TTransport transport = null;
    29         try {
    30             transport = new TFramedTransport(new TSocket(SERVER_IP,
    31                     SERVER_PORT, TIMEOUT));
    32             // 协议要和服务端一致
    33             TProtocol protocol = new TCompactProtocol(transport);
    34             HelloWorldService.Client client = newHelloWorldService.Client(
    35                     protocol);
    36             transport.open();
    37             String result = client.sayHello(userName);
    38             System.out.println("Thrify client result =: " + result);
    39         } catch (TTransportException e) {
    40             e.printStackTrace();
    41         } catch (TException e) {
    42             e.printStackTrace();
    43         } finally {
    44             if (null != transport) {
    45                 transport.close();
    46             }
    47         }
    48     }
    49  
    50     /**
    51      * @param args
    52      */
    53     public static void main(String[] args) {
    54         HelloClientDemo client = new HelloClientDemo();
    55         client.startClient("Michael");
    56  
    57     }
    58  
    59 }

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

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

    6.THsHaServer服务模型

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

    编写服务端代码：HelloServerDemo.java

    1 package com.micmiu.thrift.demo;
    2  
    3 import org.apache.thrift.TProcessor;
    4 import org.apache.thrift.protocol.TBinaryProtocol;
    5 import org.apache.thrift.protocol.TCompactProtocol;
    6 import org.apache.thrift.server.THsHaServer;
    7 import org.apache.thrift.server.TNonblockingServer;
    8 import org.apache.thrift.server.TServer;
    9 import org.apache.thrift.server.TSimpleServer;
    10 import org.apache.thrift.server.TThreadPoolServer;
    11 import org.apache.thrift.transport.TFramedTransport;
    12 import org.apache.thrift.transport.TNonblockingServerSocket;
    13 import org.apache.thrift.transport.TServerSocket;
    14  
    15 /**
    16  * blog http://www.micmiu.com
    17  *
    18  * @author Michael
    19  *
    20  */
    21 public class HelloServerDemo {
    22     public static final int SERVER_PORT = 8090;
    23  
    24     public void startServer() {
    25         try {
    26             System.out.println("HelloWorld THsHaServer start ....");
    27  
    28             TProcessor tprocessor = newHelloWorldService.Processor<HelloWorldService.Iface>(
    29                     new HelloWorldImpl());
    30  
    31             TNonblockingServerSocket tnbSocketTransport = newTNonblockingServerSocket(
    32                     SERVER_PORT);
    33             THsHaServer.Args thhsArgs = newTHsHaServer.Args(tnbSocketTransport);
    34             thhsArgs.processor(tprocessor);
    35             thhsArgs.transportFactory(new TFramedTransport.Factory());
    36             thhsArgs.protocolFactory(new TBinaryProtocol.Factory());
    37  
    38             //半同步半异步的服务模型
    39             TServer server = new THsHaServer(thhsArgs);
    40             server.serve();
    41  
    42         } catch (Exception e) {
    43             System.out.println("Server start error!!!");
    44             e.printStackTrace();
    45         }
    46     }
    47  
    48     /**
    49      * @param args
    50      */
    51     public static void main(String[] args) {
    52         HelloServerDemo server = new HelloServerDemo();
    53         server.startServer();
    54     }
    55  
    56 }

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

    7.异步客户端

    编写服务端代码：HelloServerDemo.java

    1 package com.micmiu.thrift.demo;
    2  
    3 import org.apache.thrift.TProcessor;
    4 import org.apache.thrift.protocol.TCompactProtocol;
    5 import org.apache.thrift.server.TNonblockingServer;
    6 import org.apache.thrift.server.TServer;
    7 import org.apache.thrift.transport.TFramedTransport;
    8 import org.apache.thrift.transport.TNonblockingServerSocket;
    9  
    10 /**
    11  * blog http://www.micmiu.com
    12  *
    13  * @author Michael
    14  *
    15  */
    16 public class HelloServerDemo {
    17     public static final int SERVER_PORT = 8090;
    18  
    19     public void startServer() {
    20         try {
    21             System.out.println("HelloWorld TNonblockingServer start ....");
    22  
    23             TProcessor tprocessor = newHelloWorldService.Processor<HelloWorldService.Iface>(
    24                     new HelloWorldImpl());
    25  
    26             TNonblockingServerSocket tnbSocketTransport = newTNonblockingServerSocket(
    27                     SERVER_PORT);
    28             TNonblockingServer.Args tnbArgs = newTNonblockingServer.Args(
    29                     tnbSocketTransport);
    30             tnbArgs.processor(tprocessor);
    31             tnbArgs.transportFactory(new TFramedTransport.Factory());
    32             tnbArgs.protocolFactory(new TCompactProtocol.Factory());
    33  
    34             // 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式
    35             TServer server = new TNonblockingServer(tnbArgs);
    36             server.serve();
    37  
    38         } catch (Exception e) {
    39             System.out.println("Server start error!!!");
    40             e.printStackTrace();
    41         }
    42     }
    43  
    44     /**
    45      * @param args
    46      */
    47     public static void main(String[] args) {
    48         HelloServerDemo server = new HelloServerDemo();
    49         server.startServer();
    50     }
    51  
    52 }

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

    1 package com.micmiu.thrift.demo;
    2  
    3 import java.util.concurrent.CountDownLatch;
    4 import java.util.concurrent.TimeUnit;
    5  
    6 import org.apache.thrift.TException;
    7 import org.apache.thrift.async.AsyncMethodCallback;
    8 import org.apache.thrift.async.TAsyncClientManager;
    9 import org.apache.thrift.protocol.TCompactProtocol;
    10 import org.apache.thrift.protocol.TProtocolFactory;
    11 import org.apache.thrift.transport.TNonblockingSocket;
    12 import org.apache.thrift.transport.TNonblockingTransport;
    13  
    14 importcom.micmiu.thrift.demo.HelloWorldService.AsyncClient.sayHello_call;
    15  
    16 /**
    17  * blog http://www.micmiu.com
    18  *
    19  * @author Michael
    20  *
    21  */
    22 public class HelloAsynClientDemo {
    23  
    24     public static final String SERVER_IP = "localhost";
    25     public static final int SERVER_PORT = 8090;
    26     public static final int TIMEOUT = 30000;
    27  
    28     /**
    29      *
    30      * @param userName
    31      */
    32     public void startClient(String userName) {
    33         try {
    34             TAsyncClientManager clientManager = newTAsyncClientManager();
    35             TNonblockingTransport transport = newTNonblockingSocket(SERVER_IP,
    36                     SERVER_PORT, TIMEOUT);
    37  
    38             TProtocolFactory tprotocol = newTCompactProtocol.Factory();
    39             HelloWorldService.AsyncClient asyncClient = newHelloWorldService.AsyncClient(
    40                     tprotocol, clientManager, transport);
    41             System.out.println("Client start .....");
    42  
    43             CountDownLatch latch = new CountDownLatch(1);
    44             AsynCallback callBack = new AsynCallback(latch);
    45             System.out.println("call method sayHello start ...");
    46             asyncClient.sayHello(userName, callBack);
    47             System.out.println("call method sayHello .... end");
    48             boolean wait = latch.await(30, TimeUnit.SECONDS);
    49             System.out.println("latch.await =:" + wait);
    50         } catch (Exception e) {
    51             e.printStackTrace();
    52         }
    53         System.out.println("startClient end.");
    54     }
    55  
    56     public class AsynCallback implementsAsyncMethodCallback<sayHello_call> {
    57         private CountDownLatch latch;
    58  
    59         public AsynCallback(CountDownLatch latch) {
    60             this.latch = latch;
    61         }
    62  
    63         @Override
    64         public void onComplete(sayHello_call response) {
    65             System.out.println("onComplete");
    66             try {
    67                 // Thread.sleep(1000L * 1);
    68                 System.out.println("AsynCall result =:"
    69                         + response.getResult().toString());
    70             } catch (TException e) {
    71                 e.printStackTrace();
    72             } catch (Exception e) {
    73                 e.printStackTrace();
    74             } finally {
    75                 latch.countDown();
    76             }
    77         }
    78  
    79         @Override
    80         public void onError(Exception exception) {
    81             System.out.println("onError :" + exception.getMessage());
    82             latch.countDown();
    83         }
    84     }
    85  
    86     /**
    87      * @param args
    88      */
    89     public static void main(String[] args) {
    90         HelloAsynClientDemo client = new HelloAsynClientDemo();
    91         client.startClient("Michael");
    92  
    93     }
    94  
    95 }

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

    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.

    ————

    分享到：
    | Ubuntu 13.10 thrift-0.9.1 安装
    评论
    发表评论

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

    相关推荐

      thrift + 服务模型实例演示（java）

      主要是对thrift0.9.0 TSimpleServer、TThreadPoolServer 、TNonblockingServer、THsHaServer等服务模型实例和AsynClient 异步客户端实例代码的演示

      thrift开发入门java程序

      Thrift作为可伸缩的跨语言服务开发框架，网上的资源较少，这里是一个简单的入门小程序，文件中的mylib下包含了依赖的jar包，并且在file目录下放了一个简单的thrift文件和生成thrift-0.9.0.exe工具，直接使用 thrift-...

      Java Thrift demo例子

      在客户端，同样使用生成的Java代码，创建`ThriftService.Client`实例，通过`TTransport`连接到服务器，调用服务方法。例如： ```java public static void main(String[] args) throws Exception { TTransport ...

      Thrift－java学习小结

      本文将基于Thrift的Java实现，总结学习过程中的一些关键知识点，旨在帮助理解Thrift的工作原理以及如何在Java环境中应用。 一、Thrift简介 Thrift是一种远程过程调用（RPC）框架，它通过定义一种中间描述文件（....

      thrift－java实例

      Thrift 是一种跨平台的通信框架，由 Facebook 在 2007 年开源，用于解决大规模系统中不同语言环境下的高效数据传输问题。Thrift 支持多种编程语言，如 C++, Java, PHP, Python 等，使得在这些语言之间进行数据交换变...

      thrift入门学习教程

      ### Thrift入门学习教程 #### 一、Thrift概述 Thrift是由Facebook开发并在2007年贡献给Apache基金会的一款开源项目。它的主要目的是解决跨平台、跨语言的系统间大数据量传输通信问题。在早期，Facebook面临着系统...

      thrift入门教程+代码

      例如，对于Java，Thrift会生成`Iface`、`Processor`、`Client`和`Server`接口及类，开发者只需实现`Iface`接口。 5. 客户端与服务器通信：客户端使用生成的客户端代码来创建服务代理，通过代理调用服务方法。服务器...

      基于thrift的RPC调用实例

      RPC（远程过程调用）是一种在...在本例中，我们展示了如何使用Thrift在Java和PHP之间进行RPC调用，通过简单的`sayHello`方法来演示其工作原理。通过深入理解和实践，Thrift可以成为构建大型分布式系统中的强大工具。

      thrift 生成的java包 全部的

      在给定的压缩包文件中，包含了一系列与 Thrift 相关的 Java 包，这将有助于构建基于 Thrift 的分布式系统。 1. **Thrift IDL**: Thrift Interface Definition Language 是一种类似 protobuf 的语言，用于定义服务...

      Thrift双向通讯java代码

      在"Thrift双向通讯java代码"这个主题中，我们主要讨论如何使用Thrift在Java环境中实现客户端和服务器端的双向通信。双向通信意味着服务器和客户端都可以向对方发送请求并接收响应，这对于构建复杂的分布式系统至关...

      thrift 的 java 和 python结合例子

      在这个"thrift的java和python结合例子"中，我们将探讨如何使用Thrift在Java和Python之间建立通信。 首先，Thrift通过定义接口描述文件（.thrift）来规范服务的接口。这个文件使用Thrift IDL（Interface Description...

      Thrift Java 服务器 客户端通信

      在Java环境中，Thrift提供了服务器和客户端的实现，使得Java应用能够方便地建立起高效的通信机制。下面我们将深入探讨Thrift在Java环境中的服务器和客户端通信过程。 首先，我们需要定义服务接口。这通常通过编写一...

      java代码使用thrift2操作hbase示例

      在本文中，我们将深入探讨如何使用Java通过Thrift2接口操作HBase数据库。HBase是一个分布式、可扩展的大数据存储系统，它构建于Hadoop之上，支持实时读写。Thrift是一个轻量级的框架，用于跨语言服务开发，允许不同...

      thrift java build jar

      本文将详细介绍如何使用 Thrift 在 Java 环境下构建 `.jar` 文件，以便在不同的 Java 应用中使用 Thrift 生成的服务。 1. **安装 Thrift** 首先，你需要在本地安装 Thrift 编译器。访问 Thrift 官方网站...

      thrift 架构的Java的小例子 demo

      此文件为自己在Mac电脑上写的thrift的demo，使用maven 管理了小程序，并用thrift生成了源码，其中对thrift生成的源码，把override注销了，其他的没处理，如果感兴趣参考博客：...

      thrift中间件实例代码

      在"thrift中间件实例代码"中，我们可以看到Thrift如何在实际应用中被使用。Thrift通过定义一种IDL（接口定义语言）来描述服务接口，然后自动生成各种目标语言（如Java、Python、C++等）的客户端和服务端代码。这样，...

      thrift样例操作实例

      在学习这个实例时，你需要理解Thrift的IDL语法，如何使用Thrift编译器生成代码，以及如何在Java环境中集成和使用Thrift库。此外，你还需要了解如何配置和运行Thrift服务以及客户端，这通常涉及到网络通信、序列化和...

      采用java操作thrift代码示例

      4. **启动服务器**：使用生成的`ThriftServer.java`（或者自定义服务器），创建一个Thrift服务器实例，监听特定端口并处理客户端请求： ```java public class ThriftServer { public static void main(String[] ...

      thrift初级入门教程

      ### Thrift初级入门教程 #### 一、简介 Thrift 是由 Facebook 开发的一款软件库和一组代码生成工具，旨在加速高效且可扩展的后端服务的开发与实现。通过抽象出不同编程语言中最常用的部分，并将其封装进一个通用库...

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