這一系列文章主要是對protocol buffer這種編碼格式的使用方式、特點、使用技巧進行說明，並在原生protobuf的基礎上進行擴充套件和優化，使得它能更好地為我們服務。

在上一篇文章中，我們舉例了在移動網際網路場景下原生protobuf類庫使用上的問題，並且自己完成了一個java的編碼類庫。本文中將展示swift版本的解碼類庫，並且用網路請求的demo來模擬實際的使用場景，最後再進一步優化protobuf的編碼過程

本文包括以下幾個部分

1.swift版本的解碼類庫實現，這裡要特別說明，因為大部分情況下請求引數的資料量是不大的，所以優先關心返回引數的解碼

2.用網路請求模擬實際的使用場景，包括java和swift

3.根據移動網際網路應用場景的特點進一步優化protobuf的編碼過程

Swift解碼類庫

因為swift也是一個強型別語言，所以主要思路和java的完全一致，包括所有的基礎演算法都是從java那裡搬過來的，因此大部分程式碼都會比較類似。不過swift和java相比比較大的區別是對於反射的支援並不是很好，所以在模型定義上會有一些限制。

1.模型定義

為了能正常使用反射，需要將模型和其中的欄位定義為@objc，且類需要實現NSObject介面，另外為了方便轉換json，類還需要實現Codable介面

在上一篇文章最後，我們做了一個模型的測試CoderTestStudent，這裡就在swfit中定義同樣一個模型

import Cocoa

@objc class CoderTestStudent:NSObject,Codable{
   @objc var age:Int = 0
   @objc var father:Parent
   @objc var friends:[String]
   @objc var hairCount:Int64 = 0
   @objc var height:Double = 0
   @objc var hobbies:[Hobby]
   @objc var isMale:Bool
   @objc var mother:Parent
   @objc var name:String?
   @objc var weight:Float
}

@objc class Parent:NSObject,Codable{
    @objc var age:Int = 0
    @objc var name:String?
}

@objc class Hobby:NSObject,Codable {
    @objc var cost:Int = 0
    @objc var name:String?
}
 

2.類的定義和入口方法

首先是入口方法，這裡思路和java類庫一樣，首先需要一個入口方法接收2個引數，編碼後的位元組陣列data和物件的型別typeT

class Decoder: NSObject{
    ...    
    func deserialize<T: NSObject>(data:[Int], typeT:T.Type) ->T{
        buffer = data
        pos = 0;
        limit = data.count;
        let result = T.init()
        return deserializeObject(limit:data.count, obj:result);
    }
    ...
}

3.主邏輯方法，可遞迴呼叫

接著是用於遞迴的方法，總體思路還是利用反射獲取到型別中的所有欄位，並將其按字母順序進行排序，之後根據其型別分別呼叫不同的資料讀取方法

func deserializeObject<T: NSObject>(limit:Int, obj:T)->T{
    //這裡對模型欄位進行排序
    let result = obj
    let mirror = Mirror(reflecting: result)
    if(mirror.children.count == 0){
        pos = limit
        return result;
    }
    var fieldNameDict:[String: Mirror.Child] = [:]
    for property in mirror.children{
        fieldNameDict[property.label!] = property
    }
    let sortedKeys = Array(fieldNameDict.keys).sorted(by:{$0.lowercased()<$1.lowercased()})
    var fieldNumberDict:[Int: Mirror.Child] = [:]
    var order = 1
    for key in sortedKeys{
        fieldNumberDict[order]=fieldNameDict[key]
        order += 1
    }
    //排序是否完成
    while(pos < limit){
        //讀取位元組中的序號欄位
        let fieldNum = readTag();
        //為了老版本客戶端的相容性，如果讀取到的序號已經超過了模型的最大欄位序號
        //那麼就說明這是新版本客戶端新增的欄位，老版本客戶端就不需要解析了
        if(fieldNum >= order){
            pos = limit
            return result
        }
        //獲取和序號相符合的欄位
        if let field = fieldNumberDict[fieldNum] {
            //通過反射獲取欄位資訊
            let fm = Mirror(reflecting: field.value)
            //根據欄位描述判斷出欄位的型別，然後進入不同的讀取資料的方法
            if(fm.description == "Mirror for Optional<String>"){
                let r = readString();
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Int"){
                let r = readInt()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Bool"){
                let r = readBool()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Double"){
                let r = readDouble()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Float"){
                let r = readFloat()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Int64"){
                let r = readInt64()
                result.setValue(r, forKey: field.label!)
            }
            else if (fm.description == "Mirror for Optional<Array<String>>"){
                let r = readStringArray()
                let value = result.value(forKey: field.label!)
                //如果nil則新建一個數組，否則append
                if(value == nil){
                    result.setValue(r, forKey: field.label!)
                }else{
                    var array = (value as! [String])
                    array.append(contentsOf: r)
                    result.setValue(array, forKey: field.label!)
                }
            }else if (fm.description == "Mirror for Optional<Array<Int>>"){
                let r = readIntArray()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Optional<Array<Double>>"){
                let r = readDoubleArray()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Optional<Array<Float>>"){
                let r = readFloatArray()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Optional<Array<Int64>>"){
                let r = readLongArray()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description == "Mirror for Optional<Array<Bool>>"){
                let r = readBoolArray()
                result.setValue(r, forKey: field.label!)
            }else if (fm.description.hasPrefix("Mirror for Optional<Array<")){
                //如果是一個Object的Array，那麼就比較複雜一些
                //首先獲取該Object型別的字串
                if let match = fm.description.range(of: "(?<=<)[^>]+", options: .regularExpression) {
                    let first = fm.description.substring(with: match)
                    let className = first.split{$0 == "<"}.map(String.init)[1]
                    //通過反射載入類
                    let cls: AnyClass = NSClassFromString("\(_namespace!).\(className)")!;
                    let objType = cls as! NSObject.Type
                    let object = objType.init()
                    //遞迴呼叫
                    let r = readObject(obj: object)
                    let currentValue = result.value(forKey: field.label!)
                    //判斷陣列是否為空
                    if(currentValue == nil){
                        result.setValue([r], forKey: field.label!)
                    }else{
                        var array = currentValue as! [NSObject]
                        array.append(r)
                        result.setValue(array, forKey: field.label!)
                    }
                }
            }else{
                //如果是一個Object，那麼和Array類似，通過字串動態獲取模型的類
                if let match = fm.description.range(of: "(?<=<)[^>]+", options: .regularExpression) {
                    let className = fm.description.substring(with: match)
                    let cls: AnyClass = NSClassFromString("\(_namespace!).\(className)")!;
                    let objType = cls as! NSObject.Type
                    let object = objType.init()
                    //遞迴呼叫
                    let r = readObject(obj: object)
                    result.setValue(r, forKey: field.label!)
                }
            }
        }
    }
    return result
}

4.讀取單獨欄位的方法

這裡都會呼叫一些基礎方法

func readBool()->Bool{
    return readRawVarint32() == 1
}

func readInt()->Int{
    return readRawVarint32()
}

func readInt64()->Int64{
    return readRawVarint64();
}

func readDouble()->Double{
    return longBitsToDouble(bits: readRawLittleEndian64())
}

func readFloat()->Float{
    return intBitsToFloat(bits: readRawLittleEndian32())
}

5.單獨欄位的基礎方法

因為readRawVarint32、readRawVarint64是照搬java版本google提供的官方邏輯，裡面全是位的運算，這裡就不展示了，有興趣的可以去git檢視完整程式碼，這裡主要看下longBitsToDouble和intBitsToFloat

swift中的Double和Float型別都提供了一個接受bitPattern型別引數的建構函式，這就是swift提供的按照IEEE754標準將位元組轉換成Double和Float的方法

但是在swift中，所有的位元組都是無符號的，而java中是有符號的，並且readRawLittleEndian64和readRawLittleEndian32是按照java版本的邏輯編寫的，返回的值是有正有負，因此在swift中還原就會有問題

所以這裡就需要對bits的正負做一個判斷，如果是負數則需要將其最高位的符號位置為0

9223372036854775807表示01111111 11111111 111111111 11111111 11111111 11111111 111111111 11111111

2147483647表示01111111 11111111 111111111 11111111

經過&運算後，即可將最高位置為0，之後將得到的Double和Float取負即可得到實際的值

func longBitsToDouble(bits:Int64)->Double{
    if(bits > 0){
        return Double(bitPattern: UInt64(bits))
    }else{
        let postiveBits:Int64 = bits & 9223372036854775807
        return -Double(bitPattern: UInt64(postiveBits))
    }
}

func intBitsToFloat(bits:Int)->Float{
    if(bits > 0){
        return Float(bitPattern: UInt32(bits))
    }else{
        let postiveBits:Int = bits & 2147483647
        return -Float(bitPattern: UInt32(postiveBits))
    }
}

6.讀取陣列欄位的方法

這裡就是呼叫讀取單獨欄位的方法，並將其構造成一個數組即可

func readBoolArray()->[Bool]{
    var result:[Bool] = []
    let length = readRawVarint32()
    let limit = pos + length;
    while (pos < limit) {
        result.append(contentsOf: [readBool()]);
    }
    return result
}

func readLongArray()->[Int64]{
    var result:[Int64] = []
    let length = readRawVarint32()
    let limit = pos + length;
    while (pos < limit) {
        let ss = readInt64()
        result.append(contentsOf: [ss]);
    }
    return result
}

func readDoubleArray()->[Double]{
    var result:[Double] = []
    let length = readRawVarint32()
    let limit = pos + length;
    while (pos < limit) {
        result.append(contentsOf: [readDouble()]);
    }
    return result
}

func readFloatArray()->[Float]{
    var result:[Float] = []
    let length = readRawVarint32()
    let limit = pos + length;
    while (pos < limit) {
        result.append(contentsOf: [readFloat()]);
    }
    return result
}

func readIntArray()->[Int]{
    var result:[Int] = []
    let length = readRawVarint32()
    let limit = pos + length;
    while (pos < limit) {
        result.append(contentsOf: [readInt()]);
    }
    return result
}

func readStringArray()->[String]{
    return [readString()]
}

7.讀取Object和ObjectArray的方法

這裡就是遞迴呼叫主邏輯方法

需要特別注意的是，即使是ObjectArray，也是呼叫這個讀取單個Object的方法

在第三篇詳解protobuf編碼原理的文章中有展示，對於子物件的Array，protobuf其實是將其每一個元素都編碼成了獨立的完整的protobuf結構，因此可以一個一個讀取

https://www.cnblogs.com/tera/p/13578660.html

func readObject<T:NSObject>(obj: T)->T{
    let length = readRawVarint32()
    let limit = pos + length
    return deserializeObject(limit: limit, obj: obj)
}

以上就是對於解碼程式碼的解析

完整的demo程式碼在https://github.com/TeraTian/protobuf-ios-demo

接著我們就可以看下實際使用的例子

客戶端的模擬請求

接著我們就用2個簡單的模擬請求看下客戶端和服務端的實際互動

首先我們寫一個服務端的介面

這裡需要注意的是，因為protobuf最終結果是一個byte陣列，所以不能用常規的物件返回，而是需要直接將結果byte陣列寫入到返回流中

@RestController
@RequestMapping("/protobuf")
public class ProtobufController {
    @Autowired
    private HttpServletResponse response;

    @GetMapping("/getStudent")
    public void getStudent() throws IOException {
        String source = "{\"age\":13,\"father\":{\"age\":45,\"name\":\"Tom\"},\"friends\":[\"mary\",\"peter\",\"john\"],\"hairCount\":342728123942,\"height\":180.3,\"hobbies\":[{\"cost\":130,\"name\":\"football\"},{\"cost\":270,\"name\":\"basketball\"}],\"isMale\":true,\"mother\":{\"age\":45,\"name\":\"Alice\"},\"name\":\"Tera\",\"weight\":52.34}";
        CoderTestStudent student = JSON.parseObject(source, CoderTestStudent.class);
        ServletOutputStream out = response.getOutputStream();
        byte[] result = BasicEncoder.serialize(student, CoderTestStudent.class);
        Parent a = new Parent();
        out.write(result);
    }
}

1.Android的請求解析

先看android的客戶端請求，也就是java版本的解碼類庫

/**
 * 模擬安卓端的網路請求
 */
@Test
public void httpTest() throws IOException {
    Request request = new Request.Builder()
            .url("http://localhost:8080/protobuf/getStudent")
            .build();
    OkHttpClient client = new OkHttpClient();
    try (Response response = client.newCall(request).execute()) {
        byte[] bytes = response.body().bytes();
        CoderTestStudent student = new BasicDecoder().deserialize(bytes, CoderTestStudent.class);
        System.out.println(JSON.toJSONString(student, SerializerFeature.PrettyFormat));
    }
}

2.IOS的請求解析

接著看ios端的請求，也就是swift版本的類庫

這裡需要注意的是，因為所有解碼的基礎方法都是翻自java，正如之前所述，java中的位元組是帶符號的，而swift中位元組是無符號的，在進行數字運算的時候就會導致結果不正確，所以這裡將所有的位元組都轉換成了Int型別

var pd = Decoder(namespace:"commond_line")
func request(){
    let sem = DispatchSemaphore(value:0)
    let url = URL(string: "http://localhost:8080/protobuf/getStudent")
    var request = URLRequest(url: url!)
    request.httpMethod = "GET"
    let session = URLSession(configuration: .default)

    let task = session.dataTask(with: request, completionHandler: {(data, response, error) in
        //這裡做了一個位元組到Int8的轉換
        let buffer = data!.map({ (bit) -> Int in
            let int8Bit: Int8 = Int8(bitPattern: bit)
            return Int(int8Bit)
        })
        let model = pd.deserialize(data: buffer, typeT: CoderTestStudent.self)
        printJson(object:model)
    });
    task.resume()
    sem.wait(timeout: DispatchTime.now() + 100)
}
request()

兩者輸出結果如下

{
	"age":13,
	"father":{
		"age":45,
		"name":"Tom"
	},
	"friends":[
		"mary",
		"peter",
		"john"
	],
	"hairCount":342728123942,
	"height":180.3,
	"hobbies":[
		{
			"cost":130,
			"name":"football"
		},
		{
			"cost":270,
			"name":"basketball"
		}
	],
	"isMale":true,
	"mother":{
		"age":45,
		"name":"Alice"
	},
	"name":"Tera",
	"weight":52.34
}

至此，整個protobuf在移動網際網路端的使用上就完全閉環了

protobuf的定製化優化

現在我們已經解決了原生類庫會導致客戶端體積不可控的問題，那麼接下去我們可以在原生類庫的基礎上再次根據我們的實際情況進行進一步優化

通過之前的幾篇編碼原理的文章，我們可以瞭解到protobuf的編碼結果的大小比json小的原因在於，它將很多資訊在編碼的過程中捨棄了，而這部分被捨棄的資訊則是直接存放在了資訊傳送方和接收方的本地類庫中，概括來說就是用儲存空間換取傳輸空間。

那麼此時我們就可以考慮，能否繼續擴充套件這種思想，將其做得更進一步

結合日常工作的實際情況來看，很多時候APP介面在設計的時候為了達成儘可能的“服務端可控”，大部分客戶端的文案、資料都是服務端返回的。那麼在這個過程中，我就發現很多文案雖然是可能發生改變的，但是變化的頻率是很低的，例如一些介面的標題（訂單詳情、商品列表）、一些營銷文案（尊敬的白金會員）、一些長期固定的說明文案（預訂提示：可隨時取消）等等。這些文案大部分時候都是不會變的，但是又說不定哪一天產品一拍腦袋就需要修改，所以我在開發介面的時候都會將這些文案從服務端返回，而不是寫死在客戶端，這樣在將來某一天需要修改的時候直接服務端改個配置就行。

那麼在上述場景下，客戶端每一次請求到這些文案的時候都是從服務端拿資料，但是大部分時候又不變，那麼這些資料的傳輸其實就是浪費的，然而又需要應對將來可能的變化，不能寫死在客戶端。為了解決這個矛盾，我們可以在定義欄位的時候增加預設值的概念。

1.單一預設值

例如我們定義如下的模型

public class DefaultStringStudent {
    public String name;
}

假設我們在傳遞的時候，這個學生大部分情況name都是Peter，那麼我們可以同時在客戶端和服務端的模型中定義一個預設值Peter

java模型採用annotation的方式

這裡Encode的註解是在編碼的時候用，即服務端

而Decode則是在解碼的時候用，即客戶端

public class DefaultStringStudent {
    @EncodeDefault(value = {"Peter"})
    @DecodeDefault(value = {"Peter"})
    public String defaultName;
}

swift模型採用預設值的方式

@objc class DefaultStringStudent:NSObject,Codable{
   @objc var name:defaultName? = "Peter"
}

於是，如果我們需要傳遞的json資料如下

{
	"name": "Peter",
	"age": 13
}

在編碼的時候我們就不需要將Peter進行編碼，而只需要編入一個標誌位，表示該欄位是一個預設值，那麼資料接收方在解析的時候就可以從自己的模型定義中拿到Peter的預設值。而當name改變的時候，我們就可以按照正常方式將其編碼，而資料接收方也會直接取編碼中的值

2.多種預設值

除了單一預設值的情況，還有可能是多種預設值。例如訂單的狀態，可能包括預訂成功、預訂失敗、預訂取消等等，如果我們採用一個int的列舉值表示，讓客戶端根據int列舉值判斷之後展示相應文案，那麼當將來需要新增一個預訂確認中的狀態時已經發布的老版本客戶端將無法處理，所以這些文案也應當是從服務端返回。

順著之前的思路，我們在定義預設值的時候可以定義多個，而在編碼的時候，除了用標記位表示是否使用預設值，再需要一個Int表示預設值的索引。

還是用上面的DefaultStringStudent舉例

java模型

public class DefaultStringStudent {
    @EncodeDefault(value = {"Peter"})
    @DecodeDefault(value = {"Peter"})
    public String defaultName;

    @EncodeDefault(value = {"Peter", "Mary", "John"})
    @DecodeDefault(value = {"Peter", "Mary", "John"})
    public String multipleDefaults;
}

swift模型，因為沒有自定義annotation這種機制，所以只能採用|分隔

@objc class DefaultStringStudent:NSObject,Codable{
    @objc var defaultName:String? = "Peter"
    @objc var multipleDefaults:String? = "Peter|Mary|John"
}

3.可替換的預設值

還有一種情況，一個字串中的大部分都是不變的，只有其中的幾個字元會根據不同的情況改變，例如“親愛的XXX使用者您好，歡迎回來”，在這種情況下，只有XXX需要根據實際情況進行替換，而其餘的字元都是可以不變的，因此在傳輸該資料的過程中，我們只需要傳遞會變化的部分，而不變的部分就存放到模型中

java模型

public class DefaultStringStudent {
    @EncodeDefault(value = {"Peter"})
    @DecodeDefault(value = {"Peter"})
    public String defaultName;

    @EncodeDefault(value = {"Peter", "Mary", "John"})
    @DecodeDefault(value = {"Peter", "Mary", "John"})
    public String multipleDefaults;

    @EncodeDefault(value = {"親愛的%s使用者您好，歡迎回來"}, replace = true)
    @DecodeDefault(value = {"親愛的%s使用者您好，歡迎回來"})
    public String replacedDefault;
}

swift模型

@objc class DefaultStringStudent:NSObject,Codable{
    @objc var defaultName:String? = "Peter"
    @objc var multipleDefaults:String? = "Peter|Mary|John"
    @objc var replacedDefault:String? = "親愛的%@使用者您好，歡迎回來"
}

4.程式碼修改

那麼為了實現上述三種情況下的編碼，我們就必須修改編碼和解碼的程式碼以滿足我們的要求

a.java編碼過程

這裡主要修改了主邏輯中和String相關的部分，針對EncodeDefault的註解進行處理，並且會呼叫writeDefaultString進行預設字串的編碼

if (value instanceof String) {
    String str = (String) value;
    //這裡為了APP多版本的相容，因此允許定義多個EncodeDefault
    EncodeDefaults multiple = f.getAnnotation(EncodeDefaults.class);
    if (multiple != null) {
        EncodeDefault[] singles = multiple.value();
        if (singles.length > 0) {
            int startIndex = 0;
            //這裡就需要遍歷多個EncodeDefault了，每一個EncodeDefault代表了一個APP的版本
            for (int i = 0; i < singles.length; i++) {
                EncodeDefault single = singles[i];
                //這裡判斷當前請求的APP版本是否符合當前Default配置的版本要求
                if (single.version().isEmpty() || comparator.compare(appVersion, single.version()) >= 0) {
                    //尋找資料的值是否在預設值的列表中，並且還需要判斷預設值是否是隻替換部分的預設值
                    FindIndexResult indexResult = findIndex(startIndex, single.value(), str, single.replace());
                    int index = indexResult.index;
                    //如果找到了索引，那麼久呼叫writeDefaultString方法，否則則直接呼叫最後正常寫入字串的方法
                    if (index >= 0) {
                        bytes.addAll(writeDefaultString(fieldNum, index, indexResult.params));
                        break label1;
                    }
                    startIndex += single.value().length;
                } else {
                    break;
                }
            }
        }
    } else {
        //如果只有一個Default，那麼就直接處理即可
        EncodeDefault single = f.getAnnotation(EncodeDefault.class);
        if (single != null && (single.version().isEmpty() || comparator.compare(appVersion, single.version()) >= 0)) {
            FindIndexResult indexResult = findIndex(0, single.value(), str, single.replace());
            int index = indexResult.index;
            if (index >= 0) {
                bytes.addAll(writeDefaultString(fieldNum, index, indexResult.params));
                break label1;
            }
        }
    }
    bytes.addAll(writeString(fieldNum, (String) value));
}

writeDefaultString方法

private List<Byte> writeDefaultString(int fieldNum, int index, List<String> params) {
    List<Byte> bytes = new ArrayList<>();
    //序號型別位元組的最後一個bit用1表示需要預設值
    bytes.addAll(writeTag(fieldNum, 1));
    if (params == null || params.size() == 0) {
        //如果是非替換的預設值，那麼直接寫入預設值的索引即可，並且索引的最後一個bit標識為0
        bytes.addAll(writeInt32NoTag(index << 1 | 0));
    } else {
        //如果是需要替換的預設值，那麼預設值的索引值最後一個bit需要標識為1
        bytes.addAll(writeInt32NoTag(index << 1 | 1));
        //將需要替換的部分用^分隔開，寫入編碼結果中
        bytes.addAll(writeStringNoTag(String.join("^", params)));
    }
    return bytes;
}

b.java的解碼修改

if (field.getType().equals(String.class)) {
    //判斷是否需要走預設值邏輯
    if (isDefault) {
        int defaultIndex = readRawVarint32();
        int index = defaultIndex >> 1;
        //獲取序號位元組型別的最後一個bit，判斷是否要走替換的邏輯
        boolean replace = (defaultIndex & 1) == 1;
        //對於客戶端來說，沒有多版本的概念，所以直接
        DecodeDefault feature = field.getAnnotation(DecodeDefault.class);
        if (feature != null) {
            String[] values = feature.value();
            if (values.length > index) {
                if (replace) {
                    //如果需要替換，那麼久一個一個替換
                    String params = readString();
                    List<String> paramList = Arrays.asList(params.split(split));
                    field.set(result, Helper.format(values[index], paramList, split));
                } else {
                    //不需要替換，那就直接取索引對應的預設值即可
                    field.set(result, values[index]);
                }
            }
        }
    } else {
        //不需要預設值，那麼就正常解碼即可
        field.set(result, readString());
    }
}

c.swift的解碼修改

if(fm.description == "Mirror for Optional<String>"){
    let isdefault = tuple.1 == 1
    //判斷是否需要走預設值邏輯
    if(isdefault){
        let defaultIndex = readRawVarint32();
        let index = defaultIndex >> 1;
        //取索引的最後一個bit判斷是否需要替換
        let replace = (defaultIndex & 1) == 1;
        let defaultValues = result.value(forKey: field.label!)
        if(defaultValues != nil){
            let array = (defaultValues! as! String).components(separatedBy: "|")
            if(index < array.count){
                if(replace){
                    //替換的邏輯
                    let r = readString().split(separator: "^");
                    var strarr:[String] = []
                    for rr in r{
                        strarr.append(String(rr))
                    }
                    let replaceResult = String(format:array[index], arguments:strarr)
                    result.setValue(replaceResult, forKey: field.label!)
                }else{
                    //直接根據索引取預設值
                    result.setValue(array[index], forKey: field.label!)
                }
            }else{
                result.setValue(nil, forKey: field.label!)
            }
        }
    }else{
        //不需要走預設值邏輯，就正常解碼
        let r = readString();
        result.setValue(r, forKey: field.label!)
    }
}

所有類庫的修改主要就是針對3種情況下字串的處理

5.優化後的類庫demo

我們做如下一個測試，相同的模型，比較預設值和非預設值的編碼結果

@Test
void defaultValueTest() {
    //預設值
    String source = "{" +
            "  \"defaultName\": \"Peter\"," +
            "  \"multipleDefaults\": \"Mary\"," +
            "  \"replacedDefault\": \"親愛的Tera使用者您好，歡迎回來\"" +
            "}";
    test(source, DefaultStringStudent.class, DefaultStringStudent.class);

    //非預設值
    String source2 = "{" +
            "  \"defaultName\": \"NotDefault\"," +
            "  \"multipleDefaults\": \"Ben\"," +
            "  \"replacedDefault\": \"不是預設值\"" +
            "}";
    test(source2, DefaultStringStudent.class, DefaultStringStudent.class);
}

test方法如下

static <T, U> void test(String source, Class<T> encodeClass, Class<U> decodeClass) {
    try {
        System.out.println(source);
        System.out.println("-------------------  編碼結果  -------------------");
        T javaModel = JSON.parseObject(source, encodeClass);
        //這裡傳入了一個APP版本的比較方法，以確定預設值能否匹配當前請求對應的APP版本
        byte[] teraBytes = new CustomProtobufEncoder("47", (app, target) -> {
            int a = Integer.parseInt(app);
            int b = Integer.parseInt(target);
            return a > b ? 1 : (a == b ? 0 : -1);
        }).serialize(javaModel, encodeClass);
        Helper.printBytes(teraBytes);
    } catch (Exception e) {
        System.out.println(e.getMessage());
    }

    System.out.println("");
}

輸出結果

{  "defaultName": "Peter",  "multipleDefaults": "Mary",  "replacedDefault": "親愛的Tera使用者您好，歡迎回來"}
-------------------  編碼結果  -------------------
3	0	5	2	7	1	4	84	101	114	97	
count:11


{  "defaultName": "NotDefault",  "multipleDefaults": "Ben",  "replacedDefault": "不是預設值"}
-------------------  編碼結果  -------------------
2	10	78	111	116	68	101	102	97	117	108	116	4	3	66	101	110	6	15	-28	-72	-115	-26	-104	-81	-23	-69	-104	-24	-82	-92	-27	-128	-68	
count:34

可以看到如果不帶用預設值的編碼結果為34個位元組，而採用預設值的編碼結果則只有11個位元組

本文總結

1.swift版本類庫的編寫

2.一個網路請求的demo使得整個protobuf的使用完成了閉環

3.在protobuf原始類庫的基礎上進一步進行了優化，使得傳輸資料的大小進一步減小

至此，通過5篇文章討論了和protobuf相關的幾個問題

是什麼；怎麼用；編碼原理；使用上的問題；改進問題的方法；進一步優化的思路