Protocol Buffers

Origem: Wikipédia, a enciclopédia livre.
Protocol Buffers
Desenvolvedor Google
Plataforma Multiplataforma
Lançamento Início de 2001 (interno)[1]
, 7 de julho de 2008; há 15 anos (público)
Versão estável 3.3.0 (5 de maio de 2017; há 6 anos)
Sistema operacional Independente
Gênero(s) formato e biblioteca de serialização, compilador de linguagem de descrição de interface
Licença BSD
Página oficial developers.google.com/protocol-buffers/

Protocol Buffers (também conhecido como protobuf) é um método de serialização de dados estruturados. É útil no desenvolvimento de programas que se comunicam uns com os outros ou para armazenar dados. O método envolve uma linguagem de descrição de interface que descreve a estrutura de dados e um programa que gera código-fonte a partir dessa descrição para a geração ou a análise de um fluxo de bytes que representa os dados estruturados.

O Google desenvolveu Protocol Buffers para usar internamente e ofereceu um gerador de código para várias linguagens em uma licença de código aberto.

As metas do design de Protocol Buffers enfatizaram a simplicidade e desempenho. Em particular, ele foi projetado para ser menor e mais rápido do que XML.[2]

Protocol Buffers são amplamente utilizados pelo Google para o armazenamento e intercâmbio de vários tipos de informações estruturadas. O método serve como base para uma chamada de procedimento remoto (RPC) personalizada do sistema que é usado por quase todas as comunicações inter-máquina do Google.[3]

Protocol Buffers são semelhantes ao Apache Thrift (utilizado pelo Facebook) e aos Microsoft Bond protocolos, oferecendo assim uma pilha de protocolos RPC concreta chamada gRPC.[4]

Um desenvolvedor de software define estruturas de dados (chamadas de mensagens) e serviços em um arquivo de definição proto (.proto) e os compila com um programa chamado protoc. Esta compilação gera código que pode ser invocado por um remetente ou destinatário destas estruturas de dados. Por exemplo, exemplo.proto vai produzir exemplo.pb.cc e exemplo.pb.h, que irão implementar classes de C++ para cada mensagem definida em exemplo.proto.

Canonicamente, as mensagens são serializadas em um protocolo binário compacto, com compatibilidade reversa e direta, mas não são auto-descritivas (isto é, não há nenhuma maneira de saber os nomes, significados, ou tipos de dados dos campos de uma mensagem sem uma especificação externa). Não há nenhuma forma predefinida de incluir ou referir-se a essa especificação externa (esquema) dentro de um arquivo de Protocol Buffers. Implementações oficialmente suportadas incluem um formato de serialização em ASCII,[5] mas este formato, embora auto-descritivo, perde o compatibilidade de comportamento reversa e direta, e não é, portanto, uma boa escolha para aplicações e deve ser usada somente para depuração.

Embora o objetivo principal de Protocol Buffers seja facilitar a comunicação em rede, sua simplicidade e velocidade fazem de Protocol Buffers uma alternativa para classes e estruturas em C++ centradas em dados, especialmente onde a interoperabilidade com outras linguagens ou sistemas pode ser necessária no futuro.

Exemplo[editar | editar código-fonte]

Um esquema para um determinado uso de Protocol Buffers associa tipos de dados com nomes de campo, utilizando números inteiros para identificar cada campo. (os dados do protocolo contém apenas os números, não os nomes de campo, fornecendo economia de largura de banda e armazenamento em comparação com sistemas que incluem os nomes de campos de dados.) 

//polilinha.proto
syntax = "proto2";

message Ponto {
  required int32 x = 1;
  required int32 y = 2;
  optional string etiqueta = 3;
}

message Linha {
  required Ponto inicio = 1;
  required Ponto fim = 2;
  optional string etiqueta = 3;
}

message Polilinha {
  repeated Ponto ponto = 1;
  optional string etiqueta = 2;
}

Há três mensagens definidas no exemplo acima. A mensagem "Ponto" define dois campos obrigatórios (required), x e y. O campo etiqueta é opcional (optional). Cada campo tem um número, que é definido após o sinal de igual. Por exemplo, x tem o número 1. Ambas as mensagens "Linha" e "Polilinha" utilizam Ponto, demonstrando como mensagens podem ser compostas em Protobuf. Polilinha tem um campo repetido (repeated), que se comporta como um arranjo.

Este esquema pode, posteriormente, ser compilado para uso por uma ou mais linguagens de programação. O Google fornece um compilador chamado protoc que pode produzir C++, Java ou Python. Outros compiladores do esquema são oferecidos por outras fontes para criar um resultado independente de linguagem para mais de 20 linguagens.[6]

Por exemplo, depois que uma versão em C++ do esquema acima é produzido, o arquivo de código fonte em C++, polyline.cpp, pode utilizar objetos de mensagem da seguinte maneira: 

// polilinha.cpp
#include "polilinha.pb.h"  // gerado chamando "protoc polilinha.proto"

Linha *criarNovaLinha(const std::string &nome) {
  // criar uma linha de (10, 20) até (30, 40)
  Linha *linha = new Linha;
  linha->mutable_inicio()->set_x(10);
  linha->mutable_inicio()->set_y(20);
  linha->mutable_fim()->set_x(30);
  linha->mutable_fim()->set_y(40);
  linha->set_etiqueta(nome);
  return linha;
}

Polilinha *criarNovaPolilinha() {
  // criar polilinha com pontos em (10,10) e (20,20)
  Polilinha *polilinha = new Polilinha;
  Ponto *ponto1 = polilinha->add_ponto();
  ponto1->set_x(10);
  ponto1->set_y(10);
  Ponto *ponto2 = polilinha->add_ponto();
  ponto2->set_x(20);
  ponto2->set_y(20);
  return polilinha;
}

Suporte de linguagens[editar | editar código-fonte]

A versão proto2 fornece um gerador de código para C++, Java, C#,[7] e Python.[8] Implementações de terceiros também estão disponíveis para JavaScript.[9]

A versão proto3 fornece um gerador de código para C++, Java (incluindo JavaNano, um dialeto destinado a ambientes com recursos limitados), Python, Go, Ruby, Objective-C e C#.[10] Desde 3.0.0 Beta 2 também há suporte para JavaScript.[11] Implementações de terceiros também estão disponíveis para Perl, PHP, R, Scala, Swift e Julia.[12]

Referências[editar | editar código-fonte]

  1. ↑ «Frequently Asked Questions | Protocol Buffers». Google Developers. Consultado em 2 de outubro de 2016 
  2. ↑ Eishay Smith. «jvm-serializers Benchmarks». Consultado em 12 de julho de 2010 
  3. ↑ Kenton Varda. «A response to Steve Vinoski». Consultado em 14 de julho de 2008 
  4. ↑ «grpc». grpc.io. Consultado em 2 de outubro de 2016 
  5. ↑ «text_format.h - Protocol Buffers - Google Code» 
  6. ↑ ThirdPartyAddOns - protobuf - Links to third-party add-ons. - Protocol Buffers - Google's data interchange format - Google Project Hosting. Code.google.com. Retrieved on 2013-09-18.
  7. ↑ «Protocol Buffers in C#». Code Blockage 
  8. ↑ «Protocol Buffers Language Guide». Google Developers 
  9. ↑ «Protocol Buffers for JavaScript.» 
  10. ↑ «Protocol Buffers Language Guide (proto3)». Google Developers 
  11. ↑ «Protocol Buffers v3.0.0-beta-2». Google Developers 
  12. ↑ «ThirdPartyAddOns - protobuf - Links to third-party add-ons. - Protocol Buffers - Google's data interchange format - Google Project Hosting» 

Ligações externas[editar | editar código-fonte]

Obtida de "https://pt.wikipedia.org/w/index.php?title=Protocol_Buffers&oldid=67624485"