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 ++ คุณสามารถ
จินตนาการประชากรชั้นเรียนเหล่านี้และใช้พวกเขาในการส่งข้อความเช่น
ต่อไปนี้: