Protobuf: codice strutturato con Protocol Buffers

La strutturazione dei dati svolge un ruolo importante nello sviluppo di programmi e siti web. Se i dati di un progetto sono ben strutturati, possono essere letti da altri software con facilità e precisione. Sul web, questo è particolarmente importante per i motori di ricerca testuali come Google, Bing o Yahoo, che sono in grado di catturare in modo ottimale il contenuto di un sito web grazie a un markup adeguato e strutturato.

In generale, l’utilizzo di dati strutturati nello sviluppo software, sia per applicazioni web sia desktop, è utile ovunque i programmi o i servizi debbano scambiare dati tramite interfacce e si desideri un’elevata velocità di elaborazione dei dati. Questo articolo spiega il ruolo che può svolgere il formato di serializzazione Protocol Buffers (Protobuf) e come questo metodo di strutturazione si differenzia dalla ben nota alternativa JSONP.

Dal 2008, Google offre al grande pubblico i Protocol Buffers, in breve Protobuf, vale a dire un formato di scambio dati originariamente sviluppato per uso interno come progetto open source (parzialmente con licenza Apache 2.0). Il formato binario consente alle applicazioni di memorizzare e scambiare dati strutturati in modo semplice; questi programmi possono anche essere scritti in diversi linguaggi di programmazione. Tra i linguaggi supportati vi sono:

• C#
• C++
• Go
• Objective-C
• Java
• Python
• Ruby

Protobuf viene utilizzato, tra l’altro, in combinazione con HTTP e RPC (Remote Procedurel Calls) per la comunicazione client-server locale e remota, in particolare per la descrizione delle interfacce necessarie a questo scopo. La composizione del protocollo è definita anche con la sigla gRPC.

Nello sviluppo di Protobuf, Google ha posto particolare enfasi su due fattori: semplicità e prestazione. In origine, come già detto, il formato era destinato a sostituire l’analogo formato XML all’interno dell’azienda. Oggi è in concorrenza anche con altre soluzioni, come JSON(P) o FlatBuffers. Un’analisi delle caratteristiche e dei punti di forza di questo metodo di strutturazione mostra che i Protocol Buffers rappresentano comunque la scelta migliore per molti progetti:

La base di ogni applicazione di successo è un sistema di database ben organizzato. L’organizzazione di questo sistema, compresi i dati in esso contenuti, è spesso oggetto di molta attenzione, ma quando successivamente i dati vengono inoltrati a un servizio esterno, le strutture sottostanti vanno perse. Codificando i dati secondo lo schema dei Protocol Buffers, è garantito che il vostro progetto inoltri i dati strutturati come desiderato, senza rompere queste strutture.

L’implementazione di Protobuf elimina il noioso compito di eseguire i controlli di versione, di solito associato al cosiddetto codice “ugly” (it. brutto, scritto male.) Per mantenere la compatibilità all’indietro con le versioni precedenti e la compatibilità in avanti con le nuove versioni, i buffer di protocollo accedono a campi numerati che fungono da punti di riferimento per l’accesso ai servizi. Ciò significa che non è sempre necessario adattare il codice completo per rilasciare nuove caratteristiche e funzioni.

Con la codifica del Protobuf, si utilizzano automaticamente dei modificatori (a scelta tra richiesti, opzionali o ripetitivi) che rendono il lavoro di programmazione molto più facile. Ad esempio, il metodo di strutturazione permette di determinare la forma della struttura dei dati a livello di schema, dove i dettagli d’implementazione delle classi utilizzate per i diversi linguaggi di programmazione sono regolati automaticamente. Inoltre, è possibile modificare lo stato in qualsiasi momento, ad esempio da “richiesto” a “opzionale”. Anche la trasmissione delle strutture dati può essere regolata tramite i buffer di protocollo: codificando le strutture generiche di richiesta e risposta, si garantisce facilmente un trasferimento dati flessibile e sicuro tra più servizi.

A seconda del tipo e della complessità di un progetto, il codice Boilerplate (o semplicemente Boilerplate) gioca un ruolo più o meno decisivo nella programmazione. In parole povere, si tratta di blocchi di codice riutilizzabili, necessari in molti punti di un software e di solito solo leggermente adattabili. Spesso tale codice serve, ad esempio, a predisporre l’utilizzo delle funzioni delle librerie. Essi sono comuni soprattutto nei linguaggi web JavaScript, PHP, HTML e CSS, anche se ciò non è ottimale per le prestazioni dell’applicazione web. Un adeguato schema di Procotol Buffers aiuta a ridurre il codice Boilerplate e quindi a migliorare le prestazioni a lungo termine.

Oggi le applicazioni non sono più scritte in un solo linguaggio, ma combinano parti di programma o moduli di diversi tipi di linguaggio. Protobuf semplifica notevolmente l’interazione dei singoli componenti del codice: se vengono aggiunti nuovi componenti il cui linguaggio differisce da quello corrente del progetto, è sufficiente far tradurre lo schema dei Protocol Buffers nel rispettivo linguaggio di destinazione utilizzando l’apposito generatore di codice, riducendo così al minimo il proprio sforzo. Naturalmente, i linguaggi utilizzati devono essere quelli supportati da Protobuf di default, come i linguaggi già elencati, o aggiunti tramite add-on di terze parti.

Per prima cosa, Google ha sviluppato i Protocol Buffers come alternativa a XML (Extensible Markup Language) e ha superato il linguaggio di markup su molti aspetti. Ad esempio, la strutturazione dei dati con Protobuf tende non solo ad essere più semplice, ma, secondo il gigante dei motori di ricerca, fornisce anche una struttura dei dati che è da tre a dieci volte più piccola e da 20 a 100 volte più veloce di una simile struttura XML.

I Protocol Buffers sono spesso confrontati anche con il linguaggio di markup JavaScript JSON (JavaScript Object Notation), anche se va detto che entrambe le tecnologie sono state progettate con obiettivi diversi: JSON è un formato di messaggio che ha origine in JavaScript, scambia i suoi messaggi in formato testo ed è supportato praticamente da tutti i comuni linguaggi di programmazione. Protobuf ha più di un formato di messaggio, dal momento che la tecnologia Google offre anche varie regole e strumenti per definire e scambiare messaggi. Protobuf batte JSON anche in termini di prestazioni quando si guarda all’invio di messaggi in generale, ma la seguente tabella “Protobuf vs JSON” mette in evidenza che le due tecniche di strutturazione hanno ciascuna i propri vantaggi e svantaggi:

Quindi, se avete bisogno di un formato di serializzazione ben documentato che memorizzi e trasmetta i dati strutturati in forma chiaramente leggibile, dovreste usare JSON. Ciò è particolarmente vero se la componente lato server dell’applicazione è scritta in JavaScript e se gran parte dei dati viene elaborata di default direttamente dai browser. Se, d’altra parte, la flessibilità e le prestazioni della struttura dei dati giocano un ruolo decisivo, i buffer di protocollo tendono ad essere la soluzione più efficiente e più indicata.

I buffer di protocollo possono fare la differenza in molti progetti software, ma come spesso accade, il primo passo è quello di conoscere e applicare le caratteristiche speciali e i trucchi sintattici della tecnologia di serializzazione. Per darvi una prima idea della sintassi e dello scambio di messaggi di Protobuf, nel seguente tutorial trovate i passaggi fondamentali, dalla definizione del proprio formato in file .proto alla compilazione delle strutture dei Protocol Buffers. Come esempio, viene utilizzato come codice base una semplice applicazione Java per la rubrica, che può leggere le informazioni di contatto da un file e scriverle in un altro file. I parametri “nome”, “ID”, “indirizzo e-mail” e “numero di telefono” sono assegnati ad ogni voce della rubrica.

Per prima cosa occorre descrivere una qualsiasi struttura di dati che si intende implementare con i buffer di protocollo nel file .proto, il file di configurazione standard del formato di serializzazione. Per ogni struttura che si vuole serializzare in questo file, cioè mappare in sequenza, è sufficiente aggiungere un messaggio (“message”). Si specificano quindi i nomi e i tipi per ogni campo di questo messaggio e si aggiungono i modificatori desiderati. É obbligatorio un modificatore per ogni campo.

Per la rubrica Java, una possibile mappatura delle strutture dati nel file .proto è la seguente:

La sintassi dei buffer di protocollo ricorda fortemente C++ o Java. La versione Protobuf è sempre dichiarata in primo luogo qui: proto3, seguita dalla descrizione del pacchetto software di cui si vogliono strutturare i dati. Questo include un nome univoco (“tutorial”) e, in questo esempio di codice, le due opzioni specifiche per Java: “java_package” (pacchetto Java in cui sono memorizzate le classi generate) e “java_outer_classname” (nome della classe sotto la quale sono raggruppate le classi).

Seguono i messaggi del Protobuf, che possono essere composti da un numero qualsiasi di campi, con tipi di dati tipici come “bool”, “int32”, “float”, “double” o “string”. Anche questi sono in parte utilizzati nell’esempio. Come già detto, ad ogni campo di un messaggio deve essere assegnato almeno un modificatore e può essere:

• required: un valore per questo campo è obbligatorio. Se questo valore manca, il messaggio rimane “uninitialized”, cioè non inizializzato o non inviato.
• optional: un valore può essere fornito in un campo opzionale, ma non è necessario che lo sia. In caso contrario, viene utilizzato un valore definito come standard. Ad esempio, nel codice riportato sopra, per il tipo di numero di telefono viene inserito il valore predefinito “HOME” (numero di rete fissa di casa).
• repeated: i campi con il modificatore “repeated” possono essere ripetuti tutte le volte che si desidera (anche zero volte).

Potete trovare istruzioni dettagliate su come definire il proprio formato di dati con i buffer di protocollo nel Google Developer Forum.

Una volta che le proprie strutture dati sono state definite nel file .proto come richiesto, generate le classi necessarie per leggere e scrivere i messaggi Protobuf. A tal fine applicate il compilatore di buffer di protocollo (protoc) al file di configurazione. Se non l’avete ancora installato, scaricate l’ultima versione nell’ufficiale GitHub Repository. Decomprimete il file ZIP nella posizione desiderata e avviate il compilatore con un doppio clic.

Infine, specificate

• la directory sorgente dove si trova il codice del vostro programma (qui carattere jolly “SRC_DIR”),
• la directory di destinazione dove deve essere memorizzato il codice generato (qui carattere jolly “DST_DIR”)
• e il percorso per il file .proto.

Poiché si desidera generare classi Java, utilizzate anche l’opzione --java_out (opzioni simili sono disponibili anche per gli altri linguaggi supportati). Il comando completo per la compilazione è il seguente: