Protobuf — wat is het, binair gegevensformaat en werkingsprincipe

Wat zijn Protocol Buffers?

Protocol Buffers is een door Google ontwikkeld mechanisme voor serialisatie van gestructureerde gegevens, vergelijkbaar met JSON en XML, maar met een fundamenteel verschil: gegevens worden gecodeerd in binair formaat. Dit betekent dat een Protobuf-bericht niet met het blote oog kan worden gelezen, maar aanzienlijk minder ruimte inneemt en sneller wordt verwerkt dan tekstuele tegenhangers.

Protobuf is intern bij Google gemaakt om prestatieproblemen bij gegevensuitwisseling tussen diensten op te lossen. In 2008 werd de technologie een open-source project met ondersteuning voor vele talen: C++, Java, Python, Go, JavaScript, Kotlin, Swift, Dart en andere. Versie proto3, uitgebracht in 2016, vereenvoudigde de syntax en voegde ondersteuning voor meer talen toe.

Het belangrijkste verschil tussen Protobuf en JSON is de noodzaak om een schema te definiëren voordat gegevensuitwisseling begint. Het schemabestand (.proto) beschrijft de berichtstructuur: velden, typen en unieke veldnummers. Uit dit schema genereert de protoc-compiler klassen in de doeltaal voor serialisatie en deserialisatie.

Protobuf ecosysteem

• gRPC — hoogwaardig RPC-framework dat standaard Protobuf gebruikt
• protoc — compiler van .proto schema’s naar code in verschillende programmeertalen
• Google API — de meeste openbare Google API’s gebruiken Protobuf
• Envoy Proxy — gebruikt Protobuf voor configuratie en gegevensuitwisseling

Protobuf architectuur

Protobuf architectuur omvat drie belangrijke componenten: de schemadefinitietaal (.proto), de protoc-compiler en runtime-bibliotheken voor specifieke talen. De ontwikkelaar beschrijft de gegevensstructuur in een .proto-bestand, start de compilatie en ontvangt kant-en-klare klassen om met deze gegevens te werken.

Elk veld in een Protobuf-bericht heeft een uniek nummer (field number) — dit is geen volgnummer, maar een tag die in binair formaat wordt gebruikt om het veld te identificeren. Nummers 1 tot 15 worden gecodeerd met één byte, nummers 16 tot 2047 met twee bytes. Daarom is het raadzaam belangrijke velden met hoge gebruiksfrequentie te nummeren van 1 tot 15 voor optimalisatie van de grootte.

Protobuf gegevenstypen

Protobuf ondersteunt een breed scala aan typen: scalair (int32, int64, float, double, bool, string, bytes), enumeraties (enum), samengesteld (message) en speciaal (oneof, map). Elk type heeft een specifieke binaire representatie, geoptimaliseerd voor het desbetreffende gebruiksscenario.

Voordelen van binair formaat

Protobuf biedt drie belangrijke voordelen ten opzichte van tekstformaten: berichtgrootte, serialisatiesnelheid en strikte typering. In hoogbelaste systemen en mobiele applicaties met beperkt verkeer worden deze voordelen kritiek.

De binaire representatie van Protobuf gebruikt variable-length encoding (Varint) voor getallen: kleine getallen nemen 1 byte in beslag, grote tot 10 bytes. Dit maakt efficiënte codering mogelijk van identifiers, vlaggen en tellers die in JSON of XML tientallen bytes als tekststrings zouden innemen. Het getal 150 neemt bijvoorbeeld 2 bytes in beslag in Protobuf, 3 bytes in JSON (als tekst „150”) en 3 bytes + tags in XML.

Een bijkomend voordeel is terugwaartse compatibiliteit. Het toevoegen van een nieuw veld aan een schema breekt geen oude clients: ze negeren eenvoudigweg onbekende velden. Het verwijderen van een veld vereist alleen het reserveren van het nummer om toekomstige conflicten te voorkomen.

.proto schema definiëren

.proto schema beschrijft de gegevensstructuur in een speciale taal. Het bestand begint met het specificeren van de syntax (proto3), het pakket en het importeren van afhankelijkheden. Elk bericht wordt gedefinieerd met het sleutelwoord message met velden, waarbij elk veld een type, naam en uniek nummer heeft.

Regels voor een goed schema: veldnummers 1 tot 15 voor veelgebruikte velden, betekenisvolle namen, groeperen van gerelateerde velden in afzonderlijke message, gebruik van oneof voor velden die slechts een van meerdere opties kunnen zijn.

syntax = "proto3";

package mobileapp;

message User {
  string user_id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
  UserRole role = 5;
  repeated string tags = 6;
  map<string, string> metadata = 7;
}

enum UserRole {
  USER_ROLE_UNSPECIFIED = 0;
  USER_ROLE_USER = 1;
  USER_ROLE_ADMIN = 2;
  USER_ROLE_MODERATOR = 3;
}

Geneste berichten

Berichten kunnen worden genest: het veld profile van het type Profile zal de gebruikersgegevens bevatten. Ondersteuning voor nesting maakt het mogelijk complexe hiërarchische structuren te beschrijven zonder definitieduplicatie.

syntax = "proto3";

package mobileapp;

message Order {
  string order_id = 1;
  repeated OrderItem items = 2;
  double total_price = 3;
  PaymentInfo payment = 4;
}

message OrderItem {
  string product_id = 1;
  string title = 2;
  int32 quantity = 3;
  double price = 4;
}

message PaymentInfo {
  string method = 1;
  string transaction_id = 2;
  double amount = 3;
}

Code genereren uit .proto

De protoc-compiler converteert .proto-bestanden naar broncode in de doeltaal. Voor Kotlin/Java wordt de parameter --java_out gebruikt, voor Swift --swift_out (via de Apple Swift Protobuf-plugin), voor Dart --dart_out. De gegenereerde klassen bevatten builder-methoden voor het construeren van berichten en serialisatie-/deserialisatiemethoden.

Op Android wordt voor het werken met Protobuf de plugin com.google.protobuf versie 0.9+ in Gradle gebruikt. Na het toevoegen van de plugin en het specificeren van .proto-bestanden, genereert de compilatie automatisch Kotlin-klassen die klaar zijn voor gebruik in de applicatie.

import com.google.protobuf.kotlin.toByteString
import com.example.mobileapp.UserOuterClass.User

fun createUser(): User {
    return User.newBuilder()
        .setUserId("usr_001")
        .setName("IT Sectr")
        .setEmail("team@itsectr.com")
        .setAge(5)
        .setRole(UserOuterClass.UserRole.USER_ROLE_ADMIN)
        .addTags("mobile")
        .addTags("backend")
        .build()
}

fun serializeAndDeserialize(user: User): User {
    // Serialisatie naar binair formaat
    val bytes = user.toByteArray()

    // Deserialisatie uit binair formaat
    return User.parseFrom(bytes)
}

Voorbeelden van Protobuf gebruik

Protobuf is bijzonder effectief in microservice-architectuur en mobiele applicaties. Laten we een typisch scenario beschouwen: een mobiele applicatie ontvangt een productlijst van de server via gRPC. Het Protobuf-bericht bevat productinformatie, waaronder identificatie, naam, prijs en categorie. Het binaire formaat verkleint de responsgrootte 5-8 keer in vergelijking met JSON.

gRPC-service in Kotlin

Voorbeeld van een gRPC-service met Protobuf aan de serverzijde. De service declareert de RPC-methode GetProducts, die een verzoek met pagineringsparameters ontvangt en een productlijst retourneert. De implementatie in Kotlin gebruikt de gegenereerde klassen voor het werken met verzoeken en antwoorden.

import com.example.mobileapp.ProductServiceGrpcKt
import com.example.mobileapp.ProductOuterClass.Product
import com.example.mobileapp.ProductOuterClass.GetProductsRequest
import com.example.mobileapp.ProductOuterClass.GetProductsResponse

class ProductService : ProductServiceGrpcKt.ProductServiceCoroutineImplBase() {

    override suspend fun getProducts(
        request: GetProductsRequest
    ): GetProductsResponse {
        val products = fetchProductsFromDb(
            page = request.page,
            limit = request.limit
        )

        return GetProductsResponse.newBuilder()
            .addAllProducts(products)
            .setTotalCount(products.size)
            .build()
    }
}

Protobuf instellen in Android project

Protobuf instellen in een Android-project gebeurt via de Gradle-plugin com.google.protobuf. De plugin start automatisch de protoc-compiler tijdens de compilatie en genereert Kotlin-klassen uit .proto-bestanden. Voor de werking moet de plugin worden toegevoegd aan build.gradle op projectniveau en worden toegepast in de applicatiemodule.

Na het configureren van Gradle worden .proto-bestanden geplaatst in de map src/main/proto. De protoc-compiler verwerkt ze bij elke compilatie en genereert Kotlin-klassen die in de applicatiecode kunnen worden gebruikt. Het is belangrijk de juiste versies van protobuf en protoc te specificeren om afhankelijkheidsconflicten met andere bibliotheken van het project te voorkomen.

Voor iOS-projecten wordt Protobuf aangesloten via CocoaPods of Swift Package Manager. De Swift Protobuf-plugin genereert automatisch Swift-structuren die voldoen aan het Codable-protocol. In Dart-projecten voor Flutter wordt het pakket protobuf gebruikt en vindt compilatie plaats via dart run protoc_plugin.