Les plus grandes différences de Thrift vs Protocol Buffers?
Quels sont les principaux avantages et inconvénients de Apache Thrift vs Les tampons de protocole de Google ?
Ils offrent tous deux beaucoup des mêmes caractéristiques; Cependant, il y a quelques différences:
- Thrift prend en charge les "exceptions"
- Les tampons de protocole ont une documentation et des exemples bien meilleurs
- Thrift a un type intégré
Set - Les tampons de protocole autorisent les "extensions" - vous pouvez étendre un proto externe pour ajouter des champs supplémentaires, tout en permettant au code externe de fonctionner sur les valeurs. Il n'y a aucun moyen de faire cela dans Thrift
- Je trouve les tampons de protocole beaucoup plus faciles à lire
En gros, ils sont assez équivalents (avec les tampons de protocole légèrement plus efficaces que ce que j'ai lu).
Une autre différence importante concerne les langues prises en charge par défaut.
- Tampons de protocole: Java, Android Java, C++, Python, Ruby, C #, Go, Objective-C, Node.js
- Thrift: Java, C++, Python, Ruby, C #, Go, Objective-C, JavaScript, Node.js, Erlang, PHP, Perl, Haskell, Smalltalk, OCaml, Delphi, D, Haxe
Les deux pourraient être étendus à d'autres plates-formes, mais ce sont les liaisons de langues disponibles prêtes à l'emploi.
RPC est une autre différence clé. Thrift génère du code pour implémenter les clients et les serveurs RPC, alors que les tampons de protocole semblent principalement conçus comme un format d'échange de données uniquement.
- Les objets sérialisés Protobuf sont environ 30% plus petits que Thrift.
- La plupart des actions que vous pouvez faire avec les objets protobuf (créer, sérialiser, désérialiser) sont beaucoup plus lente que thrift sauf si vous activez
option optimize_for = SPEED. - Thrift a des structures de données plus riches (Map, Set)
- Protobuf API semble plus propre, bien que les classes générées soient toutes regroupées comme des classes internes, ce qui n’est pas très agréable.
- Les enums Thrift ne sont pas de véritables Java Enums, c’est-à-dire qu’ils ne sont que des ints. Protobuf a de vrais enums Java.
Pour examiner de plus près les différences, consultez les différences de code source dans ce projet open source .
Comme je l'ai dit en tant que "Thrift vs Protocol buffers" topic:
En se référant à comparaison Thrift vs Protobuf vs JSON :
- Thrift prend en charge AS3, C++, C #, D, Delphi, Go, Graphviz, Haxe, Haskell, Java, Javascript, Node.js, OCaml, Smalltalk, TypeScript, Perl, PHP, Python, Ruby, ...
- C++, Python, Java - prise en charge intégrée à Protobuf
- Le support de Protobuf pour d'autres langues (y compris Lua, Matlab, Ruby, Perl, R, Php, OCaml, Mercury, Erlang, Go, D, LISP) est disponible en tant que tiers addons (au fait. Voici le support SWI-Prolog ).
- Protobuf a une documentation bien meilleure et de nombreux exemples.
- Thrift est livré avec un bon tutoriel
- Les objets Protobuf sont plus petits
- Protobuf est plus rapide quand on désactive "optimise_pour = VITESSE"
- Thrift a intégré la mise en œuvre RPC, tandis que les solutions Protobuf RPC sont séparées, mais disponibles (comme Zeroc ICE ).
- Protobuf est publié sous licence de type BSD
- Thrift est publié sous licence Apache 2
En outre, il existe de nombreux outils supplémentaires intéressants disponibles pour ces solutions, qui pourraient décider. Voici des exemples pour Protobuf: Protobuf-Wirehark , protobufeditor .
J'ai pu obtenir de meilleures performances avec un protocole texte par rapport à Protobuff sur Python. Cependant, aucune vérification de type ou autre conversion de fantaisie utf8, etc ... qui offre protobuff.
Donc, si la sérialisation/désérialisation est tout ce dont vous avez besoin, vous pouvez probablement utiliser autre chose.
http://dhruvbird.blogspot.com/2010/05/protocol-buffers-vs-http.html
Une chose évidente qui n’a pas encore été mentionnée est que cela peut être à la fois un avantage ou un inconvénient (et est identique pour les deux) c’est que ce sont des protocoles binaires. Cela permet une représentation plus compacte et éventuellement plus de performances (pros), mais avec une lisibilité réduite (ou plutôt, une mise au point), un inconvénient.
En outre, les deux ont un peu moins de prise en charge des outils que les formats standard tels que xml (et peut-être même json).
(EDIT) Voici une Comparaison intéressante qui aborde à la fois les différences de taille et de performances, et inclut des chiffres pour certains autres formats (xml, json).
Les tampons de protocole semblent avoir une représentation plus compacte, mais ce n'est qu'une impression que me donne la lecture du livre blanc Thrift. Dans leurs propres mots:
Nous avons décidé de ne pas utiliser certaines optimisations extrêmes en matière de stockage (regrouper Petits entiers dans ASCII ou utiliser un format de continuation de 7 bits). dans un souci de simplicité et de clarté du code. Ces modifications peut facilement être faite si et quand nous rencontrons une performance critique cas d'utilisation qui les exige.
En outre, c'est peut-être juste mon impression, mais les tampons de protocole semblent avoir des abstractions plus épaisses autour du versioning de structure. Thrift prend en charge le contrôle de version, mais cela demande un peu d'effort.
ProtocolBuffers est plus rapide.
Il y a un repère de Nice ici:
http://code.google.com/p/thrift-protobuf-compare/wiki/Benchmarking
Vous voudrez peut-être aussi vous pencher sur Avro, qui est encore plus rapide.
Microsoft a un paquet ici:
http://www.nuget.org/packages/Microsoft.Hadoop.Avro
À propos, le plus rapide que j'ai jamais vu est Cap'nProto ;
Une implémentation en C # est disponible dans le répertoire Github de Marc Gravell .
Et selon le wiki le runtime Thrift ne fonctionne pas sous Windows.
Je pense que la plupart de ces points ont manqué le fait fondamental que Thrift est un framework RPC, ce qui permet de sérialiser des données en utilisant une variété de méthodes (binaire, XML, etc.).
Les tampons de protocole sont conçus uniquement pour la sérialisation, ce n'est pas un framework comme Thrift.
D'une part, protobuf n'est pas une implémentation complète de RPC. Il faut quelque chose comme gRPC pour aller avec.
le GPRC est très lent comparé à Thrift:
Il est également important de noter que toutes les langues prises en charge ne concordent pas toujours avec épargne ou protobuf. À ce stade, il s’agit de l’implémentation des modules en plus de la sérialisation sous-jacente. Veillez à vérifier les points de repère pour la langue que vous prévoyez d’utiliser.
Il y a d'excellents points ici et je vais en ajouter un autre au cas où le chemin de quelqu'un se croise ici.
Thrift vous offre la possibilité de choisir entre sérialiseur thrift-binary et thrift-compact, thrift-binary aura une excellente performance mais une taille de paquet plus grande, tandis que thrift-compact vous donnera une bonne compression mais nécessite plus de puissance de traitement. Ceci est pratique car vous pouvez toujours basculer entre ces deux modes aussi facilement que modifier une ligne de code (enfin, rendez-le configurable). Par conséquent, si vous n’êtes pas sûr du degré d’optimisation de votre application en fonction de la taille du paquet ou de la puissance de traitement, épargnez peut devenir un choix intéressant.
PS: Voir cet excellent projet de référence de thekvs qui compare de nombreux sérialiseurs, y compris thrift-binary, thrift-compact et protobuf: https://github.com/thekvs/cpp-serializers
PS: Il existe un autre sérialiseur nommé YAS qui donne également cette option, mais il n’existe pas de schéma. Voir le lien ci-dessus.