Thrift RPC基础学习总结

时间 2019-11-12

原文原文链接

一.什么是Thrift?

Thrift是一个软件框架，用来进行可扩展且跨语言的服务的开发。它结合了功能强大的软件堆栈和代码生成引擎，以构建在 C++、Java、Python、PHP、Ruby、Erlang、Perl、Haskell、C#、Cocoa、JavaScript、Node.js、Smalltalk、and OCaml 等等编程语言间无缝结合的、高效的服务。php

Thrift最初由facebook开发，07年四月开放源码，08年5月进入Apache孵化器。Thrift容许你定义一个简单的定义文件中的数据类型和服务接口。以做为输入文件，编译器生成代码用来方便地生成RPC客户端和服务器通讯的无缝跨编程语言。java

官网地址：thrift.apache.orgc++

2、Thrift的基础

基本类型：apache

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：对应服务的类

服务端编码基本步骤

实现服务处理接口impl
建立TProcessor
建立TServerTransport
建立TProtocol
建立TServer
启动Server

客户端编码基本步骤

建立Transport
建立TProtocol
基于TTransport和TProtocol建立Client
调用Client的相应方法

数据传输协议

TBinaryProtocol 二进制格式
TCompactProtocol 压缩格式
TJSONProtocol JSON格式
TSimpleJSONProtocol 提供JSON只写协议，生成的文件很容易经过脚本语言解析

提示:客户端和服务端的协议要一致编程语言

基本关键字

oneway ：表示客户端调用服务器不关心服务器的返回值，不关心服务器程序是否执行完成
void ：和oneway同样没有返回值，可是会确保服务器程序执行完成
extends：继承，service之间能够经过extends继承

3、简单示例

3.1基本配置ide

到官网下载最新版本，截止今日（2016-04-23）最新版本为0.9.3

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

<dependency>
    <groupId>org.apache.thrift</groupId>
    <artifactId>libthrift</artifactId>
    <version>0.9.3</version>
</dependency>
<dependency>
 <groupId>org.slf4j</groupId>
 <artifactId>slf4j-log4j12</artifactId>
 <version>1.7.5</version>
</dependency>

也能够手动配置jar包，在项目中添加以下jar包便可

3.2 下载thrift而且配置环境变量

下载thrift 工具，将thrift-x.x.x.exe修改完thrift.exe，而且将次程序所在位置添加到path环境变量中。

3.3 生成简单示例

shared.thrift

namespace cpp 	com.itest.thrift.shared   #c++中的命名空间
namespace java 	com.itest.thrift.shared   #java 包名
namespace php 	com.itest.thrift.shared   #php命名空间

struct SharedStruct {
  1: i32 key
  2: string value
}

service SharedService {
  SharedStruct getStruct(1: i32 key)
}

tutorial.thrift

include "shared.thrift" #引入shared.thrift

namespace cpp com.itest.thrift.service
namespace java com.itest.thrift.service
namespace php com.itest.thrift.service

/**
 * 定义c风格的数据类型
 * 
 */
typedef i32 MyInteger

/**
 * 定义常量
 * 
 */
const i32 INT32CONSTANT = 9853
const map<string,string> MAPCONSTANT = {'hello':'world', 'goodnight':'moon'}

/**
 * 
 * 定义枚举
 */
enum Operation {  //php默认不支持枚举，但这里也会经过其余方式生成php枚举
  ADD = 1,
  SUBTRACT = 2,
  MULTIPLY = 3,
  DIVIDE = 4
}

/**
 * 
 * 定义结构体，在php和java中生成bean，在c++中是结构体
 */
struct Work {
  1: i32 num1 = 0,
  2: i32 num2,
  3: Operation op,
  4: optional string comment,
}

/**
 * 定义异常类型，扩展性很强
 */
exception InvalidOperation {
  1: i32 whatOp,
  2: string why
}

/**
 * 定义服务，这里也能够继承其余服务
 */
service Calculator extends shared.SharedService {

  /**
   * 定义服务方法
   */

   void ping(),

   i32 add(1:i32 num1, 2:i32 num2),

   i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),

   /**
    * 此方法表示客户端只发送请求，不关心程序的执行和执行结果，和void不一样，void须要确认程序执行结束
    */
   oneway void zip()

}

3.4生成代码

执行以下命令（更多命令，请执行 thrift --help 查询）

thrift -o ./ -out ./ -r -gen java tutorial.thrift

将生成的代码添加到项目中，以下：

3.4 实现接口Iface

package com.itest.thrift.handler;


import java.util.HashMap;

import com.itest.thrift.service.InvalidOperation;
import com.itest.thrift.service.Work;
import com.itest.thrift.service.Calculator;
import com.itest.thrift.shared.SharedStruct;
// Generated code

public class CalculatorHandler implements Calculator.Iface {

  private HashMap<Integer,SharedStruct> log;

  public CalculatorHandler() {
    log = new HashMap<Integer, SharedStruct>();
  }

  public void ping() {
    System.out.println("ping()");
  }

  public int add(int n1, int n2) {
    System.out.println("add(" + n1 + "," + n2 + ")");
    return n1 + n2;
  }

  public int calculate(int logid, Work work) throws InvalidOperation {
    System.out.println("calculate(" + logid + ", {" + work.op + "," + work.num1 + "," + work.num2 + "})");
    int val = 0;
    switch (work.op) {
    case ADD:
      val = work.num1 + work.num2;
      break;
    case SUBTRACT:
      val = work.num1 - work.num2;
      break;
    case MULTIPLY:
      val = work.num1 * work.num2;
      break;
    case DIVIDE:
      if (work.num2 == 0) {
        InvalidOperation io = new InvalidOperation();
        io.whatOp = work.op.getValue();
        io.why = "Cannot divide by 0";
        throw io;
      }
      val = work.num1 / work.num2;
      break;
    default:
      InvalidOperation io = new InvalidOperation();
      io.whatOp = work.op.getValue();
      io.why = "Unknown operation";
      throw io;
    }

    SharedStruct entry = new SharedStruct();
    entry.key = logid;
    entry.value = Integer.toString(val);
    log.put(logid, entry);

    return val;
  }

  public SharedStruct getStruct(int key) {
    System.out.println("getStruct(" + key + ")");
    return log.get(key);
  }

  public void zip() {
    System.out.println("zip()");
  }

}

3.5发布服务

package com.iuap.thirft.itest;
import org.apache.thrift.server.TServer;
import org.apache.thrift.server.TServer.Args;
import org.apache.thrift.server.TSimpleServer;
import org.apache.thrift.transport.TServerSocket;
import org.apache.thrift.transport.TServerTransport;

import com.itest.thrift.handler.CalculatorHandler;
import com.itest.thrift.service.Calculator;
// Generated code

public class JavaServer {

  public static CalculatorHandler handler;

  @SuppressWarnings("rawtypes")
  public static Calculator.Processor processor;

  @SuppressWarnings("rawtypes")
  public static void main(String [] args) {
    try {
      handler = new CalculatorHandler();
      processor = new Calculator.Processor(handler);

      Runnable simple = new Runnable() {
        public void run() {
          simple(processor);
        }
      };      
      new Thread(simple).start();
    } catch (Exception x) {
      x.printStackTrace();
    }
  }

  public static void simple(@SuppressWarnings("rawtypes") Calculator.Processor processor) {
    try {
      TServerTransport serverTransport = new TServerSocket(9090);
      TServer server = new TSimpleServer(new Args(serverTransport).processor(processor));

      System.out.println("Starting the simple server...");
      server.serve();
    } catch (Exception e) {
      e.printStackTrace();
    }
  }

}

3.6调用服务

package com.iuap.thirft.itest;
import org.apache.thrift.TException;
import org.apache.thrift.protocol.TBinaryProtocol;
import org.apache.thrift.protocol.TProtocol;
import org.apache.thrift.transport.TSocket;
import org.apache.thrift.transport.TTransport;

import com.itest.thrift.service.Calculator;
import com.itest.thrift.service.InvalidOperation;
import com.itest.thrift.service.Operation;
import com.itest.thrift.service.Work;
import com.itest.thrift.shared.SharedStruct;

public class JavaClient {
  public static void main(String [] args) {


    try {
      TTransport transport;
  //    if (args[0].contains("simple")) {
        transport = new TSocket("localhost", 9090);
        transport.open();
    /*  }
      else {
        TSSLTransportParameters params = new TSSLTransportParameters();
        params.setTrustStore("../../lib/java/test/.truststore", "thrift", "SunX509", "JKS");
        transport = TSSLTransportFactory.getClientSocket("localhost", 9091, 0, params);
      }*/

      TProtocol protocol = new  TBinaryProtocol(transport);
      Calculator.Client client = new Calculator.Client(protocol);

      perform(client);

      transport.close();
    } catch (TException x) {
      x.printStackTrace();
    } 
  }

  private static void perform(Calculator.Client client) throws TException
  {
    client.ping();
    System.out.println("ping()");

    int sum = client.add(1,1);
    System.out.println("1+1=" + sum);

    Work work = new Work();

    work.op = Operation.DIVIDE;
    work.num1 = 1;
    work.num2 = 0;
    try {
      int quotient = client.calculate(1, work);
      System.out.println("Whoa we can divide by 0");
    } catch (InvalidOperation io) {
      System.out.println("Invalid operation: " + io.why);
    }

    work.op = Operation.SUBTRACT;
    work.num1 = 15;
    work.num2 = 10;
    try {
      int diff = client.calculate(1, work);
      System.out.println("15-10=" + diff);
    } catch (InvalidOperation io) {
      System.out.println("Invalid operation: " + io.why);
    }
    
    client.zip();

    SharedStruct log = client.getStruct(1);
    System.out.println("Check log: " + log.value);
  }
}

3.7执行结果

服务器端

Starting the simple server...
ping()
add(1,1)
calculate(1, {DIVIDE,1,0})
calculate(1, {SUBTRACT,15,10})
zip()
getStruct(1)
ping()
add(1,1)
calculate(1, {DIVIDE,1,0})
calculate(1, {SUBTRACT,15,10})
zip()
getStruct(1)

客户端

ping()
1+1=2
Invalid operation: Cannot divide by 0
15-10=5
Check log: 5

4、注意事项

①thrift服务调用也能够经过异步方式，须要继承AsyncIface，而且实现TNonblockingServer模型

②命令中的 -gen的值肯定生成不一样语言的代码，如-gen php,-gen java

③thrift须要各类语言的支持库或者虚拟机才能生成代码，所以须要下载不一样的虚拟机SDK，配置相应的环境变量。