快來看看Google出品的Protocol Buffer，別僅僅會用Json和XML了

阿新 • • 發佈：2017-08-01

println 輸出流基本數據類型下一個 ebr sid 官網序列 reg

前言

習慣用 Json、XML 數據存儲格式的你們，相信大多都沒聽過Protocol Buffer
Protocol Buffer 事實上是 Google出品的一種輕量 & 高效的結構化數據存儲格式，性能比 Json、XML 真的強！太！
多！

由於 Google出品，我相信Protocol Buffer已經具備足夠的吸引力
今天，我將獻上一份 Protocol Buffer的介紹 & 使用攻略，希望你們會喜歡。

文件夾

技術分享

1. 定義

一種結構化數據的數據存儲格式（相似於 `XML、Json` ）

Google

出品（開源）

Protocol Buffer 眼下有兩個版本號：proto2 和 proto3

由於proto3 還是beta 版，所以本次解說是 proto2

2. 作用

通過將結構化的數據進行串行化（**序列化**），從而實現 **數據存儲 / RPC 數據交換**的功能

序列化：將數據結構或對象轉換成二進制串的過程

反序列化：將在序列化過程中所生成的二進制串轉換成數據結構或者對象的過程

3. 特點

對照於常見的 XML、Json 數據存儲格式。Protocol Buffer

有例如以下特點：

技術分享

4. 應用場景

數據傳輸量大 & 網絡環境不穩定的數據存儲、RPC 數據交換 的需求場景

如即時IM （QQ、微信）的需求場景

總結

在 數據傳輸量較大的需求場景下，Protocol Buffer比XML、Json 更小、更快、使用 & 維護更簡單！

5. 使用流程

使用 Protocol Buffer 的流程例如以下：

技術分享

5.1 環境配置

要使用Protocol Buffer 。須要先在電腦上安裝Protocol Buffer
整個安裝過程僅僅須要依照以下步驟進行就可以：

整個安裝過程請自備梯子以保證網絡暢通

步驟1：下載 `Protocol Buffer` 安裝包

下載方式1：官網下載（須要FQ）
下載方式2：貼心的我 已經給你們準備好了，請移步百度網盤。password：paju

此處選擇較穩定的版本號 protobuf-2.6.1.tar.gz 進行演示
下載成功後，對文件進行解壓，例如以下圖：

步驟2：安裝 `HOMEBREW`（已安裝的能夠跳過）

// 打開 終端 輸入以下指令
/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

步驟3：安裝 `Protocol Buffer`

打開 您的終端 依次輸入下列指令就可以：

brew install autoconf automake libtool curl
// Step1：安裝 Protocol Buffer 依賴
// 註：Protocol Buffer 依賴於  autoconf、automake、libtool、curl

cd Desktop/protobuf-2.6.1
// Step2：進入 Protocol Buffer安裝包 解壓後的文件夾（我的解壓文件放在桌面）

./autogen.sh
// Step3：執行 autogen.sh 腳本

 ./configure
// Step4：執行 configure.sh 腳本

 make
// Step5：編譯未編譯的依賴包

 make check
// Step6：檢查依賴包是否完整

make install
// Step7：開始安裝Protocol Buffer

步驟4：檢查 `Protocol Buffer` 是否成功安裝

// 在 終端 下輸入
protoc - - version

出現 libprotoc 2.6.1 提示即表示成功安裝。例如以下圖

技術分享

特別註意：

protoc = Protocol Buffer的編譯器
作用：將 .proto文件 編譯成相應平臺的 頭文件和源碼文件
在以下會詳細介紹

至此， Protocol Buffer已經安裝完畢。以下將解說怎樣詳細使用Protocol Buffer

5.2 構建 `Protocol Buffer` 消息對象模型

5.2.1 構建步驟

技術分享

以下將通過一個實例（Android（Java） 平臺為例）詳細介紹每一個步驟。

5.2.2 詳細介紹

實例說明：構建一個Person類的數據結構。包括成員變量name、id、email等等

// Java類

public class Person
{
    private String name;
    private Int id;
    private String email;
...
}

平臺使用：以 Android（Java） 平臺為例來進行演示

步驟1：通過 `Protocol Buffer` 語法描寫敘述須要存儲的數據結構

新建一個文件，命名規則為：文件名稱 = 類名，後綴為 .proto

此處叫Demo.proto

依據上述數據結構的需求。在Demo.proto裏通過 Protocol Buffer 語法寫入相應 .proto對象模型的代碼，例如以下：

package protocobuff_Demo;
// 關註1：包名

option java_package = "com.carson.proto";
option java_outer_classname = "Demo";
// 關註2：option選項

// 關註3：消息模型
// 以下詳細說明
// 生成 Person 消息對象（包括多個字段。以下詳細說明）
message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;

  enum PhoneType {
    MOBILE = 0;
    HOME = 1;
    WORK = 2;
  }

  message PhoneNumber {
    required string number = 1;
    optional PhoneType type = 2 [default = HOME];
  }

  repeated PhoneNumber phone = 4;
}

message AddressBook {
  repeated Person person = 1;
}

以下將結合上述樣例對 Protocol Buffer 語法進行詳細介紹

技術分享

關註1：包名

package protocobuff_Demo;
// 關註1：包名

作用：防止不同 .proto 項目間命名發生沖突
Protocol buffer包的解析過程例如以下：
1. Protocol buffer 的類型名稱解析與 C++ 一致：從最內部開始查找，依次向外進行
  
  每一個包會被看作是其父類包的內部類
2. Protocol buffer 編譯器會解析 .proto文件裏定義的全部類型名
3. 生成器會依據不同語言生成相應語言的代碼文件
  a. 即對不同語言使用了不同的規則進行處理
  b. Protoco Buffer提供 C++、Java、Python 三種語言的 API

關註2：Option選項

option java_package = "com.carson.proto";
option java_outer_classname = "Demo";
// 關註2：option選項

作用：影響特定環境下的處理方式

但不改變整個文件聲明的含義
經常使用Option選項例如以下：

option java_package = "com.carson.proto"; // 定義：Java包名 // 作用：指定生成的類應該放在什麽Java包名下 // 註：如不顯式指定，默認包名為：依照顧用名稱倒序方式進行排序 option java_outer_classname = "Demo"; // 定義：類名 // 作用：生成相應.java 文件的類名（不能跟以下message的類名同樣） // 註：如不顯式指定，則默覺得把.proto文件名稱轉換為首字母大寫來生成 // 如.proto文件名稱="my_proto.proto"，默認情況下，將使用 "MyProto" 做為類名 option optimize_for = ***; // 作用：影響 C++ & java 代碼的生成 // ***參數例如以下： // 1. SPEED (默認):：protocol buffer編譯器將通過在消息類型上執行序列化、語法分析及其它通用的操作。（最優方式） // 2. CODE_SIZE:：編譯器將會產生最少量的類，通過共享或基於反射的代碼來實現序列化、語法分析及各種其它操作。 // 特點：採用該方式產生的代碼將比SPEED要少非常多。可是效率較低； // 使用場景：經常使用在包括大量.proto文件但不追求效率的應用中。 //3. LITE_RUNTIME:：編譯器依賴於執行時核心類庫來生成代碼（即採用libprotobuf-lite 替代libprotobuf）。 // 特點：這樣的核心類庫要比全類庫小得多（忽略了一些描寫敘述符及反射）；編譯器採用該模式產生的方法實現與SPEED模式不相上下，產生的類通過實現 MessageLite接口，但它僅僅是Messager接口的一個子集。

// 應用場景：移動手機平臺應用 option cc_generic_services = false; option java_generic_services = false; option py_generic_services = false; // 作用：定義在C++、java、python中，protocol buffer編譯器是否應該基於服務定義產生抽象服務代碼（2.3.0版本號前該值默認 = true） // 自2.3.0版本號以來，官方覺得通過提供代碼生成器插件來對 RPC實現更可取，而不是依賴於“抽象”服務 optional repeated int32 samples = 4 [packed=true]; // 假設該選項在一個整型基本類型上被設置為真，則採用更緊湊的編碼方式（不會對數值造成損失） // 在2.3.0版本號前。解析器將會忽略非期望的包裝值。因此，它不可能在不破壞現有框架的兼容性上而改變壓縮格式。 // 在2.3.0之後，這樣的改變將是安全的。解析器能夠接受上述兩種格式。 optional int32 old_field = 6 [deprecated=true]; // 作用：推斷該字段是否已經被棄用 // 作用同 [email protected]

在 ProtocolBuffers 中同意自己定義選項並使用
該功能屬於高級特性。使用頻率非常低，此處只是多描寫敘述。有興趣可查看官方文檔

關註3：消息模型

作用：真正用於描寫敘述數據結構

// 消息對象用message修飾
message Person {

  required string name = 1;
  required int32 id = 2;
  optional string email = 3;

  enum PhoneType {
    MOBILE = 0;
    HOME = 1;
    WORK = 2;
  }

  message PhoneNumber {
    optional PhoneType type = 2 [default = HOME];
  }

  repeated PhoneNumber phone = 4;
}

message AddressBook {
  repeated Person person = 1;
}

組成：在 ProtocolBuffers 中：
1. 一個 .proto 消息模型 = 一個 .proto文件 = 消息對象 + 字段
2. 一個消息對象（Message） = 一個結構化數據
3. 消息對象（Message）裏的字段 = 結構化數據裏的成員變量

技術分享

以下會詳細介紹 .proto 消息模型裏的消息對象 & 字段

技術分享

1. 消息對象

在 ProtocolBuffers 中：

一個消息對象（Message） = 一個結構化數據
消息對象用修飾符 message 修飾
消息對象含有字段：消息對象（Message）裏的字段 = 結構化數據裏的成員變量

技術分享

特別註意：

技術分享

a. 加入：在一個 .proto文件中可定義多個消息對象

應用場景：盡可能將與某一消息類型相應的響應消息格式定義到同樣的 .proto文件中
實例：

message SearchRequest {

  required string query = 1;
  optional int32 page_number = 2;
  optional int32 result_per_page = 3;

}

// 與SearchRequest消息類型 相應的 響應消息類型SearchResponse
message SearchResponse {
 …
}

b. 一個消息對象裏能夠定義另外一個消息對象（即嵌套）

message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;

// 該消息類型 定義在 Person消息類型的內部
// 即Person消息類型 是 PhoneNumber消息類型的父消息類型
  message PhoneNumber {
    required string number = 1;
  }
}

<-- 多重嵌套 -->
message Outer {   // Level 0
  message MiddleAA {  // Level 1
    message Inner {   // Level 2
      required int64 ival = 1;
      optional bool  booly = 2;
    }
  }
}

2. 字段

消息對象的字段組成主要是：字段 = 字段修飾符 + 字段類型 +字段名 +標識號

技術分享

以下將對每一項詳細介紹

a. 字段修飾符

作用：設置該字段解析時的規則
詳細類型例如以下：

技術分享

b. 字段類型

字段類型主要有三類：

基本數據類型
枚舉類型
消息對象類型

message Person {

  // 基本數據類型 字段
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;

  enum PhoneType {
    MOBILE = 0;
    HOME = 1;
    WORK = 2;
  }

  message PhoneNumber {
    optional PhoneType type = 2 [default = HOME];
    // 枚舉類型 字段
  }

  repeated PhoneNumber phone = 4;
  // 消息類型 字段
}

1. 基本數據類型

.proto基本數據類型相應於各平臺的基本數據類型例如以下：
技術分享

2. 枚舉類型

作用：為字段指定一個可能取值的字段集合

該字段僅僅能從該指定的字段集合裏取值
說明：如以下樣例，電話號碼可能是手機號、家庭電話號或工作電話號的當中一個。那麽就將PhoneType定義為枚舉類型，並將加入電話的集合（ MOBILE、 HOME、WORK）

// 枚舉類型須要先定義才幹進行使用

// 枚舉類型 定義
 enum PhoneType {
    MOBILE = 0;
    HOME = 1;
    WORK = 2;
// 電話類型字段 僅僅能從 這個集合裏 取值
  }

// 特別註意：
// 1. 枚舉類型的定義可在一個消息對象的內部或外部
// 2. 都能夠在 同一.proto文件 中的不論什麽消息對象裏使用
// 3. 當枚舉類型是在一消息內部定義，希望在 還有一個消息中 使用時。須要採用MessageType.EnumType的語法格式

  message PhoneNumber {
    required string number = 1;
    optional PhoneType type = 2 [default = HOME];
    // 使用枚舉類型的字段（設置了默認值）
  }

// 特別註意：
// 1.  枚舉常量必須在32位整型值的範圍內
// 2. 不推薦在enum中使用負數：由於enum值是使用可變編碼方式的。對負數不夠高

額外說明

當對一個使用了枚舉類型的.proto文件使用 Protocol Buffer編譯器編譯時，生成的代碼文件裏：

對 Java 或 C++來說。將有一個相應的 enum 文件
對 Python 來說。有一個特殊的EnumDescriptor 類

被用來在執行時生成的類中創建一系列的整型值符號常量（symbolic constants）

3. 消息對象類型

一個消息對象能夠將其它消息對象類型用作字段類型。情況例如以下：

技術分享

3.1 使用同一個 .proto 文件裏的消息類型

a. 使用內部消息類型

目的：先在消息類型中定義其它消息類型。然後再使用

即嵌套，須要用作字段類型的消息類型定義在該消息類型裏
實例：

message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;

// 該消息類型 定義在 Person消息類型的內部
// 即Person消息類型 是 PhoneNumber消息類型的父消息類型
  message PhoneNumber {
    required string number = 1;
  }

  repeated PhoneNumber phone = 4;
  // 直接使用內部消息類型
}

b. 使用外部消息類型

即外部重用。須要用作字段類型的消息類型定義在該消息類型外部

message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;
}

message AddressBook {
  repeated Person person = 1;
  // 直接使用了 Person消息類型作為消息字段
}

c. 使用外部消息的內部消息類型

message Person {
  required string name = 1;
  required int32 id = 2;
  optional string email = 3;

// PhoneNumber消息類型 是 Person消息類型的內部消息類型
  message PhoneNumber {
    required string number = 1;
    optional PhoneType type = 2 [default = HOME];
  }
}

// 若父消息類型外部的消息類型須要重用該內部消息類型
// 須要以 Parent.Type 的形式去使用
// Parent = 須要使用消息類型的父消息類型。Type = 須要使用的消息類型

// PhoneNumber父消息類型Person 的外部 OtherMessage消息類型 須要使用 PhoneNumber消息類型
message OtherMessage {
  optional Person.PhoneNumber phonenumber = 1;
// 以 Parent.Type = Person.PhoneNumber  的形式去使用

}

3.2 使用不同 .proto 文件裏的消息類型

目的：須要在 A.proto文件使用 B.proto文件裏的消息類型
解決方式：在 A.proto文件通過導入（ import） B.proto文件裏來使用 B.proto文件裏的消息類型

import "myproject/other_protos.proto"
// 在A.proto 文件裏加入 B.proto文件路徑的導入聲明
// ProtocolBuffer編譯器 會在 該文件夾中 查找須要被導入的 .proto文件
// 假設不提供參數。編譯器就在 其調用的文件夾下 查找

當然，在使用不同 .proto 文件裏的消息類型時也會存在想使用同一個 .proto 文件消息類型的情況，但使用都是一樣，此處不作過多描寫敘述。

3.3 將消息對象類型用在 RPC（遠程方法調用）系統

解決方式：在 .proto 文件裏定義一個 RPC 服務接口，Protocol Buffer編譯器會依據所選擇的不同語言平臺生成服務接口代碼
由於使用得不多，此處不作過多描寫敘述。詳細請看該文檔

c. 字段名

該字段的名稱，此處不作過多描寫敘述。

d. 標識號

作用：通過二進制格式唯一標識每一個字段
1. 一旦開始使用就不能夠再改變
2. 標識號使用範圍：[1,2的29次方 - 1]
3. 不可使用 [19000－19999] 標識號，由於 Protobuf 協議實現中對這些標識號進行了預留。假若使用，則會報錯
編碼占有內存規則：
每一個字段在進行編碼時都會占用內存，而占用內存大小取決於標識號：
1. 範圍 [1,15] 標識號的字段在編碼時占用1個字節。
2. 範圍 [16,2047] 標識號的字段在編碼時占用2個字節
使用建議
1. 為頻繁出現的消息字段保留 [1,15] 的標識號
2. 為將來有可能加入的、頻繁出現的消息字段預留 [1,15] 標識號

關於字段的高級使用方法

技術分享

1. 更新消息對象的字段

目的：為了滿足新需求，須要更新消息類型而不破壞已有消息類型代碼

即新、老版本號須要兼容
更新字段時，須要符合下列規則：

2. 擴展消息對象的字段

作用：使得其它人能夠在自己的 .proto 文件裏為該消息對象聲明新的字段而不必去編輯原始文件
1. 註：擴展能夠是消息類型也能夠是字段類型
2. 以下以擴展消息類型為例

A.proto

message Request { … extensions 100 to 199; // 將一個範圍內的標識號聲明為可被第三方擴展所用 // 在消息Request中。範圍 [100,199] 的標識號被保留為擴展用 // 假設標識號須要非常大的數量時。能夠將可擴展標符號的範圍擴大至max // 當中max是2的29次方 - 1（536,870,911）。

message Request { extensions 1000 to max; // 註：請避開[19000－19999] 的標識號。由於已被Protocol Buffers實現中預留 }

如今，其它人就能夠在自己的 .proto文件裏加入新字段到Request裏。例如以下：

B.proto

extend Request {

  optional int32 bar = 126;
  // 加入字段的 標識號必須要在指定的範圍內
  // 消息Request 如今有一個名為 bar 的 optional int32 字段
  // 當Request消息被編碼時，數據的傳輸格式與在Request裏定義新字段的效果是全然一樣的
  //  註：在同一個消息類型中一定要確保不會擴展新增同樣的標識號。否則會導致數據不一致；能夠通過為新項目定義一個可擴展標識號規則來防止該情況的發生
}

要訪問擴展字段的方法與訪問普通的字段不同：使用專門的擴展訪問函數
實例：

// 怎樣在C++中設置 bar 值
Request request;
request.SetExtension(bar, 15);
// 相似的模板函數 HasExtension()。ClearExtension()，GetExtension()，MutableExtension()，以及 AddExtension()
// 與相應的普通字段的訪問函數相符

嵌套的擴展

能夠在還有一個消息對象裏聲明擴展，如：

message Carson {

  extend Request {

    optional int32 bar = 126;

  }
  …
}

// 訪問此擴展的C++代碼：
Request request;
request.SetExtension(Baz::bar, 15);

對於嵌套的使用，一般的做法是：在擴展的字段類型的範圍內定義該擴展
實例：一個 Request 消息對象須要擴展（擴展的字段類型是Car 消息類型）。那麽，該擴展就定義在 Car消息類型裏：


message Car {

  extend Request {
    optional Car request_ext = 127;
// 註：二者並沒有子類、父類的關系
  }
}

至此，Protoco Buffer的語法已經解說完畢
關於怎樣依據需求通過Protoco Buffer語法去構建數據結構相信大家已經非常熟悉了。
在將 .proto文件保存後，進入下一個步驟

步驟2：通過 `Protocol Buffer` 編譯器編譯 .proto 文件

作用：將 .proto 文件轉換成相應平臺的代碼文件

Protoco Buffer提供 C++、Java、Python 三種開發語言的 API
詳細生成文件與平臺有關：

編譯指令說明

// 在 終端 輸入下列命令進行編譯
protoc -I=$SRC_DIR --xxx_out=$DST_DIR   $SRC_DIR/addressbook.proto

// 參數說明
// 1. $SRC_DIR：指定須要編譯的.proto文件文件夾 (如沒有提供則使用當前文件夾)
// 2. --xxx_out：xxx依據須要生成代碼的類型進行設置
// 對於 Java ，xxx =  java ，即 -- java_out
// 對於 C++ ，xxx =  cpp ，即 --cpp_out
// 對於 Python。xxx =  python。即 --python_out

// 3. $DST_DIR ：編譯後代碼生成的文件夾 (通常設置與$SRC_DIR同樣)
// 4. 最後的路徑參數：須要編譯的.proto 文件的詳細路徑

// 編譯通過後。Protoco Buffer會依據不同平臺生成相應的代碼文件

詳細實例

// 編譯說明
// 1. 生成Java代碼
// 2. 須要編譯的.proto文件在桌面，希望編譯後生成的代碼也放在桌面
protoc -I=/Users/Carson_Ho/Desktop --java_out=/Users/Carson_Ho/Desktop /Users/Carson_Ho/Desktop/Demo.proto

// 編譯通過後，Protoco Buffer會依照標準Java風格。生成Java類及文件夾結構

在指定的文件夾能看到一個Demo的包文件（含 java類文件）

技術分享

編譯功能的拓展

a. 使用`Android Studio`插件進行編譯

需求場景：每次手動執行 Protocol Buffer 編譯器將 .proto 文件轉換為 Java 文件操作不方便
解決方式：使用 Android Studio的 gradle 插件 protobuf-gradle-plugin，以便於在項目編譯時自己主動執行 Protocol Buffers 編譯器

關於protobuf-gradle-plugin插件有興趣的讀者可自行了解。但個人還是建議使用 命令行，畢竟太過折騰插件不是必需

b. 動態編譯

需求場景：某些情況下。人們無法預先知道 .proto 文件，他們須要動態處理一些未知的 .proto 文件

如一個通用的消息轉發中間件。它無法預先知道須要處理什麽類型的數據結構消息
解決方式：動態編譯.proto文件

由於使用得不多，此處不作過多描寫敘述。詳細請看官方文檔

c. 編寫新的 `.proto` 編譯器

需求場景： Protocol Buffer 僅支持 C++、java 和 Python 三種開發語言。一旦超出該三種開發語言，Protocol Buffer將無法使用
解決方式：使用 Protocol Buffer 的 Compiler 包開發出支持其它語言的新的.proto編譯器

由於使用得不多，此處不作過多描寫敘述，詳細請看官方文檔

5.3 應用到詳細平臺（`Android`平臺）

最終到了應用到詳細平臺項目中的步驟了。

此處以 Android平臺為例
詳細過程例如以下：

步驟1：將生成的代碼文件放入到項目中

對於Android（Java）平臺。即將編譯.proto文件生成的Java包文件整個拷貝到 Android 項目中
放置路徑： app/src/main/java的 文件夾裏

技術分享

步驟2：在 `Gradle` 加入 `Protocol Buffer` 版本號依賴

compile ‘com.google.protobuf:protobuf-java:2.6.1‘
// 註：protobuf-java的版本號 一定要和 安裝protocobuffer的版本號 一致

步驟3：詳細在Android項目中使用

3.1 消息對象類介紹

通過.proto文件 轉換的 Java源碼 = Protocol Buffer 類 + 消息對象類（含Builder內部類）

消息對象類是 Protocol Buffer 類的內部類

由於最經常使用的都是消息對象類和其內部類Builder類的方法&成員變量，所以此處主要解說這兩者。

3.1.1 消息對象類（`Message`類）

消息對象類類通過 二進制數組 寫和讀消息類型
使用方法包括：

<-- 方式1：直接序列化和反序列化 消息 -->
protocolBuffer.toByteArray()。
// 序列化消息 並 返回一個包括它的原始字節的字節數組
protocolBuffer.parseFrom(byte[] data)；
// 從一個字節數組 反序列化（解析） 消息

<-- 方式2：通過輸入/ 輸出流（如網絡輸出流） 序列化和反序列化消息 -->
protocolBuffer.writeTo(OutputStream output)。
output.toByteArray();
// 將消息寫入 輸出流 ，然後再 序列化消息 

protocolBuffer.parseFrom(InputStream input)。
// 從一個 輸入流 讀取並 反序列化（解析）消息


// 僅僅含包括字段的getters方法
// required string name = 1;
public boolean hasName();// 假設字段被設置，則返回true
public java.lang.String getName();

// required int32 id = 2;
public boolean hasId();
public int getId();

// optional string email = 3;
public boolean hasEmail();
public String getEmail();

// repeated .tutorial.Person.PhoneNumber phone = 4;
// 反復（repeated）字段有一些額外方法
public List<PhoneNumber> getPhoneList();
public int getPhoneCount();
// 列表大小的速記
// 作用：通過索引獲取和設置列表的特定元素的getters和setters

經常使用的如上，很多其它請看官方文檔

3.1.2 `Builder`類

作用：創建消息構造器 & 設置/ 獲取消息對象的字段值 & 創建消息類實例

屬於消息對象類的內部類

a. 創建消息構造器

Demo.Person.Builder person = Person.newBuilder();

b. 設置/ 獲取消息對象的字段值詳細方法例如以下：

// 標準的JavaBeans風格：含getters和setters
// required string name = 1;
public boolean hasName();// 假設字段被設置，則返回true
public java.lang.String getName();
public Builder setName(String value);
public Builder clearName(); // 將字段設置回它的空狀態

// required int32 id = 2;
public boolean hasId();
public int getId();
public Builder setId(int value);
public Builder clearId();

// optional string email = 3;
public boolean hasEmail();
public String getEmail();
public Builder setEmail(String value);
public Builder clearEmail();

// repeated .tutorial.Person.PhoneNumber phone = 4;
// 反復（repeated）字段有一些額外方法
public List<PhoneNumber> getPhoneList();
public int getPhoneCount();
// 列表大小的速記
// 作用：通過索引獲取和設置列表的特定元素的getters和setters

public PhoneNumber getPhone(int index);
public Builder setPhone(int index, PhoneNumber value);

public Builder addPhone(PhoneNumber value);
// 將新元素加入到列表的末尾

public Builder addAllPhone(Iterable<PhoneNumber> value);
// 將一個裝滿元素的整個容器加入到列表中
public Builder clearPhone();

public Builder isInitialized() 
// 檢查全部 required 字段 是否都已經被設置

public Builder toString() :
// 返回一個人類可讀的消息表示（用於調試）

public Builder mergeFrom(Message other)
// 將 其它內容 合並到這個消息中，覆寫單數的字段，附接反復的。

public Builder clear()
// 清空全部的元素為空狀態。

3.2 詳細使用

使用過程例如以下：
步驟1：通過消息類的內部類Builder類構造消息構造器
步驟2：通過消息構造器設置消息字段的值
步驟3：通過消息構造器創建消息類對象
步驟4：序列化 / 反序列化消息
詳細使用例如以下：（凝視非常清晰）

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 步驟1:通過 消息類的內部類Builder類 構造 消息類的消息構造器
        Demo.Person.Builder personBuilder =  Demo.Person.newBuilder();

        // 步驟2:設置你想要設置的字段為你選擇的值
        personBuilder.setName("Carson");// 在定義.proto文件時,該字段的字段修飾符是required,所以必須賦值
        personBuilder.setId(123);// 在定義.proto文件時,該字段的字段修飾符是required,所以必須賦值
        personBuilder.setEmail("[email protected]"); // 在定義.proto文件時,該字段的字段修飾符是optional,所以可賦值 / 不賦值(不賦值時將使用默認值)

        Demo.Person.PhoneNumber.Builder phoneNumber =  Demo.Person.PhoneNumber.newBuilder();
        phoneNumber.setType( Demo.Person.PhoneType.HOME);// 直接採用枚舉類型裏的值進行賦值
        phoneNumber.setNumber("0157-23443276");
        // PhoneNumber消息是嵌套在Person消息裏,能夠理解為內部類
        // 所以創建對象時要通過外部類來創建

        // 步驟3:通過 消息構造器 創建 消息類 對象
        Demo.Person person = personBuilder.build();

        // 步驟4:序列化和反序列化消息(兩種方式)

        /*方式1：直接 序列化 和 反序列化 消息 */
        // a.序列化
        byte[] byteArray1 = person.toByteArray();
        // 把 person消息類對象 序列化為 byte[]字節數組
        System.out.println(Arrays.toString(byteArray1));
        // 查看序列化後的字節流

        // b.反序列化
        try {

            Demo.Person person_Request = Demo.Person.parseFrom(byteArray1);
            // 當接收到字節數組byte[] 反序列化為 person消息類對象

            System.out.println(person_Request.getName());
            System.out.println(person_Request.getId());
            System.out.println(person_Request.getEmail());
            // 輸出反序列化後的消息
        } catch (IOException e) {
            e.printStackTrace();
        }


        /*方式2：通過輸入/ 輸出流（如網絡輸出流） 序列化和反序列化消息 */
        // a.序列化
        ByteArrayOutputStream output = new ByteArrayOutputStream();
         try {

            person.writeTo(output);
            // 將消息序列化 並寫入 輸出流(此處用 ByteArrayOutputStream 取代)

        } catch (IOException e) {
            e.printStackTrace();
        }

        byte[] byteArray = output.toByteArray();
        // 通過 輸出流 轉化成二進制字節流

        // b. 反序列化
        ByteArrayInputStream input = new ByteArrayInputStream(byteArray);
        // 通過 輸入流 接收消息流(此處用 ByteArrayInputStream 取代)

        try {

            Demo.Person person_Request = Demo.Person.parseFrom(input);
            // 通過輸入流 反序列化 消息

            System.out.println(person_Request.getName());
            System.out.println(person_Request.getId());
            System.out.println(person_Request.getEmail());
            // 輸出消息
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

Demo 地址

Carson_Ho的Github ：https://github.com/Carson-Ho/ProtocolBuffer

高級功能

貼心的Google還提供將Protocol Buff 編碼方式轉化為其它編碼方式，如 Json、XML等等

即將 Protocol Buff 對象轉化為其它編碼方式的數據存儲對象
以下展示的是將 Protocol Buff 對象轉化為 Json對象

// 步驟1：在Gradle加入依賴
compile ‘com.googlecode.protobuf-java-format:protobuf-java-format:1.4‘

// 步驟2：將`Protocol Buff` 對象 序列化 為 `Json`對象
JsonFormat jsonFormat = new JsonFormat();  
String person2json = jsonFormat.printToString(mProtoBuffer);

6. 總結

在 數據傳輸量較大的需求場景下，Protocol Buffer比XML、Json 更小、更快、使用 & 維護更簡單！
以下用一張圖總結在 Android平臺中使用 Protocol Buffer 的整個步驟流程：

技術分享

看完本文，你應該會非常好奇為什麽Protocol Buffer 的優勢這麽大：為什麽序列化後的數據包比XML、Json更小、傳輸速度更快？
下一篇文章我將對Protocol Buffer 進行源碼分析。有興趣能夠繼續關註我的CSDN博客！

請幫頂或評論點贊！
由於你的鼓舞是我寫作的最大動力！

快來看看Google出品的Protocol Buffer，別僅僅會用Json和XML了

println 輸出流基本數據類型下一個 ebr sid 官網序列 reg 前言習慣用 Json、XML 數據存儲格式的你們，相信大多都沒聽過Protocol Buffer Protocol Buffer 事實上是 Google出品的一種輕

快來看看Google出品的Protocol Buffer，別僅僅會用Json和XML了

前言

文件夾

1. 定義

2. 作用

3. 特點

4. 應用場景

總結

5. 使用流程

5.1 環境配置

步驟1：下載 Protocol Buffer 安裝包

步驟2：安裝 HOMEBREW（已安裝的能夠跳過）

步驟3：安裝 Protocol Buffer

步驟4：檢查 Protocol Buffer 是否成功安裝

5.2 構建 Protocol Buffer 消息對象模型

5.2.1 構建步驟

5.2.2 詳細介紹

步驟1：通過 Protocol Buffer 語法 描寫敘述 須要存儲的數據結構

關註1：包名

關註2：Option選項

關註3：消息模型

1. 消息對象

a. 加入：在一個 .proto文件 中可定義多個 消息對象

b. 一個消息對象 裏 能夠定義 另外一個消息對象（即嵌套）

2. 字段

1. 基本數據類型

2. 枚舉類型

3. 消息對象 類型

3.1 使用同一個 .proto 文件裏的消息類型

3.2 使用不同 .proto 文件裏的消息類型

3.3 將 消息對象類型 用在 RPC（遠程方法調用）系統

c. 字段名

d. 標識號

關於 字段 的高級使用方法

1. 更新消息對象 的字段

2. 擴展消息對象 的字段

嵌套的擴展

步驟2：通過 Protocol Buffer 編譯器 編譯 .proto 文件

編譯功能的拓展

a. 使用Android Studio插件進行編譯

b. 動態編譯

c. 編寫新的 .proto 編譯器

5.3 應用到詳細平臺（Android平臺）

步驟1：將生成的 代碼文件 放入到項目中

步驟2：在 Gradle 加入 Protocol Buffer 版本號依賴

步驟3：詳細在Android項目中使用

3.1 消息對象類介紹

3.1.1 消息對象類（Message類）

3.1.2 Builder類

3.2 詳細使用

Demo 地址

高級功能

6. 總結

請幫頂或評論點贊！由於你的鼓舞是我寫作的最大動力！

相關推薦

步驟1：下載 `Protocol Buffer` 安裝包

步驟2：安裝 `HOMEBREW`（已安裝的能夠跳過）

步驟3：安裝 `Protocol Buffer`

步驟4：檢查 `Protocol Buffer` 是否成功安裝

5.2 構建 `Protocol Buffer` 消息對象模型

步驟1：通過 `Protocol Buffer` 語法描寫敘述須要存儲的數據結構

a. 加入：在一個 .proto文件中可定義多個消息對象

b. 一個消息對象裏能夠定義另外一個消息對象（即嵌套）

3. 消息對象類型

3.3 將消息對象類型用在 RPC（遠程方法調用）系統

關於字段的高級使用方法

1. 更新消息對象的字段

2. 擴展消息對象的字段

步驟2：通過 `Protocol Buffer` 編譯器編譯 .proto 文件

a. 使用`Android Studio`插件進行編譯

c. 編寫新的 `.proto` 編譯器

5.3 應用到詳細平臺（`Android`平臺）

步驟1：將生成的代碼文件放入到項目中

步驟2：在 `Gradle` 加入 `Protocol Buffer` 版本號依賴

3.1.1 消息對象類（`Message`類）

3.1.2 `Builder`類

請幫頂或評論點贊！
由於你的鼓舞是我寫作的最大動力！