Apache Thrift快速入门：零基础搭建跨语言RPC服务-优快云博客

Apache Thrift快速入门：零基础搭建跨语言RPC服务

【免费下载链接】thrift Apache Thrift 项目地址: https://gitcode.com/gh_mirrors/thrift2/thrift

你还在为不同编程语言间的通信难题烦恼吗？微服务架构中Python后端如何高效调用Java服务？分布式系统里C++模块与Go组件如何无缝协作？Apache Thrift（远程过程调用RPC框架）正是解决这些跨语言通信痛点的利器。本文将带你从环境搭建到实战开发，30分钟内完成跨语言RPC服务的搭建，无需深厚的网络编程知识，只需跟随步骤操作即可。读完本文你将掌握：Thrift环境部署、IDL文件编写、多语言代码生成、服务端与客户端实现全流程。

Apache Thrift核心架构解析

Apache Thrift是一个轻量级、跨语言的RPC（Remote Procedure Call，远程过程调用）框架，它通过自定义接口定义语言（IDL）来描述数据类型和服务接口，然后通过编译器生成不同语言的代码，实现不同语言之间的高效通信。其核心优势在于：支持28+编程语言、二进制高效传输、灵活的协议栈组合、松耦合的服务设计。

Thrift采用分层架构设计，从下到上分为传输层（Transport）、协议层（Protocol）、处理层（Processor）和服务层（Server），每层都可灵活选择不同实现：

传输层：负责数据的传输，如TCP、HTTP等，对应实现如TSocket、THttpTransport
协议层：定义数据的序列化格式，如二进制、JSON等，对应实现如TBinaryProtocol、TJSONProtocol
处理层：处理业务逻辑，由编译器根据IDL生成
服务层：提供服务模型，如简单单线程、多线程等，对应实现如TSimpleServer、TThreadPoolServer

官方文档：README.md

快速安装与环境配置

系统环境要求

Thrift支持Linux、Windows、macOS等主流操作系统，不同系统的安装方式略有差异。本文以Debian/Ubuntu系统为例，其他系统可参考对应安装文档。

Debian/Ubuntu系统安装

sudo apt-get install automake bison flex g++ git libboost-all-dev libevent-dev libssl-dev libtool make pkg-config

如果是Debian 7/Ubuntu 12等旧版本系统，需要手动升级automake和boost：

wget http://ftp.debian.org/debian/pool/main/a/automake-1.15/automake_1.15-3_all.deb
sudo dpkg -i automake_1.15-3_all.deb

wget http://sourceforge.net/projects/boost/files/boost/1.60.0/boost_1_60_0.tar.gz
tar xvf boost_1_60_0.tar.gz
cd boost_1_60_0
./bootstrap.sh
sudo ./b2 install

详细安装指南：doc/install/debian.md

CentOS系统安装

sudo yum -y groupinstall "Development Tools"
sudo yum -y install libevent-devel zlib-devel openssl-devel

CentOS系统需要升级autoconf、automake和boost等组件，具体步骤参考：doc/install/centos.md

Windows系统安装

Windows用户推荐使用预编译的Thrift编译器，下载后直接放入系统PATH路径即可。如需从源码编译，可使用Visual Studio打开compiler/cpp/compiler.vcxproj项目进行构建。

Windows安装指南：doc/install/windows.md

源码编译安装

完成依赖安装后，通过以下命令从源码编译安装Thrift：

git clone https://gitcode.com/gh_mirrors/thrift2/thrift.git
cd thrift
./bootstrap.sh
./configure
make
sudo make install

验证安装是否成功：

thrift --version

IDL接口定义实战

IDL基础语法

Thrift IDL（接口定义语言）是跨语言通信的核心，它使用简单的语法描述数据类型和服务接口。基本语法包括：

数据类型：支持bool、byte、i16、i32、i64、double、string等基本类型，以及map、list、set等容器类型
结构体：使用struct定义复杂数据结构
枚举：使用enum定义枚举类型
服务：使用service定义服务接口

编写第一个IDL文件

我们以一个简单的计算器服务为例，创建tutorial.thrift文件：

namespace cpp tutorial
namespace java tutorial
namespace py tutorial

typedef i32 MyInteger

const i32 INT32CONSTANT = 9853
const map<string,string> MAPCONSTANT = {'hello':'world', 'goodnight':'moon'}

enum Operation {
  ADD = 1,
  SUBTRACT = 2,
  MULTIPLY = 3,
  DIVIDE = 4
}

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 {
  void ping(),
  i32 add(1:i32 num1, 2:i32 num2),
  i32 calculate(1:i32 logid, 2:Work w) throws (1:InvalidOperation ouch),
  oneway void zip()
}

完整示例：tutorial/tutorial.thrift

IDL文件包含

Thrift支持通过include关键字包含其他IDL文件，实现接口复用。例如，创建shared.thrift：

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

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

在tutorial.thrift中包含：

include "shared.thrift"

service Calculator extends shared.SharedService {
  // ...
}

共享接口定义：tutorial/shared.thrift

多语言代码生成与实现

生成代码

使用Thrift编译器根据IDL文件生成目标语言代码：

thrift --gen cpp tutorial.thrift  # 生成C++代码
thrift --gen java tutorial.thrift # 生成Java代码
thrift --gen py tutorial.thrift   # 生成Python代码

生成的代码会放在gen-<language>目录下，例如C++代码在gen-cpp目录，包含服务接口和数据结构的定义。

C++服务端实现

#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <thrift/protocol/TBinaryProtocol.h>
#include <thrift/server/TSimpleServer.h>
#include <thrift/transport/TServerSocket.h>
#include <thrift/transport/TBufferTransports.h>

#include "gen-cpp/Calculator.h"

using namespace std;
using namespace apache::thrift;
using namespace apache::thrift::protocol;
using namespace apache::thrift::transport;
using namespace apache::thrift::server;

using namespace tutorial;
using namespace shared;

class CalculatorHandler : virtual public CalculatorIf {
public:
    CalculatorHandler() {
        // 初始化
    }

    void ping() {
        cout << "ping()" << endl;
    }

    int32_t add(const int32_t num1, const int32_t num2) {
        cout << "add(" << num1 << ", " << num2 << ")" << endl;
        return num1 + num2;
    }

    int32_t calculate(const int32_t logid, const Work& w) {
        cout << "calculate(" << logid << ", " << w.op << ", " << w.num1 << ", " << w.num2 << ")" << endl;
        int32_t val;

        switch (w.op) {
            case Operation::ADD:
                val = w.num1 + w.num2;
                break;
            case Operation::SUBTRACT:
                val = w.num1 - w.num2;
                break;
            case Operation::MULTIPLY:
                val = w.num1 * w.num2;
                break;
            case Operation::DIVIDE:
                if (w.num2 == 0) {
                    InvalidOperation io;
                    io.whatOp = w.op;
                    io.why = "Cannot divide by zero";
                    throw io;
                }
                val = w.num1 / w.num2;
                break;
            default:
                InvalidOperation io;
                io.whatOp = w.op;
                io.why = "Invalid operation";
                throw io;
        }

        return val;
    }

    void zip() {
        cout << "zip()" << endl;
    }
};

int main(int argc, char **argv) {
    int port = 9090;
    shared_ptr<CalculatorHandler> handler(new CalculatorHandler());
    shared_ptr<TProcessor> processor(new CalculatorProcessor(handler));
    shared_ptr<TServerTransport> serverTransport(new TServerSocket(port));
    shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());
    shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());

    TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);
    cout << "Starting the server..." << endl;
    server.serve();
    cout << "Server stopped" << endl;
    return 0;
}

C++库实现：lib/cpp/src/thrift/

Python客户端实现

import sys
from thrift import Thrift
from thrift.transport import TSocket
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol

from gen_py.tutorial import Calculator
from gen_py.tutorial.ttypes import *

def main():
    # 建立传输通道
    transport = TSocket.TSocket('localhost', 9090)
    transport = TTransport.TBufferedTransport(transport)
    
    # 选择协议
    protocol = TBinaryProtocol.TBinaryProtocol(transport)
    
    # 创建客户端
    client = Calculator.Client(protocol)
    
    # 连接服务器
    transport.open()
    
    client.ping()
    print("ping() called")
    
    sum_ = client.add(1, 1)
    print("1+1=%d" % sum_)
    
    work = Work()
    work.op = Operation.DIVIDE
    work.num1 = 100
    work.num2 = 0
    
    try:
        quotient = client.calculate(1, work)
        print("100/0=%d" % quotient)
    except InvalidOperation as e:
        print("Invalid operation: %s" % e.why)
    
    transport.close()

if __name__ == '__main__':
    try:
        main()
    except Thrift.TException as tx:
        print("%s" % tx.message)

Python库实现：lib/py/src/thrift/

Java客户端实现

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 org.apache.thrift.transport.TTransportException;

import tutorial.Calculator;
import tutorial.InvalidOperation;
import tutorial.Operation;
import tutorial.Work;

public class CalculatorClient {
    public static void main(String[] args) {
        TTransport transport = new TSocket("localhost", 9090);
        try {
            transport.open();
            
            TProtocol protocol = new TBinaryProtocol(transport);
            Calculator.Client client = new Calculator.Client(protocol);
            
            client.ping();
            System.out.println("ping() called");
            
            int sum = client.add(1, 1);
            System.out.println("1+1=" + sum);
            
            Work work = new Work();
            work.op = Operation.DIVIDE;
            work.num1 = 100;
            work.num2 = 0;
            
            try {
                int quotient = client.calculate(1, work);
                System.out.println("100/0=" + quotient);
            } catch (InvalidOperation e) {
                System.out.println("Invalid operation: " + e.why);
            }
            
            transport.close();
        } catch (TTransportException e) {
            e.printStackTrace();
        } catch (TException e) {
            e.printStackTrace();
        }
    }
}

Java库实现：lib/java/src/main/java/org/apache/thrift/

测试与部署

编译运行服务端

C++服务端编译：

g++ -std=c++11 Calculator_server.cpp gen-cpp/Calculator.cpp gen-cpp/shared_types.cpp gen-cpp/tutorial_types.cpp -o Calculator_server -lthrift
./Calculator_server

运行客户端测试

Python客户端运行：

python Calculator_client.py

预期输出：

ping() called
1+1=2
Invalid operation: Cannot divide by zero

协议与传输层选择

Thrift支持多种协议和传输层组合，可根据需求选择：

协议：TBinaryProtocol（二进制）、TCompactProtocol（压缩二进制）、TJSONProtocol（JSON格式）
传输：TSocket（TCP）、THttpTransport（HTTP）、TFramedTransport（分帧传输）

修改协议示例：

// 使用压缩协议
shared_ptr<TProtocolFactory> protocolFactory(new TCompactProtocolFactory());

# 使用JSON协议
protocol = TJSONProtocol.TJSONProtocol(transport)

服务模型选择

Thrift提供多种服务模型：

TSimpleServer：简单单线程模型，适用于测试
TThreadPoolServer：线程池模型，适用于并发请求
TNonblockingServer：非阻塞模型，适用于高并发场景

线程池服务端示例：

shared_ptr<TServer> server(new TThreadPoolServer(
    processor, serverTransport, transportFactory, protocolFactory));

常见问题与最佳实践

版本兼容性

Thrift设计支持版本兼容，新增字段应使用可选（optional）关键字，避免破坏旧客户端。详细规范参考：doc/specs/thrift-protocol-spec.md

性能优化

使用TCompactProtocol减少数据传输量
采用TFramedTransport提高传输效率
服务端使用TThreadPoolServer或TNonblockingServer提高并发处理能力

性能测试工具：test/benchmark/

安全考虑

使用TSocket+SSL传输加密数据
实现身份验证和授权机制
输入验证防止恶意请求

安全相关文档：doc/specs/thrift-sasl-spec.txt

跨语言注意事项

不同语言的类型映射需注意（如Python的int对应Thrift的i32/i64）
异常处理机制在不同语言中的实现差异
异步调用在部分语言中的特殊处理

多语言支持列表：LANGUAGES.md

总结与进阶

通过本文学习，你已掌握Apache Thrift的基本使用，能够搭建跨语言RPC服务。Thrift的强大之处在于其灵活性和可扩展性，适用于构建分布式系统和微服务架构。

进阶学习资源：

官方教程：tutorial/
协议规范：doc/specs/
测试用例：test/

Thrift社区活跃，支持多种编程语言和场景，是构建跨语言分布式系统的理想选择。如有问题，可参考官方文档或社区讨论获取帮助。

如果觉得本文对你有帮助，欢迎点赞、收藏、关注，下期将带来Thrift高级特性与实战案例分析！

【免费下载链接】thrift Apache Thrift 项目地址: https://gitcode.com/gh_mirrors/thrift2/thrift

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考