Protocol Buffers

Un article de Wikipédia, l'encyclopédie libre.
Aller à : navigation, rechercher
image illustrant l’informatique
Cet article est une ébauche concernant l’informatique.

Vous pouvez partager vos connaissances en l’améliorant (comment ?) selon les recommandations des projets correspondants.

Protocol Buffers
Développeur Google
Dernière version 2.6.1 ()
Type Bibliothèque et format de sérialisation, compilateur IDL
Licence Licence BSD
Site web code.google.com/apis/protocolbuffers

Protocol Buffers 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[1].

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 de 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 en-tête 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 toute sorte 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 compilera 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éfini.

Les messages sont sérialisés sous un format binaire compacte, 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[modifier | modifier le code]

message 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 | modifier le code]

Références[modifier | modifier le code]

Liens externes[modifier | modifier le code]