前言

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

  由於 Google出品，我相信Protocol Buffer已經具備足夠的吸引力

• 今天，我將獻上一份 Protocol Buffer的介紹 & 使用攻略，希望你們會喜歡。

目錄

目錄

1. 定義

一種 結構化資料 的資料儲存格式（類似於 XML、Json ）

1. Google 出品 （開源）
2. Protocol Buffer 目前有兩個版本：proto2
   和 proto3
3. 因為proto3 還是beta 版，所以本次講解是 proto2

2. 作用

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

1. 序列化： 將 資料結構或物件 轉換成 二進位制串 的過程
2. 反序列化：將在序列化過程中所生成的二進位制串 轉換成 資料結構或者物件 的過程

3. 特點

• 對比於 常見的 XML、Json 資料儲存格式，Protocol Buffer有如下特點：

Protocol Buffer 特點

4. 應用場景

傳輸資料量大 & 網路環境不穩定 的資料儲存、RPC 資料交換 的需求場景

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

總結

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

5. 使用流程

使用 Protocol Buffer 的流程如下：

Protocol Buffer使用流程

5.1 環境配置

• 要使用Protocol Buffer ，需要先在電腦上安裝Protocol Buffer

• 整個 安裝過程 只需要按照以下步驟進行即可：

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

步驟1：下載 Protocol Buffer 安裝包

• 下載方式2：貼心的我 已經給你們準備好了，請移步百度網盤，密碼：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

• 根據上述資料結構的需求，在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 語法 進行詳細介紹

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];
// 作用：判斷該欄位是否已經被棄用
// 作用同 在java中的註解@Deprecated

• 在 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 訊息物件類

• 訊息物件類 類通過 二進位制陣列 寫 和 讀 訊息型別
• 使用方法包括：

<-- 方式1：直接序列化和反序列化 訊息 -->
protocolBuffer.toByteArray()；
// 序列化訊息 並 返回一個包含它的原始位元組的位元組陣列
protocolBuffer.parseFrom(byte[] data)；
// 從一個位元組陣列 反序列化（解析） 訊息

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

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

常用的如上，更多請看官方文件

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.setEmail("[email protected]");// 在定義.proto檔案時,該欄位的欄位修飾符是required,所以必須賦值
        personBuilder.setId(123); // 在定義.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[]位元組陣列
        // b.反序列化
        Demo.Person person = Demo.Person.parseFrom(byteArray1);
        // 當接收到位元組陣列byte[] 反序列化為 person訊息類物件

        /*方式2：通過輸入/ 輸出流（如網路輸出流） 序列化和反序列化訊息 */
        // a.序列化
        ByteArrayOutputStream output = new ByteArrayOutputStream();
        person.writeTo(output);
        // 將訊息寫入 輸出流(此處用 ByteArrayOutputStream 代替)
        byte[] byteArray = output.toByteArray();
        // 通過 輸出流 序列化訊息
        // b. 反序列化
        ByteArrayInputStream input = new ByteArrayInputStream(byteArray);
        // 通過 輸入流 接收訊息流(此處用 ByteArrayInputStream 代替)
        Demo.Person person_Request = Demo.Person.parseFrom(input);
        // 通過輸入流 反序列化 訊息

        // 步驟5:輸出訊息
        System.out.println("Name:" + person_Request.getName());
        System.out.println("ID:" + person_Request.getName());
        System.out.println("E-mail:" + person_Request.getName());
    }
}

高階功能

• 貼心的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 進行原始碼分析，有興趣可以繼續關注Carson_Ho的安卓開發筆記