In this article we are going to explore the exciting world of Apache Thrift. From its origins to its impact today, Apache Thrift has generated continued interest and has become a topic of discussion and debate in various areas. Throughout these pages, we will analyze the different aspects related to Apache Thrift, from its importance in modern society to its influence on popular culture. Additionally, we will examine how Apache Thrift has evolved over time and how it continues to set trends today. Be prepared to embark on an exciting journey through the ins and outs of Apache Thrift and discover everything this theme has to offer.
This article has multiple issues. Please help improve it or discuss these issues on the talk page. (Learn how and when to remove these template messages)
|
Original author(s) | Facebook, Inc. |
---|---|
Developer(s) | Apache Software Foundation |
Stable release | |
Repository | Thrift Repository |
Written in | ActionScript, C, C#, C++, D, Dart, Delphi, Erlang, Go, Haskell, Haxe, Java, JavaScript, Node.js, OCaml, Perl, PHP, Python, Rust, Scala, Smalltalk |
Type | Remote procedure call framework |
License | Apache 2.0 |
Website | thrift |
Thrift is an interface definition language and binary communication protocol used for defining and creating services for programming languages. It was developed by Facebook. Since 2020, it is an open source project in the Apache Software Foundation.
It uses a remote procedure call (RPC) framework and combines a software stack with a code generation engine to build cross-platform services. Ultimately, Thrift can connect applications written in a variety of languages and frameworks, including ActionScript, C, C++, C#, Cocoa, Delphi, Erlang, Go, Haskell, Java, JavaScript, Objective-C, OCaml, Perl, PHP, Python, Ruby, Elixir, Rust, Scala, Smalltalk, and Swift. The implementation was described in a April 2007 technical paper released by Facebook, now hosted on Apache.
Thrift includes a complete stack for creating clients and servers. The top part is generated code from the Thrift definition. From this file, the services generate client and processor codes. In contrast to built-in types, created data structures are sent as a result of generated code. The protocol and transport layer are part of the runtime library. With Thrift, it is possible to define a service and change the protocol and transport without recompiling the code. Besides the client part, Thrift includes server infrastructure to tie protocols and transports together, like blocking, non-blocking and multi-threaded servers. The underlying I/O part of the stack is implemented differently for different languages.
Thrift supports a number of protocols:
The supported transports are:
ByteArrayOutputStream
internally.Thrift also provides a number of servers, which are:
Some stated benefits of Thrift include:
ArrayList<String>
. C++ uses std::vector<std::string>
.Thrift is written in C++, but can create code for a number of languages. To create a Thrift service, one has to write Thrift files that describe it, generate the code in the destination language, write some code to start the server and call it from the client. Here is a code example of such a description file:
enum PhoneType {
HOME,
WORK,
MOBILE,
OTHER
}
struct Phone {
1: i32 id,
2: string number,
3: PhoneType type
}
service PhoneService {
Phone findById(1: i32 id),
list<Phone> findAll()
}
Thrift will generate the code out of this descriptive information. For instance, in Java, the PhoneType
will be a simple enum
inside the Phone
class.
Thrift is a separate Apache project which is a binary communication protocol
Through a simple and straightforward Interface Definition Language (IDL), Thrift allows to define and create services which are both consumable by and serviceable by numerous languages. Using code generation, Thrift creates a set of files which can then be used for creating clients and/or servers. In addition to interoperability, Thrift can be very efficient through a unique serialization mechanism that is efficient in both time and space.
Thrift supports many programming languages too varying degrees. The complete list is below. Be careful before assuming that just because your language has some support that it supports all of Thrift's features. Python for example, only supports TBinaryProtocol. Cocoa, C++, C#, Erlang, Haskell, Java, OCaml, Perl, PHP, Python, Ruby, and Smalltalk
The top portion of the stack is generated code from your Thrift definition file. Thrift services result in generated client and processor code. These are represented by the brown boxes in the diagram. The data structures that are sent (other than built-in types) also result in generated code. These result in the red boxes. The protocol and transport are part of the Thrift runtime library. Therefore with Thrift, you can define a service, and are free to change the protocol and transport without re-generating your code. Thrift also includes a server infrastructure to tie the protocols and transports together. There are blocking, non-blocking, single and multi-threaded servers available. The "Underlying I/O" portion of the stack differs based on the language in question. For Java and Python network I/O, the built-in libraries are leveraged by the Thrift library, while the C++ implementation uses its own custom implementation.