stringtranslate.com

Buffers de protocolo

Protocol Buffers ( Protobuf ) es un formato de datos multiplataforma, gratuito y de código abierto que se utiliza para serializar datos estructurados. Es útil para desarrollar programas que se comunican entre sí a través de una red o para almacenar datos. El método implica un lenguaje de descripción de interfaz que describe la estructura de algunos datos y un programa que genera código fuente a partir de esa descripción para generar o analizar un flujo de bytes que representa los datos estructurados.

Descripción general

Google desarrolló Protocol Buffers para uso interno y proporcionó un generador de código para múltiples idiomas bajo una licencia de código abierto .

Los objetivos de diseño de Protocol Buffers enfatizaron la simplicidad y el rendimiento. En particular, se diseñó para que fuera más pequeño y más rápido que XML . [3]

En Google, Protocol Buffers se utiliza ampliamente para almacenar e intercambiar todo tipo de información estructurada. El método sirve como base para un sistema de llamada a procedimiento remoto (RPC) personalizado que se utiliza para casi todas las comunicaciones entre máquinas en Google. [4]

Protocol Buffers es similar a los protocolos Apache Thrift , Ion y Microsoft Bond, y ofrece una pila de protocolos RPC concreta para usar en servicios definidos llamados gRPC . [5]

Los esquemas de estructuras de datos (llamados mensajes ) y los servicios se describen en un archivo de definición de proto ( .proto) y se compilan con protoc. Esta compilación genera código que puede ser invocado por un remitente o destinatario de estas estructuras de datos. Por ejemplo, example.pb.ccy example.pb.hse generan a partir de example.proto. Definen clases de C++ para cada mensaje y servicio en example.proto.

Canónicamente, los mensajes se serializan en un formato de cable binario que es compacto, compatible con versiones anteriores y posteriores , pero no autodescriptivo (es decir, no hay forma de saber los nombres, el significado o los tipos de datos completos de los campos sin una especificación externa). No hay una forma definida de incluir o hacer referencia a dicha especificación externa (esquema) dentro de un archivo Protocol Buffers. La implementación oficialmente admitida incluye un formato de serialización ASCII, [6] pero este formato, aunque autodescriptivo, pierde el comportamiento de compatibilidad con versiones anteriores y posteriores, y por lo tanto no es una buena opción para aplicaciones que no sean la edición y depuración humanas. [7]

Aunque el propósito principal de Protocol Buffers es facilitar la comunicación en red, su simplicidad y velocidad hacen de Protocol Buffers una alternativa a las clases y estructuras de C++ centradas en datos, especialmente donde podría necesitarse interoperabilidad con otros lenguajes o sistemas en el futuro.

Limitaciones

Los protobufs no tienen una única especificación. [8] El formato es más adecuado para fragmentos de datos pequeños que no superan unos pocos megabytes y se pueden cargar o enviar a una memoria de inmediato y, por lo tanto, no es un formato que se pueda transmitir. [9] La biblioteca no proporciona compresión de fábrica. El formato tampoco tiene un buen soporte en lenguajes no orientados a objetos (por ejemplo, Fortran ). [10]

Ejemplo

Un esquema para un uso particular de los buffers de protocolo asocia los tipos de datos con los nombres de los campos, utilizando números enteros para identificar cada campo. (Los datos del buffer de protocolo contienen solo los números, no los nombres de los campos, lo que permite ahorrar algo de ancho de banda y almacenamiento en comparación con los sistemas que incluyen los nombres de los campos en los datos).

// polilinea.proto sintaxis = "proto2" ;  mensaje Punto { requerido int32 x = 1 ; requerido int32 y = 2 ; opcional cadena etiqueta = 3 ; }                 mensaje Línea { requerido Punto inicial = 1 ; requerido Punto final = 2 ; opcional cadena etiqueta = 3 ; }                 mensaje Polilínea { Punto repetido punto = 1 ; cadena opcional etiqueta = 2 ; }            

El mensaje "Point" define dos elementos de datos obligatorios, x e y . La etiqueta del elemento de datos es opcional. Cada elemento de datos tiene una etiqueta. La etiqueta se define después del signo igual. Por ejemplo, x tiene la etiqueta 1.

Los mensajes "Línea" y "Polilínea", que utilizan puntos, demuestran cómo funciona la composición en los búferes de protocolo. La polilínea tiene un campo repetido y, por lo tanto, se comporta como un conjunto de puntos (de un número no especificado).

Este esquema puede compilarse posteriormente para su uso en uno o más lenguajes de programación. Google ofrece un compilador llamado protocque puede generar resultados para C++, Java o Python. Existen otros compiladores de esquemas disponibles en otras fuentes para crear resultados dependientes del lenguaje para más de 20 lenguajes diferentes. [11]

Por ejemplo, después de producir una versión C++ del esquema de búfer de protocolo anterior, un archivo de código fuente C++, polyline.cpp, puede usar los objetos de mensaje de la siguiente manera:

// polyline.cpp #include "polyline.pb.h"  // generado al llamar al "protocolo polyline.proto" Línea * createNewLine ( const std :: string & name ) { // crea una línea desde (10, 20) hasta (30, 40) Línea * línea = new Línea ; línea -> mutable_start () -> set_x ( 10 ); línea -> mutable_start () -> set_y ( 20 ); línea -> mutable_end () -> set_x ( 30 ); línea -> mutable_end () -> set_y ( 40 ); línea -> set_label ( nombre ); return línea ; }                 Polilínea * createNewPolyline () { // crea una polilínea con puntos en (10,10) y (20,20) Polilínea * polilínea = new Polilínea ; Punto * punto1 = polilínea -> add_point (); punto1 -> set_x ( 10 ); punto1 -> set_y ( 10 ); Punto * punto2 = polilínea -> add_point (); punto2 -> set_x ( 20 ); punto2 -> set_y ( 20 ); return polilínea ; }                      

Soporte de idiomas

Protobuf 2.0 proporciona un generador de código para C++ , Java , C# , [12] y Python . [13]

Protobuf 3.0 proporciona un generador de código para C++ , Java (incluido JavaNano, un dialecto destinado a entornos de bajos recursos ), Python , Go , Ruby , Objective-C y C# . [14] También es compatible con JavaScript desde 3.0.0-beta-2. [15]

También hay implementaciones de terceros disponibles para Ballerina , [16] C , [17] [18] C++ , [19] Dart , Elixir , [20] [21] Erlang , [22] Haskell , [23] JavaScript , [24] Julia , [25] Nim , [26] Perl , PHP , Prolog , [27] [28] R , [29] Rust , [30] [31] [32] Scala , [33] y Swift . [34]

Véase también

Referencias

  1. ^ "Preguntas frecuentes | Buffers de protocolo". Google Developers . Consultado el 2 de octubre de 2016 .
  2. ^ "Lanzamientos - google/protobuf" – vía GitHub .
  3. ^ Eishay Smith. "Puntos de referencia de jvm-serializers". GitHub . Consultado el 12 de julio de 2010 .
  4. ^ Kenton Varda. "Una respuesta a Steve Vinoski" . Consultado el 14 de julio de 2008 .
  5. ^ "grpc". grpc.io . Consultado el 2 de octubre de 2016 .
  6. ^ "text_format.h - Buffers de protocolo - Código de Google" . Consultado el 2 de marzo de 2012 .
  7. ^ "Proto Best Practices | Documentación de Protocol Buffers" . Consultado el 26 de mayo de 2023 .
  8. ^ "Descripción general". protobuf.dev . Consultado el 28 de mayo de 2023 .
  9. ^ "Descripción general". protobuf.dev . Consultado el 28 de mayo de 2023 .
  10. ^ "Descripción general". protobuf.dev . Consultado el 28 de mayo de 2023 .
  11. ^ ThirdPartyAddOns - protobuf - Enlaces a complementos de terceros. - Protocol Buffers - Formato de intercambio de datos de Google - Google Project Hosting. Code.google.com. Consultado el 18 de septiembre de 2013.
  12. ^ "Buffers de protocolo en C#". Bloqueo de código . Consultado el 12 de mayo de 2017 .
  13. ^ "Guía del lenguaje de búferes de protocolo". Google Developers . Consultado el 21 de abril de 2016 .
  14. ^ "Guía de lenguaje (proto3) | Buffers de protocolo". Google Developers . Consultado el 9 de agosto de 2020 .
  15. ^ "Release Protocol Buffers v3.0.0-beta-2 · protocolbuffers/protobuf". GitHub . Consultado el 9 de agosto de 2020 .
  16. ^ "Bailarina - GRPC". Archivado desde el original el 15 de noviembre de 2021. Consultado el 24 de marzo de 2021 .
  17. ^ "Nanopb - buffers de protocolo con tamaño de código pequeño" . Consultado el 12 de diciembre de 2017 .
  18. ^ "Implementación de buffers de protocolo en C". GitHub . Consultado el 12 de diciembre de 2017 .
  19. ^ "Embedded Proto - Protobuf para microcontroladores" . Consultado el 15 de agosto de 2021 .
  20. ^ "Protox". GitHub . 25 de octubre de 2021.
  21. ^ "Protobuf-elixir". GitHub . 26 de octubre de 2021.
  22. ^ "Tomás-abrahamsson/GPB". GitHub . 19 de octubre de 2021.
  23. ^ "Proto-lente". GitHub . 16 de octubre de 2021.
  24. ^ "Buffers de protocolo para JavaScript". github.com . Consultado el 14 de mayo de 2016 .
  25. ^ "ThirdPartyAddOns - protobuf - Enlaces a complementos de terceros. - Protocol Buffers - Formato de intercambio de datos de Google - Google Project Hosting" . Consultado el 7 de noviembre de 2012 .
  26. ^ "Implementación de Protobuf en Nim puro que aprovecha el poder del sistema de macros para no depender de ninguna herramienta externa". GitHub . 21 de octubre de 2021.
  27. ^ "SWI-Prolog: Biblioteca de buffers de protocolo de Google".
  28. ^ "SWI-Prolog / contrib-protobufs". GitHub . Consultado el 21 de abril de 2022 .
  29. ^ "RProtoBuf". GitHub .
  30. ^ "Rust-protobuf". GitHub . 26 de octubre de 2021.
  31. ^ "¡PROST!". GitHub . 21 de agosto de 2021.
  32. ^ "Quick-protobuf". GitHub . 12 de octubre de 2021.
  33. ^ "ScalaPB". GitHub . Consultado el 27 de septiembre de 2022 .
  34. ^ "Swift Protobuf". GitHub . 26 de octubre de 2021.

Enlaces externos