serialization in apache thrift

the processes of serialization and de-serialization are by far the most essential operations done within an apache thrift framework. since the data structures need to be sent over the clients and the servers, the operations are fundamental in these transaction processes.

this tutorial aims to explain how these processes are carried out in detail interacting with the way thrift encodes and transforms usable data into transmittable data (serialization), and finally transforms the transmittable data into usable data (de-serialization).

data types in thrift

before diving into serialization, it is important to understand the basic data types supported by thrift, as these are the building blocks of the serialized data.

basic data types

following are the basic data types supported by thrift −

bool: represents a boolean value (true or false).
byte: represents an 8-bit signed integer.
i16: represents a 16-bit signed integer.
i32: represents a 32-bit signed integer.
i64: represents a 64-bit signed integer.
double: represents a double-precision floating-point number.
string: represents a utf-8 encoded string.

complex data types

following are the complex data types supported by thrift −

list<t>: an ordered collection of elements of type t.
set<t>: an unordered collection of unique elements of type t.
map<k, v>: a collection of key-value pairs where k is the key type and v is the value type.
struct: a user-defined composite type that groups related fields.
enum: a set of named integer constants.

serialization process

serialization in thrift involves converting data types defined in the thrift idl (interface definition language) into a binary or textual format that can be easily transmitted over a network or stored for later use.

thrift provides several protocols for serialization, including tbinaryprotocol, tcompactprotocol, and tjsonprotocol, each with its own advantages and use cases.

following are the basic steps used for performing serialization process −

step 1: choose the protocol

the first step in the serialization process is deciding which serialization protocol to use based on the requirements of your application −

tbinaryprotocol: suitable for applications where performance and efficiency are critical.
tcompactprotocol: best for scenarios where a compact data representation is needed.
tjsonprotocol: ideal for applications that require human-readable data and easy integration with web technologies.

step 2: create the protocol factory

next, you need to create a protocol factory. the protocol factory is responsible for producing protocol objects that will handle the serialization and deserialization of data −

from thrift.protocol import tbinaryprotocol

protocol_factory = tbinaryprotocol.tbinaryprotocolfactory()

step 3: serialize data

using the generated thrift code (based on your idl file), you can now serialize your data structure into the chosen protocol format. this involves creating an in-memory transport for the serialization process, and then using the protocol to write the data −

from thrift.transport import ttransport
from example.ttypes import person

# create an in-memory transport for serialization
transport = ttransport.tmemorybuffer()
protocol = protocol_factory.getprotocol(transport)

# example struct from thrift idl
person = person(name="alice", age=30)

# serialize the data
person.write(protocol)
serialized_data = transport.getvalue()

step 4: transmit or store serialized data

once the data is serialized, it can be transmitted over the network or stored for later use. the serialized data is in a format that can be easily de-serialized back into the original data structure on the receiving end.

protocols and their use cases

apache thrift provides multiple protocols for serialization and deserialization, each designed to meet different needs in terms of performance, data size, and readability.

understanding the specific use cases for each protocol helps in choosing the right one for your application.

tbinaryprotocol: efficient and fast binary serialization. best for performance-critical applications.
tcompactprotocol: more compact binary serialization. useful when reducing the size of the data is important.
tjsonprotocol: json-based serialization. ideal for readability and integration with web technologies.

Save or share this article