Thrift入门及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>
    </artifactId>
    </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
    demo
     
    {
    )
    }

    目录结构如下：

     
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    F
    列表
    BE47
    .
    thrift
    thrift
    0.8.0.exe
     
    没有子文件夹

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

     
     
    1
    thrift

    生成后的目录结构如下：

     
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    F
    列表
    BE47
    .
    thrift
    thrift
    0.8.0.exe
    │
    java
    com
    micmiu
    thrift
    demo
    java

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

     
     
     
     
     
    XHTML
     
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    <dependency>
    </groupId>
    </artifactId>
    </version>
    </dependency>
    <dependency>
    </groupId>
    </artifactId>
    </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
    ;
     
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
     
    {
    }
     
    Override
    {
    ;
    }
     
    }

    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
    ;
     
    ;
    ;
    ;
    ;
    ;
    ;
    ;
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
    ;
     
    {
    {
    ;
     
    (
    ;
    // HelloWorldService.Processor&lt;HelloWorldService.Iface&gt; tprocessor =
    // new HelloWorldService.Processor&lt;HelloWorldService.Iface&gt;(
    // new HelloWorldImpl());
     
    // 简单的单线程服务模型，一般用于测试
    ;
    ;
    ;
    ;
    // tArgs.protocolFactory(new TCompactProtocol.Factory());
    // tArgs.protocolFactory(new TJSONProtocol.Factory());
    ;
    ;
     
    {
    ;
    ;
    }
    }
     
    /**
    * @param args
    */
    {
    ;
    ;
    }
     
    }

    编写客户端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
    ;
     
    ;
    ;
    ;
    ;
    ;
    ;
    ;
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
     
    ;
    ;
    ;
     
    /**
    *
    * @param userName
    */
    {
    ;
    {
    ;
    // 协议要和服务端一致
    ;
    // TProtocol protocol = new TCompactProtocol(transport);
    // TProtocol protocol = new TJSONProtocol(transport);
    (
    ;
    ;
    ;
    ;
    {
    ;
    {
    ;
    {
    {
    ;
    }
    }
    }
     
    /**
    * @param args
    */
    {
    ;
    ;
     
    }
     
    }

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

     
     
    1
    .

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

     
     
    1
    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
    ;
     
    ;
    ;
    ;
    ;
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
    ;
     
    {
    {
    ;
     
    (
    ;
     
    ;
    (
    ;
    ;
    ;
     
    // 线程池服务模型，使用标准的阻塞式IO，预先创建一组线程处理请求。
    ;
    ;
     
    {
    ;
    ;
    }
    }
     
    /**
    * @param args
    */
    {
    ;
    ;
    }
     
    }

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

     
     
    1
    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
    ;
     
    ;
    ;
    ;
    ;
    ;
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
    ;
     
    {
    {
    ;
     
    (
    ;
     
    (
    ;
    (
    ;
    ;
    ;
    ;
     
    // 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式
    ;
    ;
     
    {
    ;
    ;
    }
    }
     
    /**
    * @param args
    */
    {
    ;
    ;
    }
     
    }

    编写客户端代码：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
    ;
     
    ;
    ;
    ;
    ;
    ;
    ;
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
     
    ;
    ;
    ;
     
    /**
    *
    * @param userName
    */
    {
    ;
    {
    ,
    ;
    // 协议要和服务端一致
    ;
    (
    ;
    ;
    ;
    ;
    {
    ;
    {
    ;
    {
    {
    ;
    }
    }
    }
     
    /**
    * @param args
    */
    {
    ;
    ;
     
    }
     
    }

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

     
     
    1
    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
    ;
     
    ;
    ;
    ;
    ;
    ;
    ;
    ;
    ;
    ;
    ;
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
    ;
     
    {
    {
    ;
     
    (
    ;
     
    (
    ;
    ;
    ;
    ;
    ;
     
    //半同步半异步的服务模型
    ;
    ;
     
    {
    ;
    ;
    }
    }
     
    /**
    * @param args
    */
    {
    ;
    ;
    }
     
    }

    客户端代码和上面 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
    ;
     
    ;
    ;
    ;
    ;
    ;
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
    ;
     
    {
    {
    ;
     
    (
    ;
     
    (
    ;
    (
    ;
    ;
    ;
    ;
     
    // 使用非阻塞式IO，服务端和客户端需要指定TFramedTransport数据传输的方式
    ;
    ;
     
    {
    ;
    ;
    }
    }
     
    /**
    * @param args
    */
    {
    ;
    ;
    }
     
    }

    编写客户端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
    ;
     
    ;
    ;
     
    ;
    ;
    ;
    ;
    ;
    ;
    ;
     
    ;
     
    /**
    * blog http://www.micmiu.com
    *
    * @author Michael
    *
    */
    {
     
    ;
    ;
    ;
     
    /**
    *
    * @param userName
    */
    {
    {
    ;
    ,
    ;
     
    ;
    (
    ;
    ;
     
    ;
    ;
    ;
    ;
    ;
    ;
    ;
    {
    ;
    }
    ;
    }
     
    {
    ;
     
    {
    ;
    }
     
    Override
    {
    ;
    {
    // Thread.sleep(1000L * 1);
    ;
    {
    ;
    {
    ;
    {
    ;
    }
    }
     
    Override
    {
    ;
    ;
    }
    }
     
    /**
    * @param args
    */
    {
    ;
    ;
     
    }
     
    }

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

     
     
    1
    2
    3
    4
    5
    6
    7
    .
    .
    end
    onComplete
    com
    true
    .

    ————

    相关文章：

    猜你喜欢
    相关资源
    相似解决方案
    热门标签
    Java Python linux javascript Mysql C# Docker 算法 前端 SpringBoot Redis Vue spring 设计模式 .net core .net kubernetes c++ 数据库 数据结构 大数据 js 机器学习 微服务 Android Go 程序员 面试 JVM ASP.net core 云原生 人工智能 后端 PHP git CSS golang k8s Nginx Django mybatis 深度学习 多线程 React 架构 devops 爬虫 云计算 Spring Boot LeetCode