Bekerja dengan Apache Thrift

1. Gambaran keseluruhan

Dalam artikel ini, kita akan mengetahui bagaimana mengembangkan aplikasi pelayan pelanggan lintas platform dengan bantuan rangka RPC yang disebut Apache Thrift.

Kami akan merangkumi:

  • Menentukan jenis data dan antara muka perkhidmatan dengan IDL
  • Memasang perpustakaan dan menghasilkan sumber untuk pelbagai bahasa
  • Melaksanakan antara muka yang ditentukan dalam bahasa tertentu
  • Melaksanakan perisian klien / pelayan

Sekiranya anda ingin terus ke contoh, teruskan ke bahagian 5.

2. Apache Thrift

Apache Thrift pada awalnya dikembangkan oleh pasukan pengembangan Facebook dan kini dikendalikan oleh Apache.

Sebagai perbandingan dengan Protocol Buffer, yang menguruskan proses serialisasi / deserialisasi objek lintas platform, Thrift terutama memfokuskan pada lapisan komunikasi antara komponen sistem anda.

Thrift menggunakan Bahasa Penerangan Antaramuka khas (IDL) untuk menentukan jenis data dan antara muka perkhidmatan yang disimpan sebagai fail .thrift dan digunakan kemudian sebagai input oleh penyusun untuk menghasilkan kod sumber perisian klien dan pelayan yang berkomunikasi melalui pelbagai bahasa pengaturcaraan.

Untuk menggunakan Apache Thrift dalam projek anda, tambahkan kebergantungan Maven ini:

 org.apache.thrift libthrift 0.10.0 

Anda boleh mendapatkan versi terbaru di repositori Maven.

3. Bahasa Huraian Antara Muka

Seperti yang telah dijelaskan, IDL membolehkan menentukan antara muka komunikasi dalam bahasa yang neutral. Di bawah ini anda akan menemui jenis yang disokong sekarang.

3.1. Jenis Pangkalan

  • bool - nilai boolean (benar atau salah)
  • bait - bilangan bulat bertanda 8-bit
  • i16 - bilangan bulat 16-bit yang ditandatangani
  • i32 - bilangan bulat 32-bit yang ditandatangani
  • i64 - bilangan bulat bertanda 64-bit
  • berganda - nombor titik terapung 64-bit
  • string - rentetan teks yang dikodkan menggunakan pengekodan UTF-8

3.2. Jenis Khas

  • binari - urutan bait yang tidak dikodkan
  • pilihan - Java 8 ini Pilihan jenis

3.3. Struktur

Thrift struct adalah kelas yang setara dengan bahasa OOP tetapi tanpa pewarisan. A struct mempunyai set medan kuat ditaip, masing-masing dengan nama unik sebagai pengecam. Medan mungkin mempunyai pelbagai anotasi (ID medan angka, nilai lalai pilihan, dll.).

3.4. Bekas

Bekas bekas adalah bekas yang ditaip kuat:

  • list - senarai elemen yang teratur
  • set - sekumpulan elemen unik yang tidak tersusun
  • peta - peta kunci nilai yang unik

Elemen kontena mungkin jenis Thrift yang sah.

3.5. Pengecualian

Pengecualian secara fungsional setara dengan struktur , kecuali yang diwarisi dari pengecualian asli.

3.6. Perkhidmatan

Perkhidmatan sebenarnya antara muka komunikasi yang ditentukan menggunakan jenis Thrift. Mereka terdiri dari sekumpulan fungsi bernama, masing-masing dengan senarai parameter dan jenis pengembalian.

4. Penjanaan Kod Sumber

4.1. Sokongan Bahasa

Terdapat senarai panjang bahasa yang disokong sekarang:

  • C ++
  • C #
  • Pergi
  • Haskell
  • Jawa
  • Javascript
  • Node.js
  • Perl
  • PHP
  • Python
  • Ruby

Anda boleh menyemak senarai penuh di sini.

4.2. Menggunakan Fail Pelaksana Perpustakaan

Cukup muat turun versi terkini, bina dan pasang jika perlu, dan gunakan sintaks berikut:

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

In the commands set above, [LANGUAGE] is one of the supported languages and [FILENAME] is a file with IDL definition.

Note the -r flag. It tells Thrift to generate code recursively once it notices includes in a given .thrift file.

4.3. Using Maven Plugin

Add the plugin in your pom.xml file:

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

After that just execute the following command:

mvn clean install

Note that this plugin will not have any further maintenance anymore. Please visit this page for more information.

5. Example of a Client-Server Application

5.1. Defining Thrift File

Let's write some simple service with exceptions and structures:

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.

Seperti biasa, semua contoh boleh didapati di repositori GitHub.