Arbeiten mit Apache Thrift

1. Übersicht

In diesem Artikel erfahren Sie, wie Sie mithilfe des RPC-Frameworks Apache Thrift plattformübergreifende Client-Server-Anwendungen entwickeln.

Wir werden abdecken:

  • Definieren von Datentypen und Dienstschnittstellen mit IDL
  • Installieren der Bibliothek und Generieren der Quellen für verschiedene Sprachen
  • Implementierung der definierten Schnittstellen in einer bestimmten Sprache
  • Implementierung von Client / Server-Software

Wenn Sie direkt zu Beispielen gehen möchten, fahren Sie direkt mit Abschnitt 5 fort.

2. Apache Thrift

Apache Thrift wurde ursprünglich vom Facebook-Entwicklungsteam entwickelt und wird derzeit von Apache verwaltet.

Im Vergleich zu Protokollpuffern, die plattformübergreifende Objektserialisierungs- / Deserialisierungsprozesse verwalten, konzentriert sich Thrift hauptsächlich auf die Kommunikationsschicht zwischen Komponenten Ihres Systems.

Thrift verwendet eine spezielle Interface Description Language (IDL), um Datentypen und Dienstschnittstellen zu definieren, die als Thrift- Dateien gespeichert und später vom Compiler als Eingabe zum Generieren des Quellcodes von Client- und Serversoftware verwendet werden, die über verschiedene Programmiersprachen kommunizieren.

Fügen Sie diese Maven-Abhängigkeit hinzu, um Apache Thrift in Ihrem Projekt zu verwenden:

 org.apache.thrift libthrift 0.10.0 

Sie finden die neueste Version im Maven-Repository.

3. Sprache der Schnittstellenbeschreibung

Wie bereits beschrieben, ermöglicht IDL die Definition von Kommunikationsschnittstellen in einer neutralen Sprache. Nachfolgend finden Sie die aktuell unterstützten Typen.

3.1. Basistypen

  • bool - ein boolescher Wert (wahr oder falsch)
  • Byte - eine 8-Bit-Ganzzahl mit Vorzeichen
  • i16 - eine 16-Bit-Ganzzahl mit Vorzeichen
  • i32 - eine vorzeichenbehaftete 32-Bit-Ganzzahl
  • i64 - eine 64-Bit-Ganzzahl mit Vorzeichen
  • double - eine 64-Bit-Gleitkommazahl
  • Zeichenfolge - Eine Textzeichenfolge, die mit UTF-8-Codierung codiert wurde

3.2. Spezielle Typen

  • binär - eine Folge von nicht codierten Bytes
  • optional - der optionale Typ eines Java 8

3.3. Strukturen

Thrift structs sind das Äquivalent von Klassen in OOP - Sprachen , aber ohne Vererbung. Eine Struktur verfügt über eine Reihe stark typisierter Felder, die jeweils einen eindeutigen Namen als Bezeichner haben. Felder können verschiedene Anmerkungen haben (numerische Feld-IDs, optionale Standardwerte usw.).

3.4. Behälter

Sparsamkeitscontainer sind stark typisierte Container:

  • Liste - eine geordnete Liste von Elementen
  • set - eine ungeordnete Menge eindeutiger Elemente
  • map - Eine Karte mit streng eindeutigen Schlüssel zu Werten

Containerelemente können von einem beliebigen gültigen Thrift-Typ sein.

3.5. Ausnahmen

Ausnahmen sind funktional äquivalent zu Strukturen , außer dass sie von den nativen Ausnahmen erben.

3.6. Dienstleistungen

Dienste sind Kommunikationsschnittstellen, die mithilfe von Thrift-Typen definiert werden. Sie bestehen aus einer Reihe benannter Funktionen mit jeweils einer Liste von Parametern und einem Rückgabetyp.

4. Generierung des Quellcodes

4.1. Sprachunterstützung

Es gibt eine lange Liste der derzeit unterstützten Sprachen:

  • C ++
  • C #
  • Gehen
  • Haskell
  • Java
  • Javascript
  • Node.js
  • Perl
  • PHP
  • Python
  • Rubin

Sie können die vollständige Liste hier überprüfen.

4.2. Verwenden der ausführbaren Datei der Bibliothek

Laden Sie einfach die neueste Version herunter, erstellen und installieren Sie sie bei Bedarf und verwenden Sie die folgende Syntax:

cd path/to/thrift thrift -r --gen [LANGUAGE] [FILENAME]

In den oben festgelegten Befehlen ist [LANGUAGE] eine der unterstützten Sprachen und [FILENAME ] eine Datei mit IDL-Definition.

Beachten Sie das Flag -r . Es weist Thrift an, rekursiv Code zu generieren, sobald es feststellt, dass eine bestimmte .thrift- Datei enthalten ist.

4.3. Verwenden des Maven Plugins

Fügen Sie das Plugin in Ihre pom.xml- Datei ein:

 org.apache.thrift.tools maven-thrift-plugin 0.1.11  path/to/thrift    thrift-sources generate-sources  compile    

Führen Sie danach einfach den folgenden Befehl aus:

mvn clean install

Beachten Sie, dass dieses Plugin keine weitere Wartung mehr hat. Bitte besuchen Sie diese Seite für weitere Informationen.

5. Beispiel einer Client-Server-Anwendung

5.1. Thrift-Datei definieren

Schreiben wir einen einfachen Dienst mit Ausnahmen und Strukturen:

namespace cpp com.baeldung.thrift.impl namespace java com.baeldung.thrift.impl exception InvalidOperationException { 1: i32 code, 2: string description } struct CrossPlatformResource { 1: i32 id, 2: string name, 3: optional string salutation } service CrossPlatformService { CrossPlatformResource get(1:i32 id) throws (1:InvalidOperationException e), void save(1:CrossPlatformResource resource) throws (1:InvalidOperationException e), list  getList() throws (1:InvalidOperationException e), bool ping() throws (1:InvalidOperationException e) }

As you can see, the syntax is pretty simple and self-explanatory. We define a set of namespaces (per implementation language), an exception type, a struct, and finally a service interface which will be shared across different components.

Then just store it as a service.thrift file.

5.2. Compiling and Generating a Code

Now it's time to run a compiler which will generate the code for us:

thrift -r -out generated --gen java /path/to/service.thrift

As you might see, we added a special flag -out to specify the output directory for generated files. If you did not get any errors, the generated directory will contain 3 files:

  • CrossPlatformResource.java
  • CrossPlatformService.java
  • InvalidOperationException.java

Let's generate a C++ version of the service by running:

thrift -r -out generated --gen cpp /path/to/service.thrift

Now we get 2 different valid implementations (Java and C++) of the same service interface.

5.3. Adding a Service Implementation

Although Thrift has done most of the work for us, we still need to write our own implementations of the CrossPlatformService. In order to do that, we just need to implement a CrossPlatformService.Iface interface:

public class CrossPlatformServiceImpl implements CrossPlatformService.Iface { @Override public CrossPlatformResource get(int id) throws InvalidOperationException, TException { return new CrossPlatformResource(); } @Override public void save(CrossPlatformResource resource) throws InvalidOperationException, TException { saveResource(); } @Override public List getList() throws InvalidOperationException, TException { return Collections.emptyList(); } @Override public boolean ping() throws InvalidOperationException, TException { return true; } }

5.4. Writing a Server

As we said, we want to build a cross-platform client-server application, so we need a server for it. The great thing about Apache Thrift is that it has its own client-server communication framework which makes communication a piece of cake:

public class CrossPlatformServiceServer { public void start() throws TTransportException { TServerTransport serverTransport = new TServerSocket(9090); server = new TSimpleServer(new TServer.Args(serverTransport) .processor(new CrossPlatformService.Processor(new CrossPlatformServiceImpl()))); System.out.print("Starting the server... "); server.serve(); System.out.println("done."); } public void stop() { if (server != null && server.isServing()) { System.out.print("Stopping the server... "); server.stop(); System.out.println("done."); } } } 

First thing is to define a transport layer with the implementation of TServerTransport interface (or abstract class, to be more precise). Since we are talking about server, we need to provide a port to listen to. Then we need to define a TServer instance and choose one of the available implementations:

  • TSimpleServer – for simple server
  • TThreadPoolServer – for multi-threaded server
  • TNonblockingServer – for non-blocking multi-threaded server

And finally, provide a processor implementation for chosen server which was already generated for us by Thrift, i.e. CrossPlatofformService.Processor class.

5.5. Writing a Client

And here is the client's implementation:

TTransport transport = new TSocket("localhost", 9090); transport.open(); TProtocol protocol = new TBinaryProtocol(transport); CrossPlatformService.Client client = new CrossPlatformService.Client(protocol); boolean result = client.ping(); transport.close();

From a client perspective, the actions are pretty similar.

First of all, define the transport and point it to our server instance, then choose the suitable protocol. The only difference is that here we initialize the client instance which was, once again, already generated by Thrift, i.e. CrossPlatformService.Client class.

Since it is based on .thrift file definitions we can directly call methods described there. In this particular example, client.ping() will make a remote call to the server which will respond with true.

6. Conclusion

In this article, we've shown you the basic concepts and steps in working with Apache Thrift, and we've shown how to create a working example which utilizes Thrift library.

Wie üblich finden Sie alle Beispiele immer im GitHub-Repository.