Apache Thrift - 实现服务

在 Apache Thrift 中实现服务

Apache Thrift 允许您在接口定义语言 (IDL) 中定义服务和数据类型，并为各种编程语言生成代码。典型的服务实现涉及提供服务的服务器和使用服务的客户端。

本教程将引导您完成使用生成的代码实现服务的流程，重点介绍服务器端和客户端的实现。

设置您的环境

在实现服务之前，请确保您拥有以下内容

Apache Thrift 编译器：已安装并配置。您可以从 Apache Thrift 网站下载它。
生成的代码：使用 Thrift 编译器为您的目标编程语言生成必要的代码。
编程环境：使用适当的依赖项（例如，Java、Python 等的 Thrift 库）设置您的编程环境。

生成服务代码

在 Thrift IDL 文件中定义服务后，下一步是在目标编程语言中为服务器和客户端生成相应的代码。

此代码生成过程非常重要，因为它提供了在服务器端实现服务逻辑和在客户端与服务交互所需的类和接口。

了解 Thrift 编译器的作用

Thrift 编译器（“thrift”命令）是一个读取 Thrift IDL 文件并在您指定的编程语言中生成代码的工具。此生成的代码包括以下内容

数据结构：对应于 IDL 文件中定义的结构体、枚举、联合体和其他数据类型的类或类型。
服务接口：IDL 中定义的每个服务的接口或基类，您必须在服务器应用程序中实现这些接口或基类。
客户端存根：客户端类，提供通过调用服务中定义的远程过程来与服务器交互的方法。

示例：Thrift IDL 文件

以下 Thrift IDL 文件定义了一个“User”结构体、一个具有两种方法的“UserService”服务和一个“UserNotFoundException”异常

namespace java com.example.thrift
namespace py example.thrift

struct User {
  1: i32 id
  2: string name
  3: bool isActive
}

service UserService {
  User getUserById(1: i32 id) throws (1: UserNotFoundException e)
  void updateUser(1: User user)
}

exception UserNotFoundException {
  1: string message
}

使用 Thrift 编译器生成代码

thrift --gen java example.thrift
thrift --gen py example.thrift

这将生成您将用于实现服务的 Java 和 Python 中的必要类和接口。

在 Java 中实现服务

从 Thrift IDL 文件生成必要的 Java 代码后，下一步是实现服务。这涉及创建处理客户端请求的服务器端逻辑以及开发与服务交互的客户端代码。

服务器端实现

在服务器端实现中，您首先需要实现服务接口：Thrift 编译器为每个服务生成一个 Java 接口。实现此接口以定义服务的行为

public class UserServiceHandler implements UserService.Iface {
   @Override
   public User getUserById(int id) throws UserNotFoundException, TException {
      // Implement the logic to retrieve the user by ID
      if (id == 1) {
         return new User(id, "John Doe", true);
      } else {
         throw new UserNotFoundException("User not found");
      }
   }
   @Override
   public void updateUser(User user) throws TException {
      // Implement the logic to update the user
      System.out.println("Updating user: " + user.name);
   }
}

然后，我们需要设置服务器：创建一个服务器，侦听客户端请求并调用服务处理程序上的适当方法

public class UserServiceServer {
   public static void main(String[] args) {
      try {
         UserServiceHandler handler = new UserServiceHandler();
         UserService.Processor<UserServiceHandler> processor = new UserService.Processor<>(handler);
         TServerTransport serverTransport = new TServerSocket(9090);
         TServer server = new TSimpleServer(new TServer.Args(serverTransport).processor(processor));

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

其中，

服务器传输：指定通信传输（例如，套接字）。
处理器：通过将其委托给服务处理程序来处理传入请求。
服务器：服务器侦听请求并将它们传递给处理器。

客户端实现

在客户端实现中，您首先需要创建客户端：Thrift 编译器为每个服务生成一个客户端类。使用此类来调用服务器上的方法

public class UserServiceClient {
   public static void main(String[] args) {
      try {
         TTransport transport = new TSocket("localhost", 9090);
         transport.open();

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

         User user = client.getUserById(1);
         System.out.println("User retrieved: " + user.name);

         user.isActive = false;
         client.updateUser(user);

         transport.close();
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

其中，

传输：管理与服务器的连接。
协议：指定数据如何序列化（例如，二进制协议）。
客户端：提供调用远程服务的方法。

在 Python 中实现服务

在 Python 中实现 Thrift 服务时，该过程涉及几个类似于 Java 等其他语言中的步骤。

您将需要实现服务逻辑，设置服务器以处理客户端请求，并确保服务平稳运行。

服务器端实现

在服务器端实现中，您首先需要实现服务接口：在 Python 中，Thrift 编译器为每个服务生成一个基类。子类化此基类以实现您的服务逻辑

from example.thrift.UserService import Iface
from example.thrift.ttypes import User, UserNotFoundException

class UserServiceHandler(Iface):
   def getUserById(self, id):
      if id == 1:
         return User(id=1, name="John Doe", isActive=True)
      else:
         raise UserNotFoundException(message="User not found")

   def updateUser(self, user):
      print(f"Updating user: {user.name}")

然后，我们需要设置服务器：创建一个 Thrift 服务器以侦听传入请求并将它们传递给服务处理程序

from thrift.Thrift import TProcessor
from thrift.transport import TSocket, TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TSimpleServer
from example.thrift.UserService import Processor

if __name__ == "__main__":
   handler = UserServiceHandler()
   processor = Processor(handler)
   transport = TSocket.TServerSocket(port=9090)
   tfactory = TTransport.TBufferedTransportFactory()
   pfactory = TBinaryProtocol.TBinaryProtocolFactory()

   server = TSimpleServer(processor, transport, tfactory, pfactory)

   print("Starting the server...")
   server.serve()

其中，

处理器：管理请求到处理程序的委托。
传输和协议工厂：设置服务器的通信和数据序列化方法。
服务器：启动服务器以处理客户端请求。

客户端实现

在客户端实现中，您首先需要创建客户端：使用生成的客户端类连接到服务器并调用其方法

from thrift.transport import TSocket, TTransport
from thrift.protocol import TBinaryProtocol
from example.thrift.UserService import Client

if __name__ == "__main__":
   transport = TSocket.TSocket('localhost', 9090)
   transport = TTransport.TBufferedTransport(transport)
   protocol = TBinaryProtocol.TBinaryProtocol(transport)
   client = Client(protocol)

   transport.open()

   try:
      user = client.getUserById(1)
      print(f"User retrieved: {user.name}")

      user.isActive = False
      client.updateUser(user)
   except Exception as e:
      print(f"Error: {e}")

   transport.close()

其中，

传输和协议：管理通信和数据格式。
客户端：提供对远程服务的接口，允许您调用服务器上的方法。

处理异常

正确处理异常可确保您的服务能够平稳地管理错误并向客户端提供有意义的反馈。

在 Apache Thrift 中，可以在 IDL 文件中定义异常，并在服务实现和客户端代码中进行处理。处理异常包括

在 Thrift IDL 中定义异常：在 Thrift IDL 文件中指定异常，以便服务器和客户端都了解可能发生的错误类型。
在服务实现中抛出异常：在服务方法中实现逻辑，以便在必要时抛出异常。
在服务器端处理异常：在服务器实现中管理异常，以确保服务能够从错误中恢复并提供有意义的响应。
在客户端处理异常：在客户端代码中实现错误处理，以管理服务器抛出的异常并做出相应的响应。

在 Thrift IDL 中定义异常

使用exception关键字在 Thrift IDL 文件中定义异常。您可以指定服务方法可以抛出的自定义异常类型

示例：带有异常的 Thrift IDL 文件

exception InvalidOperationException {
   1: string message
}

service CalculatorService {
   i32 add(1: i32 num1, 2: i32 num2) throws (1: InvalidOperationException e)
   i32 divide(1: i32 num1, 2: i32 num2) throws (1: InvalidOperationException e)
}

其中，

异常定义：“InvalidOperationException”是一个带有单个字段“message”的自定义异常。
方法签名：“add”和“divide”方法指定抛出“InvalidOperationException”。使用“throws”关键字在方法签名中包含异常。

在服务实现中抛出异常

在您的服务实现中，您需要根据方法的逻辑抛出异常。这涉及使用 IDL 中定义的异常

from thrift.Thrift import TException

class InvalidOperationException(TException):
   def __init__(self, message):
      self.message = message

class CalculatorServiceHandler:
   def add(self, num1, num2):
      return num1 + num2

   def divide(self, num1, num2):
      if num2 == 0:
         raise InvalidOperationException("Cannot divide by zero")
      return num1 / num2

其中，

自定义异常类：“InvalidOperationException”继承自“TException”并包含一个“message”属性。
抛出异常：在“divide”方法中，如果除数为零，则会引发“InvalidOperationException”。

在服务器端处理异常

在服务器端，您应该处理异常以确保服务能够管理错误并提供适当的响应。

Python 服务器代码中的异常处理

from thrift.server import TSimpleServer
from thrift.transport import TSocket, TTransport
from thrift.protocol import TBinaryProtocol
from calculator_service import CalculatorService, CalculatorServiceHandler

if __name__ == "__main__":
   handler = CalculatorServiceHandler()
   processor = CalculatorService.Processor(handler)
   transport = TSocket.TServerSocket(port=9090)
   tfactory = TTransport.TBufferedTransportFactory()
   pfactory = TBinaryProtocol.TBinaryProtocolFactory()

   server = TSimpleServer.TSimpleServer(processor, transport, tfactory, pfactory)

   print("Starting the Calculator service on port 9090...")
   try:
      server.serve()
   except InvalidOperationException as e:
      print(f"Handled exception: {e.message}")
   except Exception as e:
      print(f"Unexpected error: {str(e)}")

其中，

异常处理块：“try”块启动服务器，“except”块处理异常。“InvalidOperationException”被显式捕获并处理，而其他异常则被通用“Exception”块捕获。

在客户端处理异常

在客户端，您需要处理服务器抛出的异常。这可确保客户端能够管理错误并做出相应的反应。

带有异常处理的 Python 客户端代码示例

from thrift.transport import TSocket, TTransport
from thrift.protocol import TBinaryProtocol
from calculator_service import CalculatorService, InvalidOperationException

try:
   transport = TSocket.TSocket('localhost', 9090)
   transport = TTransport.TBufferedTransport(transport)
   protocol = TBinaryProtocol.TBinaryProtocol(transport)
   client = CalculatorService.Client(protocol)

   transport.open()
    
   try:
      result = client.divide(10, 0)  # This will raise an exception
   except InvalidOperationException as e:
      print(f"Exception caught from server: {e.message}")
   finally:
      transport.close()

except Exception as e:
   print(f"Client-side error: {str(e)}")

其中，

异常处理块：“try”块围绕与服务器交互的代码。“except”块捕获服务器抛出的“InvalidOperationException”，而通用“Exception”块处理任何客户端错误。

同步与异步处理

在服务架构中，任务的处理和执行方式会显著影响性能、响应能力和用户体验。

同步和异步处理是两种基本方法，它们在处理操作的方式上有所不同，尤其是在网络或分布式系统中。

同步处理

同步处理是一种按顺序执行任务的方法。在此模型中，每个任务必须在下一个任务开始之前完成。这意味着系统在继续执行下一个操作之前会等待一个操作完成。

以下是同步处理的特点

阻塞调用：每个操作都会阻塞后续操作的执行，直到它完成。例如，如果调用服务方法，则调用方会在方法返回结果之前等待。
简单的流程：执行流程简单易懂，因为操作是逐个执行的。它更容易实现和调试，因为代码按线性顺序执行。
可预测的性能：性能是可预测的，因为操作按请求顺序完成。
资源利用率：如果操作正在等待外部资源（例如，网络响应），则可能导致资源利用率低下，因为系统在此期间处于空闲状态。

示例

考虑一个同步 Thrift 服务实现，其中客户端调用一个方法，服务器处理请求并在客户端可以继续之前返回结果

# Client-side synchronous call
# Client waits until the server responds with the result
result = client.add(5, 10)  
print(f"Result: {result}")

在此示例中，对“client.add”的客户端调用会阻塞，直到服务器响应结果。客户端在等待时无法执行其他任务。

异步处理

异步处理允许任务同时执行，而不会阻塞其他任务的执行。在此模型中，可以启动操作，然后独立于主执行流程运行。

以下是异步处理的特征

非阻塞调用：启动操作并在后台运行，允许主线程或进程继续执行其他任务。例如，服务方法调用可以立即返回，而操作在后台完成。
复杂流程：执行流程可能更复杂，因为任务是同时处理的。这通常需要回调、Promise 或 Future 对象来管理完成。
性能提升：异步处理可以通过更有效地利用系统资源来提高性能，尤其是在 I/O 密集型操作中，这些操作通常需要等待外部响应。
并发性：允许同时执行多个任务，这在高延迟环境或处理许多并发请求时非常有用。

示例

考虑一个异步 Thrift 服务实现，其中客户端在等待服务器响应时不会阻塞

import asyncio
from thrift.transport import TSocket, TTransport
from thrift.protocol import TBinaryProtocol
from thrift.server import TAsyncServer

async def call_add(client):
   result = await client.add(5, 10)  # Non-blocking call
   print(f"Result: {result}")

async def main():
   transport = TSocket.TSocket('localhost', 9090)
   transport = TTransport.TBufferedTransport(transport)
   protocol = TBinaryProtocol.TBinaryProtocol(transport)
   client = CalculatorService.Client(protocol)

   await transport.open()
   await call_add(client)
   await transport.close()

asyncio.run(main())

在此示例中，“call_add”是一个异步函数，它不会阻塞其他任务的执行。“await”关键字用于执行对“client.add”的非阻塞调用，允许程序继续执行其他代码。

打印页面