Lavorare con Apache Thrift

1. Panoramica

In questo articolo scopriremo come sviluppare applicazioni client-server multipiattaforma con l'aiuto del framework RPC chiamato Apache Thrift.

Copriremo:

  • Definizione dei tipi di dati e delle interfacce di servizio con IDL
  • Installazione della libreria e generazione dei sorgenti per diverse lingue
  • Implementazione delle interfacce definite in un linguaggio particolare
  • Implementazione di software client / server

Se vuoi andare direttamente agli esempi, vai direttamente alla sezione 5.

2. Apache Thrift

Apache Thrift è stato originariamente sviluppato dal team di sviluppo di Facebook ed è attualmente mantenuto da Apache.

Rispetto ai buffer di protocollo, che gestiscono i processi di serializzazione / deserializzazione degli oggetti multipiattaforma, Thrift si concentra principalmente sul livello di comunicazione tra i componenti del sistema.

Thrift utilizza uno speciale IDL (Interface Description Language) per definire i tipi di dati e le interfacce di servizio che vengono archiviati come file .thrift e utilizzati successivamente come input dal compilatore per generare il codice sorgente del software client e server che comunicano su diversi linguaggi di programmazione.

Per utilizzare Apache Thrift nel tuo progetto, aggiungi questa dipendenza Maven:

 org.apache.thrift libthrift 0.10.0 

Puoi trovare l'ultima versione nel repository Maven.

3. Linguaggio di descrizione dell'interfaccia

Come già descritto, IDL consente di definire interfacce di comunicazione in un linguaggio neutro. Di seguito troverai i tipi attualmente supportati.

3.1. Tipi di base

  • bool - un valore booleano (vero o falso)
  • byte - un intero con segno a 8 bit
  • i16 - un intero con segno a 16 bit
  • i32 - un intero con segno a 32 bit
  • i64 : un intero con segno a 64 bit
  • double - un numero in virgola mobile a 64 bit
  • stringa : una stringa di testo codificata utilizzando la codifica UTF-8

3.2. Tipi speciali

  • binario - una sequenza di byte non codificati
  • opzionale : un tipo opzionale di Java 8

3.3. Structs

Gli struct parsimoniosi sono l'equivalente delle classi nei linguaggi OOP ma senza ereditarietà. Una struttura ha una serie di campi fortemente tipizzati, ciascuno con un nome univoco come identificatore. I campi possono avere varie annotazioni (ID di campo numerico, valori predefiniti opzionali, ecc.).

3.4. Contenitori

I contenitori dell'usato sono contenitori fortemente tipizzati:

  • list - un elenco ordinato di elementi
  • set - un insieme non ordinato di elementi unici
  • map - una mappa di chiavi di valori strettamente univoche

Gli elementi contenitore possono essere di qualsiasi tipo Thrift valido.

3.5. Eccezioni

Le eccezioni sono funzionalmente equivalenti alle strutture , tranne per il fatto che ereditano dalle eccezioni native.

3.6. Servizi

I servizi sono in realtà interfacce di comunicazione definite utilizzando i tipi Thrift. Sono costituiti da un insieme di funzioni denominate, ciascuna con un elenco di parametri e un tipo restituito.

4. Generazione del codice sorgente

4.1. Supporto linguistico

C'è un lungo elenco di lingue attualmente supportate:

  • C ++
  • C #
  • Partire
  • Haskell
  • Giava
  • Javascript
  • Node.js
  • Perl
  • PHP
  • Pitone
  • Rubino

Puoi controllare l'elenco completo qui.

4.2. Utilizzo del file eseguibile della libreria

Basta scaricare l'ultima versione, crearla e installarla se necessario e utilizzare la seguente sintassi:

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

Nei comandi impostati sopra, [LANGUAGE] è una delle lingue supportate e [FILENAME ] è un file con definizione IDL.

Nota il flag -r . Indica a Thrift di generare il codice in modo ricorsivo una volta che nota l' inclusione in un dato file .thrift .

4.3. Utilizzando Maven Plugin

Aggiungi il plugin nel tuo file pom.xml :

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

Dopodiché, esegui il seguente comando:

mvn clean install

Nota che questo plugin non avrà più alcuna manutenzione ulteriore. Visita questa pagina per ulteriori informazioni.

5. Esempio di un'applicazione client-server

5.1. Definizione di file di risparmio

Scriviamo un semplice servizio con eccezioni e strutture:

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.

Come al solito, tutti gli esempi possono essere sempre trovati nel repository GitHub.