這一系列文章主要是對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 = https://www.cnblogs.com/tera/p/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 = https://www.cnblogs.com/tera/p/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 = https://www.cnblogs.com/tera/p/{"Peter"})
@DecodeDefault(value = https://www.cnblogs.com/tera/p/{"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 = https://www.cnblogs.com/tera/p/{"Peter"})
@DecodeDefault(value = https://www.cnblogs.com/tera/p/{"Peter"})
public String defaultName;
@EncodeDefault(value = https://www.cnblogs.com/tera/p/{"Peter", "Mary", "John"})
@DecodeDefault(value = https://www.cnblogs.com/tera/p/{"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 = https://www.cnblogs.com/tera/p/{"Peter"})
@DecodeDefault(value = https://www.cnblogs.com/tera/p/{"Peter"})
public String defaultName;
@EncodeDefault(value = https://www.cnblogs.com/tera/p/{"Peter", "Mary", "John"})
@DecodeDefault(value = https://www.cnblogs.com/tera/p/{"Peter", "Mary", "John"})
public String multipleDefaults;
@EncodeDefault(value = https://www.cnblogs.com/tera/p/{"親愛的%s用戶您好，歡迎回來"}, replace = true)
@DecodeDefault(value = https://www.cnblogs.com/tera/p/{"親愛的%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相關的幾個問題
是什么；怎么用；編碼原理；使用上的問題；改進問題的方法；進一步優化的思路
轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/90809.html
標籤：Java