Protocol Buffers, aussi connu sous le nom de Protobuf, est un format de sérialisation avec un langage de description d'interface développé par Google. L'implémentation d'origine publiée par Google pour C++, Java et Python est disponible sous une licence libre. Des implémentations pour d'autres langages sont disponibles ou en cours de développement[2].
| Développé par | |
|---|---|
| Première version | 2001 |
| Dernière version | 35.1 (11 juin 2026)[1] |
| Dépôt | github.com/protocolbuffers/protobuf |
| Écrit en | C++ |
| Environnement | Multiplateforme (d) |
| Type |
Format de sérialisation de données (d) Interface description language Format de fichier (en) |
| Licence | Licence BSD |
| Site web | protobuf.dev |
Son intérêt concerne le développement de programmes ayant à communiquer les uns avec les autres sur un réseau ou pour simplement stocker des données. La méthode est basée sur un langage de description d’interface décrivant une structure des données. Un programme pourra alors générer ou analyser les messages en fonction de cette description.
Google a développé le Protocol Buffers pour un usage interne. Il a réalisé un générateur de code pour différents langages sous licence open source.
La conception du Protocol Buffers avait pour objectif la simplicité et la performance avec pour objectif d’être plus léger et plus rapide que le XML.
Le Protocol Buffers est largement utilisé chez Google pour le stockage et l’échange de toutes sortes de structures d’informations. Cette méthode sert de système RPC (remote procedure call) personnalisé utilisé pour quasiment l’ensemble des communications inter-machines de la compagnie.
Les Protocol Buffers sont très similaires au protocole Apache Thrift (utilisé par Facebook par exemple), sauf que l’implémentation publique du Protocole Buffers ne comprend pas de véritable ensemble de protocoles RPC voué à des services spécifiques.
Un développeur logiciel définira les structures de données (messages) et services au sein d’un fichier .proto et le transpilera via protoc. Cette compilation génèrera le code qui pourra être invoqué par un expéditeur ou destinataire de telles structures de données. Par exemple, example.proto génèrera les fichiers example.pb.cc et example.pb.h, définissant les classes C++ pour chaque message et service que example.proto déclare.
Les messages sont sérialisés sous un format binaire compact, avec une compatibilité ascendante et descendante, mais non auto-descriptive (ainsi, il est impossible de connaître les labels, signification ou types de données des champs sans les spécifications). Il n’y a pas de moyen défini pour inclure ou faire référence à de telles spécifications au sein du fichier Protocol Buffers.
Exemple
modifiermessage Point {
required int32 x = 1;
required int32 y = 2;
optional string label = 3;
}
message Line {
required Point start = 1;
required Point end = 2;
optional string label = 3;
}
message Polyline {
repeated Point point = 1;
optional string label = 2;
}
Le message « Point » définit deux propriétés obligatoires, « x » et « y ». La propriété « label » est facultative. Chaque propriété a une étiquette, définie par un signe égal, par exemple « x » a l'étiquette 1.
Les messages « Line » et « Polyline » sont composés, ils utilisent « Point » dans leurs définitions. Le champ de type « repeated » (répétition) dans Polyline agit comme un vecteur.
Cette définition est ensuite compilée, en appelant protoc, pour être utilisée par un logiciel C++ de la manière suivante :
#include "polyline.pb.h" // généré en appelant protoc polyline.proto (définition ci-dessus)
Line* createNewLine(const std::string& name) {
Line* line = new Line;
line->mutable_start()->set_x(10);
line->mutable_start()->set_y(20);
line->mutable_end()->set_x(30);
line->mutable_end()->set_y(40);
line->set_label(name);
return line;
}
Polyline* createNewPolyline() {
Polyline* polyline = new Polyline;
Point* point1 = polyline->add_point();
point1->set_x(10);
point1->set_y(10);
Point* point2 = polyline->add_point();
point2->set_x(10);
point2->set_y(10);
return polyline;
}
Articles connexes
modifier- Apache Thrift
- Apache Parquet
- Abstract Syntax Notation One (ASN.1)
- Etch de Cisco
- gRPC, framework RPC open source initialement développé par Google, utilisant Protocol Buffers
- « M » de Microsoft
- Internet Communications Engine (ICE) de ZeroC
Références
modifier- ↑ « Release 35.1 », 11 juin 2026 (consulté le 12 juin 2026)
- ↑ (en) « Protocolbuffers/protobuf », sur GitHub (consulté le 27 septembre 2020).
