Protocol Buffers are a method of serializing structured data.
As such, they are useful in developing programs to communicate with each other over a wire
or for storing data.
The method involves an interface description language that describes the structure of some
data and a program that generates from that description source code in various programming
languages for generating or parsing a stream of bytes that represents the structured data.
Google developed Protocol Buffers for use internally and has made protocol compilers
for C++, Java and Python available to the public under a free software, open source
license.
Various other language implementations are also available.
The design goals for Protocol Buffers emphasized simplicity and performance.
In particular, it was designed to be smaller and faster than XML.
Third parties have reported that protocol buffers outperform the standardized Abstract
Syntax Notation One with respect to both message size and decoding performance.
Protocol Buffers are widely used at Google for storing and interchanging all kinds of
structured information.
Protocol Buffers serve as a basis for a custom remote procedure call system that is used
for nearly all inter-machine communication at Google.
Protocol Buffers are very similar to the Apache Thrift protocol, except that the public Protocol
Buffers implementation does not include a concrete RPC protocol stack to use for defined
services.
A software developer defines data structures and services in a proto definition file and
compiles it with protoc.
This compilation generates code that can be invoked by a sender or recipient of these
data structures.
For example, example.proto will produce example.pb.cc and example.pb.h, which will define C++ classes
for each message and service that example.proto defines.
Canonically, Protocol Buffers are serialized into a binary wire format which is compact,
forwards-compatible, and backwards-compatible, but not self-describing.
There is no defined way to include or refer to such an external specification within a
Protocol Buffer file.
The officially supported implementation includes an ASCII serialization format, but this format
— though self-describing — loses the forwards-and-backwards-compatibility behavior, and is thus not a good choice for
applications other than debugging.
Though the primary purpose of Protocol Buffers is to facilitate network communication, their
simplicity and speed make Protocol Buffers an alternative to data-centric C++ classes
and structs, especially where interoperability with other languages or systems might be needed
in the future.
Example A schema for a particular use of protocol
buffers associates data types with field names, using integers to identify each field.:
The "Point" message defines two mandatory data items, x and y.
The data item label is optional.
Each data item has a tag.
The tag is defined after the equal sign.
For example, x has the tag 1.
The "Line" and "Polyline" messages, which both use Point, demonstrate how composition
works in Protocol Buffers.
Polyline has a repeated field, which behaves like a vector.
This schema can subsequently be compiled for use by one or more programming languages.
Google provides a compiler called protoc which can produce output for C++, Java or Python.
Other schema compilers are available from other sources to create language-dependent
output for over 20 other languages.
For example, after a C++ version of the protocol buffer schema above is produced, a C++ source
code file, polyline.cpp, can use the message objects as follows:
See also
Comparison of data serialization formats References
External links Official project page at code.google.com
Another official home page at Google Open Source project hosting
Protocol Buffers Objective-C Protocol Buffers Apple Swift