There is a single way of defining a

There is a single way of defining a structured data format that then is exchanged and
serialized in protocol buffers. This is done by defining a buffer message type in
a .proto file. Each protocol buffer message then represents a logical record of information
in this format. Each message then contains a series of name-value pairs using this syntax.
Here is a very basic example of a .proto file that defines a message containing information
for an address book entry:As you can see, the message format is rather straightforward. Each message type has at
least one uniquely numbered field, and each field has a name and a value type. Note
that value types can be numbers (i.e., integer or floating-point), booleans, strings, raw
bytes, or other protocol buffer message types (as in the previous example). These other
types allow one to structure data hierarchically, in a manner that allows for customization
and flexibility to suit the needs of the application. Optional fields, required fields,
and repeated fields can be specified as well, and we showed that in the previous example
with the repeated PhoneNumber portion indicating that four entries are repeated.
Once the data structure types and formats are defined, a number of protocol buffer
compiler tools are available that can generate source code from these types in order to
write and read these. These tools are available for a wide variety of data stream types as
well as for a variety of languages, including Java, Python, Perl, and C++. Once messages
have been defined, one of the protocol buffer compilers is run for a particular target
language. This compiler is fed the .proto file or files as input, and that generates data
access classes. Part of this process generates access functions for each field (i.e., query()
or set_query()) as well as methods to serialize or parse the already defined data structures
to/from raw bytes—so, for instance, if your chosen language is C++, running the
compiler on the earlier example will generate a class called PersonalRecord. You can
then use this class in your application to populate, serialize, and send and retrieve Person protocol buffer messages.One very cool feature of protocol buffers is that code that is generated for receiving
messages will ignore structures with additional fields not defined in the version of the
code compiled. This means that absolute compatibility between sides of the discussion
need not be precise. This is allowed because its designers were concerned with server
upgrades required as the APIs evolved rapidly and wanted to obviate the need to upgrade
all of the servers at once. On a small scale, this might not seem like a big deal, but for a
company like Google, upgrading tens of thousands of servers in a short period of time
can definitely be an issue.
Getting back to the example, if you examine the newly generated C++ code, you can
imagine populating these classes and using them to transmit a message such as the
following:

ผลลัพธ์ (ไทย) 1:

มีวิธีเดียวของการกำหนดรูปแบบข้อมูลแล้ว มีการแลกเปลี่ยน และอนุกรมในบัฟเฟอร์การโพรโทคอล โดยการกำหนดชนิดของข้อความเป็นบัฟเฟอร์ในไฟล์.proto แต่ละโพรโทคอลบัฟเฟอร์ข้อความแล้วแสดงบันทึกข้อมูลทางตรรกะในรูปแบบนี้ นอกจากนี้แต่ละข้อความแล้วประกอบด้วยชุดของคู่ค่าของชื่อที่ใช้ไวยากรณ์นี้นี่คือตัวอย่างของแฟ้ม.proto ที่กำหนดข้อความประกอบด้วยข้อมูลพื้นฐานสำหรับรายการสมุดที่อยู่: คุณสามารถดู รูปแบบข้อความค่อนข้างตรงไปตรงมา แต่ละชนิดของข้อความได้ที่อย่างน้อยหนึ่งฟิลด์ที่มีตัวเลขไม่ซ้ำกัน และแต่ละฟิลด์มีชื่อและชนิดของมูลค่า หมายเหตุว่า ชนิดของค่าสามารถเป็นตัวเลข (เช่น จำนวนเต็ม หรือทศนิยม), booleans สาย วัตถุดิบไบต์ หรือชนิดอื่น ๆ ข้อบัฟเฟอร์โพรโทคอล (เช่นในตัวอย่างก่อนหน้านี้) อื่น ๆ เหล่านี้ชนิดอนุญาตให้ข้อมูลโครงสร้างตามลำดับชั้น ในลักษณะที่กำหนดเองและมีความยืดหยุ่นเพื่อให้เหมาะกับความต้องการของแอพลิเคชัน เขตข้อมูล เขตข้อมูลจำเป็นคุณสามารถระบุเขตข้อมูลซ้ำเช่น และเราแสดงให้เห็นว่าในตัวอย่างก่อนหน้านี้มีส่วนซ้ำ PhoneNumber เพื่อระบุว่า รายการสี่มีการทำซ้ำเมื่อกำหนดข้อมูลโครงสร้างชนิดและรูปแบบ จำนวนของบัฟเฟอร์การโพรโทคอลคอมไพเลอร์เครื่องมือที่สามารถสร้างรหัสแหล่งที่มาประเภทนี้เพื่อให้เขียน และอ่านเหล่านี้ เครื่องมือเหล่านี้มีความหลากหลายของชนิดของกระแสข้อมูลเป็นดีสำหรับความหลากหลายของภาษา รวม ถึง Java, Python, Perl, c ++ ข้อความครั้งเดียวการกำหนด คอมไพเลอร์บัฟเฟอร์การโพรโทคอลอย่างใดอย่างหนึ่งจะเรียกใช้เป้าหมายเฉพาะภาษา คอมไพเลอร์นี้จะถูกป้อนแฟ้ม.proto หรือแฟ้มที่เป็น input และที่สร้างข้อมูลเข้าชั้นเรียน เป็นส่วนหนึ่งของกระบวนการนี้สร้างฟังก์ชั่นการเข้าถึงสำหรับแต่ละฟิลด์ (เช่น query()หรือ set_query()) เป็นวิธีการ serialize หรือการแยกวิเคราะห์โครงสร้างข้อมูลที่กำหนดแล้วจากไบต์ raw — ดังนั้น เช่น ถ้าภาษาที่คุณเลือกเป็น c ++, ทำงานคอมไพเลอร์ในตัวอย่างก่อนหน้านี้จะสร้างคลาสที่เรียกว่า PersonalRecord คุณสามารถแล้ว ใช้คลาในโปรแกรมประยุกต์ของคุณเพื่อเติม อนุกรม และส่ง และเรียกข้อความบัฟเฟอร์การโพรโทคอคน คุณลักษณะอย่างหนึ่งเย็นมากของบัฟเฟอร์การโพรโทคอลคือ รหัสที่สร้างขึ้นสำหรับการรับข้อความจะละเว้นโครงสร้างกับฟิลด์เพิ่มเติมที่ไม่ได้กำหนดไว้ในรุ่นนี้รหัสที่คอมไพล์ หมายถึง เข้ากันได้ที่แน่นอนระหว่างด้านของการสนทนาต้องมีความแม่นยำ ได้รับอนุญาตเนื่องจากนักออกแบบที่เกี่ยวข้องกับเซิร์ฟเวอร์การอัพเกรดที่จำเป็น ตาม APIs ที่พัฒนาอย่างรวดเร็ว และต้องการ obviate จำเป็นต้องปรับรุ่นทุกเซิร์ฟเวอร์ในครั้งเดียว ในขนาดเล็ก นี้อาจดูเหมือน เช่นเรื่องสำคัญ แต่สำหรับการบริษัทเช่น Google การปรับรุ่นเซิร์ฟเวอร์นับหมื่นในระยะเวลาสั้น ๆแน่นอนอาจเป็นปัญหาได้การกลับไปตัวอย่าง ถ้าคุณตรวจสอบรหัส c ++สร้างใหม่ คุณสามารถimagine populating these classes and using them to transmit a message such as thefollowing:

ผลลัพธ์ (ไทย) 2:

มีวิธีเดียวในการกำหนดรูปแบบข้อมูลที่มีโครงสร้างที่แล้วมีการแลกเปลี่ยนและมีความ
ต่อเนื่องในบัฟเฟอร์โปรโตคอล นี้จะกระทำโดยการกำหนดประเภทข้อความบัฟเฟอร์ใน
ไฟล์ .proto แต่ละข้อความบัฟเฟอร์โปรโตคอลนั้นหมายถึงการบันทึกตรรกะของข้อมูล
ในรูปแบบนี้ แต่ละข้อความแล้วมีชุดของคู่ค่าชื่อโดยใช้ไวยากรณ์นี้.
นี่เป็นตัวอย่างขั้นพื้นฐานมากของไฟล์ .proto ที่กำหนดข้อความที่มีข้อมูล
สำหรับรายการหนังสือที่อยู่: ในขณะที่คุณสามารถดูรูปแบบข้อความค่อนข้างตรงไปตรงมา ประเภทข้อความแต่ละคนมี
อย่างน้อยหนึ่งฟิลด์หมายเลขที่ไม่ซ้ำกันและแต่ละเขตมีชื่อและชนิดของค่า ทราบ
ว่าประเภทค่าสามารถเป็นตัวเลข (เช่นจำนวนเต็มหรือทศนิยม) booleans สตริงดิบ
ไบต์หรือประเภทข้อความบัฟเฟอร์โปรโตคอลอื่น ๆ (เช่นในตัวอย่างก่อนหน้านี้) อื่น ๆ เหล่านี้
ชนิดหนึ่งที่จะช่วยให้โครงสร้างข้อมูลลำดับชั้นในลักษณะที่ช่วยให้การปรับแต่ง
และมีความยืดหยุ่นเพื่อให้เหมาะกับความต้องการของแอพลิเคชัน เขตเลือกเขตข้อมูลที่จำเป็น
และสาขาซ้ำสามารถระบุได้เช่นกันและเราแสดงให้เห็นว่าในตัวอย่างก่อนหน้านี้
กับส่วน PhoneNumber ซ้ำแสดงให้เห็นว่าสี่รายการมีการทำซ้ำ.
เมื่อประเภทโครงสร้างข้อมูลและรูปแบบจะมีการกำหนดจำนวนของบัฟเฟอร์โปรโตคอล
เครื่องมือคอมไพเลอร์ที่มีอยู่ที่สามารถสร้างรหัสที่มาจากประเภทนี้เพื่อที่จะ
เขียนและอ่านเหล่านี้ เครื่องมือเหล่านี้จะสามารถใช้ได้สำหรับความหลากหลายของประเภทกระแสข้อมูลเป็น
เดียวกับความหลากหลายของภาษารวมทั้ง Java, Python, Perl, และ C ++ เมื่อข้อความ
ได้รับการกำหนดหนึ่งของคอมไพเลอร์บัฟเฟอร์โปรโตคอลมีการเรียกใช้สำหรับเป้าหมายโดยเฉพาะอย่างยิ่ง
ภาษา คอมไพเลอร์นี้จะถูกป้อนไฟล์ .proto หรือไฟล์ที่เป็น input และสร้างข้อมูล
การเรียนการเข้าถึง ส่วนหนึ่งของกระบวนการนี้สร้างฟังก์ชั่นการเข้าถึงสำหรับแต่ละเขต (คือแบบสอบถาม ()
หรือ set_query ()) เช่นเดียวกับวิธีการที่จะเป็นอันดับหรือแยกโครงสร้างข้อมูลที่กำหนดไว้แล้ว
จาก / ไปยังดิบไบต์ดังนั้นสำหรับตัวอย่างเช่นถ้าภาษาที่คุณเลือกเป็น C ++ เรียกใช้
คอมไพเลอร์ในตัวอย่างก่อนหน้านี้จะสร้างชั้นเรียกว่า PersonalRecord คุณสามารถ
แล้วใช้ชั้นนี้ในใบสมัครของคุณเพื่อเติม, ซีเรียและส่งและเรียกบุคคลบัฟเฟอร์โปรโตคอล messages.One คุณสมบัติเย็นมากบัฟเฟอร์โปรโตคอลเป็นรหัสที่ถูกสร้างขึ้นสำหรับการรับ
ข้อความจะไม่สนใจโครงสร้างที่มีเขตข้อมูลเพิ่มเติมไม่ได้กำหนดในรุ่น ของ
รหัสเรียบเรียง ซึ่งหมายความว่าการทำงานร่วมกันระหว่างสองฝ่ายที่แน่นอนของการอภิปราย
ไม่จำเป็นต้องแม่นยำ นี้ได้รับอนุญาตเพราะนักออกแบบมีความกังวลกับเซิร์ฟเวอร์
อัพเกรดต้องเป็น API ที่พัฒนาอย่างรวดเร็วและต้องการที่จะขจัดความจำเป็นในการอัพเกรด
เซิร์ฟเวอร์ทั้งหมดของในครั้งเดียว ในขนาดเล็กนี้ไม่อาจจะดูเหมือนเป็นเรื่องใหญ่ แต่สำหรับ
บริษัท เช่น Google, อัพเกรดนับหมื่นของเซิร์ฟเวอร์ในระยะเวลาสั้น ๆ
แน่นอนสามารถเป็นปัญหา.
เดินทางกลับไปตัวอย่างเช่นถ้าคุณตรวจสอบใหม่ สร้างรหัส c ++ คุณสามารถ
จินตนาการประชากรชั้นเรียนเหล่านี้และใช้พวกเขาในการส่งข้อความเช่น
ต่อไปนี้:

ผลลัพธ์ (ไทย) 3:

有一个方法是一个单一的网络数据格式。然后是defining是exchanged和这是在协议buffers serialized。由defining a message type Done在缓冲区。A . proto协议文件。然后每represents a logical记录缓冲的消息信息。在这个格式。每name-value contains a message，然后使用这个syntax pairs系列。这里是一个很基本的一个例子。defines a message file是proto containing信息为一个地址你可以看到：作为入门书籍！straightforward消息格式，消息是在每型有。至少一个字段，每个字段uniquely numbered has a name和value type类型的描述和一个。这可以是B值（即，numbers），整数规划，或floating-point booleans strings，原字节缓冲区或其他协议的消息，B（As）。在那场These例子一个数据结构B，hierarchically allow for manner是在一个定制的对suit和flexibility的应用领域需求的领域，需要，可选。域可以是specified和重复，我们可以为这场在showed例子这部分indicating PhoneNumber与重复。重复。四是一周的数据结构定义，A和B是number of协议缓冲区。这是generate编译器工具可从这些源代码可以在订单到B这些工具。These read write和品种是有效的为一个数据流作为一个B为一个好的品种为多种语言，包括Java，Python，Perl，C + +和一messages。有一个已定义的协议，是为一个编译器的运行缓冲particular target这是美联储的语言编译器。proto文件作为输入文件。或者，这generates数据这类小型接入。接入过程generates functions for each，场（即query（）。好set_query）或As（）As的方法来定义的数据serialize已经或将structures从原bytes to / for -例如，如果你的SO，粒子是C + +语言，运行的例如在earlier编译器将generate a class .你可以叫PersonalRecord然后在你的应用程序来使用这个类，serialize populate，和人messages.One send和retrieve协议缓冲区。很酷的功能是buffers协议代码，那是KEYS是收到将权限与messages structures additional域定义的版本不在这绝对是compiled代码兼容性。这之间的讨论，阐述了听写的有利一面——这是不需要的。是因为它precise allowed designers是有关与服务器upgrades需要作为一个API的evolved rapidly和wanted想升级到obviate在所有的服务器。在一个小规模的一次，这不可能像一个seem协议为一个大的，但像谷歌公司的服务器，在成千上万的提升tens period of a short time一个问题是绝对不能。获取到的例子，如果你回来examine newly KEYS的C + +代码，你可以使用这些类和他们想象populating a message to，如作为一个传递如下：