資訊專欄INFORMATION COLUMN
摘要：接上篇三和在進行的序列化和反序列化源碼解析之前先了解一下其主體工具類。是中用于序列化的主體。同時為了兼顧性能做了很多有意思的設計，比如獲取適配器的時候的雙緩存設計，應該是為了提高解析器的復用效率，具體有待研究。
接上篇 三 JsonReader 和 JsonWriter
在進行 json 的序列化和反序列化源碼解析之前先了解一下其主體工具類。
1 JsonReaderJsonReader 是 Gson 中用于 json 反序列化的主體。
在 Gson 包中可以不使用 Gson 門面而多帶帶使用 JsonReader 進行 json 的反序列化：
public static void main(String[] args){
//json 字符串
String json = "{"name":"zhangsan","age":18}";
//使用 StringReader 包裝字符串
StringReader strReader = new StringReader(json);
//使用 JsonReader 包裝 StringReader
JsonReader jsonReader = new JsonReader(strReader);
//創建一個參數均為空的目標對象
Person p = new Person();
try {
//beginObject(...) 方法用于告訴 jsonReader 開始讀取一個 object
jsonReader.beginObject();
//while 循環讀取
while(jsonReader.hasNext()){
//讀取一個 json 的 key 值
String name = jsonReader.nextName();
switch (name){
case "name":
p.setName(jsonReader.nextString()); //讀取一個 String 作為 value，存入對象中
break;
case "age":
p.setAge(jsonReader.nextInt()); //讀取一個 int 作為 value，存入對象中
break;
}
}
jsonReader.endObject();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println("名字：" + p.getName());
System.out.println("年齡：" +p.getAge())
}
JsonReader 的構造方法：
//JsonReader.class
public JsonReader(Reader in) {
if (in == null) {
throw new NullPointerException("in == null");
}
//傳入的 Reader 中保存著要讀取的 json 主體
//此處比較常用的是 StringReader，但是也可以是 FileReader 等其它 Reader 接口的實現類
this.in = in;
}
JsonReader 僅此一個構造方法，創建對象均調用此方法。
先來看一下 JsonReader 中非常重要的一個非公開方法 doPeek()：
//JsonReader.class
int doPeek() throws IOException {
//stack 是一個定義在 JsonReader 中的 int 數組，作為 JsonReader 的指令集存在，用于控制變量 peeked 的狀態
//在 JsonReader 初始化的時候會將 stack 的第一個元素變成6，其余均為0
//6的意思根據官方注釋為 "No object or array has been started"(還沒開始讀取對象或列表)
//6作為常量保存在 JsonScope 中，JsonScope 中還保存了很多代表指令的常量，下列會用到
//stackSize 是 stack 的有效元素計數器，初始化時 stackSize = 1，即只有第一個元素是有效的
int peekStack = stack[stackSize - 1];
//JsonScope.EMPTY_ARRAY = 1
if (peekStack == JsonScope.EMPTY_ARRAY) {
//JsonScope.NONEMPTY_ARRAY = 2
stack[stackSize - 1] = JsonScope.NONEMPTY_ARRAY;
} else if (peekStack == JsonScope.NONEMPTY_ARRAY) {
//在第一次調用 nextNonWhitespace(true) 方法的時候，json 字符串會被轉存為一個 char 數組
//該方法以 int 值的形式返回下一個要解析的 char 對象
int c = nextNonWhitespace(true);
switch (c) {
case "]":
//peeked 是 JsonReader 中最重要的用來狀態控制的 int 變量
//peeker 和 stack 會協同控制 JsonReader 的邏輯行為
return peeked = PEEKED_END_ARRAY; //PEEKED_END_ARRAY = 4
case ";":
//檢查標準協議選項，json 標準中的符號沒有分號
//所以在 lenient = false 的時候就會報錯
checkLenient();
case ",":
break;
default:
throw syntaxError("Unterminated array");
}
//JsonScope.EMPTY_OBJECT = 3，JsonScope.NONEMPTY_OBJECT = 5
} else if (peekStack == JsonScope.EMPTY_OBJECT || peekStack == JsonScope.NONEMPTY_OBJECT) {
//JsonScope.DANGLING_NAME = 4
stack[stackSize - 1] = JsonScope.DANGLING_NAME;
if (peekStack == JsonScope.NONEMPTY_OBJECT) {
int c = nextNonWhitespace(true);
switch (c) {
case "}":
return peeked = PEEKED_END_OBJECT; //PEEKED_END_OBJECT = 2
case ";":
checkLenient();
case ",":
break;
default:
throw syntaxError("Unterminated object");
}
}
int c = nextNonWhitespace(true);
switch (c) {
case """:
return peeked = PEEKED_DOUBLE_QUOTED_NAME; //PEEKED_DOUBLE_QUOTED_NAME = 13
case """:
checkLenient();
return peeked = PEEKED_SINGLE_QUOTED_NAME; //PEEKED_SINGLE_QUOTED_NAME = 12
case "}":
if (peekStack != JsonScope.NONEMPTY_OBJECT) {
return peeked = PEEKED_END_OBJECT;
} else {
throw syntaxError("Expected name");
}
default:
checkLenient();
pos--;
if (isLiteral((char) c)) {
return peeked = PEEKED_UNQUOTED_NAME; //PEEKED_UNQUOTED_NAME = 14
} else {
throw syntaxError("Expected name");
}
}
} else if (peekStack == JsonScope.DANGLING_NAME) {
stack[stackSize - 1] = JsonScope.NONEMPTY_OBJECT;
int c = nextNonWhitespace(true);
switch (c) {
case ":":
break;
case "=":
checkLenient();
//buffer 是儲存 json 字符串的 char 數組
//pos 是已經讀取到字符的數量指針
//limit 是 buffer 的可用部分的總長
if ((pos < limit || fillBuffer(1)) && buffer[pos] == ">") {
pos++;
}
break;
default:
throw syntaxError("Expected ":"");
}
//JsonScope.EMPTY_DOCUMENT = 6
//第一次進入方法的時候，會進入這個 if 語句中
} else if (peekStack == JsonScope.EMPTY_DOCUMENT) {
//檢查標準化協議相關
if (lenient) {
consumeNonExecutePrefix();
}
//JsonScope.NONEMPTY_DOCUMENT = 7
stack[stackSize - 1] = JsonScope.NONEMPTY_DOCUMENT;
} else if (peekStack == JsonScope.NONEMPTY_DOCUMENT) {
int c = nextNonWhitespace(false);
if (c == -1) {
return peeked = PEEKED_EOF;
} else {
checkLenient();
pos--;
}
//JsonScope.CLOSED = 8
} else if (peekStack == JsonScope.CLOSED) {
throw new IllegalStateException("JsonReader is closed");
}
//在這里獲取到了下一個要解析的 char 的 int 值
int c = nextNonWhitespace(true);
//進入 switch 去進行定位，定位到了之后修改 peeked 的狀態
switch (c) {
case "]":
if (peekStack == JsonScope.EMPTY_ARRAY) {
return peeked = PEEKED_END_ARRAY;
}
case ";":
case ",":
if (peekStack == JsonScope.EMPTY_ARRAY || peekStack == JsonScope.NONEMPTY_ARRAY) {
checkLenient();
pos--;
return peeked = PEEKED_NULL;
} else {
throw syntaxError("Unexpected value");
}
case """:
checkLenient();
return peeked = PEEKED_SINGLE_QUOTED;
case """:
return peeked = PEEKED_DOUBLE_QUOTED;
case "[":
return peeked = PEEKED_BEGIN_ARRAY;
case "{":
return peeked = PEEKED_BEGIN_OBJECT;
default:
pos--;
}
//peekKeyword() 方法會從 buffer 數組里獲取下一個 char
//然后根據這個字符判斷下一個要處理的字符串是不是 true、false、null 等特殊字符
//如果不是，會返回 result = PEEKED_NONE
int result = peekKeyword();
if (result != PEEKED_NONE) {
//不等于 PEEKED_NONE，證明下一個確實是特殊字符
return result;
}
//peekNumber() 方法和上述 peekKeyword() 方法很類似
//用于判斷下一個要處理的字符串是否是數字
result = peekNumber();
if (result != PEEKED_NONE) {
return result;
}
//isLiteral(buffer[pos]) 用于判斷下一個字符是否是特殊符
//比如 換行符、井號、括號 等
//如果是 換行符 的話這里就會拋出錯誤
if (!isLiteral(buffer[pos])) {
throw syntaxError("Expected value");
}
checkLenient();
return peeked = PEEKED_UNQUOTED; //PEEKED_UNQUOTED = 10
}
方法雖然比較長，但是代碼其實比較簡單，本質上是根據 stack 指令去修改 peeked 的值，從而達到狀態控制的效果。
再來看 beginObject() 方法：
//JsonReader.class
public void beginObject() throws IOException {
int p = peeked;
//初始化時 peeked = PEEKED_NONE
//在 doPeek() 方法中會修改成 PEEKED_BEGIN_OBJECT，即開始一個 Object 的序列化
if (p == PEEKED_NONE) {
p = doPeek();
}
if (p == PEEKED_BEGIN_OBJECT) {
//push(...) 方法會檢查 stack 數組的容積，適時進行擴容，并把傳入的指令存放到數組中
//此處將 EMPTY_OBJECT 指令存入到 stack 中
push(JsonScope.EMPTY_OBJECT);
//將 peeked 狀態初始化
peeked = PEEKED_NONE;
} else {
throw new IllegalStateException("Expected BEGIN_OBJECT but was " + peek() + locationString());
}
}
再來看 nextName() 方法：
//JsonReader.class
public String nextName() throws IOException {
//老樣子進行 peeked 的狀態獲取
int p = peeked;
if (p == PEEKED_NONE) {
p = doPeek();
}
String result;
//在這里通過 if 語句和 peeked 定位 json 的 key 是用單引號還是雙引號包裹的
//result 就是 key 的字符串
if (p == PEEKED_UNQUOTED_NAME) {
result = nextUnquotedValue();
} else if (p == PEEKED_SINGLE_QUOTED_NAME) {
result = nextQuotedValue(""");
} else if (p == PEEKED_DOUBLE_QUOTED_NAME) {
result = nextQuotedValue(""");
} else {
throw new IllegalStateException("Expected a name but was " + peek() + locationString());
}
//將 peeked 狀態初始化
peeked = PEEKED_NONE;
//pathNames 是一個用來儲存所有 key 的字符串的數組
pathNames[stackSize - 1] = result;
return result;
}
nextQuotedValue(...) 方法里實際上是比較繁瑣的字符串處理，在這里暫時不展開了。
hasNext() 和 nextString() 方法其實都和 nextName() 方法差不多，本質上都是根據 peeked 的值去進入不同的 if 語句來處理字符串。
2 JsonWriterJsonWriter 是 Gson 中用于 json 序列化的主體。
和 JsonReader 一樣，也可以不使用 Gson 門面而多帶帶使用 JsonWriter 進行 json 的序列化：
public static void main(String[] args){
//組裝 bean
Person person = new Person();
person.setName("zhangsan");
person.setAge(18);
//創建一個 StringWriter，本質是 StringBuffer 的封裝
StringWriter writer = new StringWriter();
//用 JsonWriter 去封裝 StringWriter
JsonWriter jsonWriter = new JsonWriter(writer);
try {
//啟動一個 object 的寫入
jsonWriter.beginObject();
//寫入 key-value
jsonWriter.name("name").value(person.getName());
jsonWriter.name("age").value(person.getAge());
//結束命令
jsonWriter.endObject();
//將 JsonWriter 里的數據存入到 StringWriter 中
jsonWriter.flush();
} catch (IOException e) {
e.printStackTrace();
}
System.out.println(writer.toString());
}
JsonWriter 的構造方法：
//JsonWriter.class
public JsonWriter(Writer out) {
if (out == null) {
throw new NullPointerException("out == null");
}
this.out = out;
}
追蹤一下 beginObject() 方法：
//JsonWriter.class
public JsonWriter beginObject() throws IOException {
//這個方法主要的作用是在不同的 object 之間加逗號
//如果是起始第一個 object 就不需要了，會直接跳過
writeDeferredName();
return open(EMPTY_OBJECT, "{");
}
繼續追蹤 open(...) 方法：
//JsonWriter.class
private JsonWriter open(int empty, String openBracket) throws IOException {
//該方法會使用 stack 中最新的指令進行操作
beforeValue();
//push(...) 方法會檢查 stack 數組的容積，適時進行擴容，并把傳入的指令存放到數組中
push(empty);
//寫入字符串
out.write(openBracket);
return this;
}
JsonWriter 中沒有 JsonReader 中那么復雜的指令操作，所以沒有引入 peeked 變量，僅僅使用 stack 數組來控制狀態。
stack 的控制封裝在 beforeValue() 方法中：
//JsonWriter.class
private void beforeValue() throws IOException {
//peek() 方法會根據 stack 數組的指令獲取到下一個要操作的字符類型
switch (peek()) {
case NONEMPTY_DOCUMENT:
if (!lenient) {
throw new IllegalStateException(
"JSON must have only one top-level value.");
}
case EMPTY_DOCUMENT:
//replaceTop(...) 方法會將 stack 最新的指令更新成傳入的參數
replaceTop(NONEMPTY_DOCUMENT);
break;
case EMPTY_ARRAY:
replaceTop(NONEMPTY_ARRAY);
//換行
newline();
break;
case NONEMPTY_ARRAY:
out.append(",");
newline();
break;
case DANGLING_NAME:
//separator 即為 ":" (冒號)
out.append(separator);
replaceTop(NONEMPTY_OBJECT);
break;
default:
throw new IllegalStateException("Nesting problem.");
}
}
來看一下 name(...) 方法：
//JsonWriter.class
public JsonWriter name(String name) throws IOException {
if (name == null) {
throw new NullPointerException("name == null");
}
if (deferredName != null) {
throw new IllegalStateException();
}
if (stackSize == 0) {
throw new IllegalStateException("JsonWriter is closed.");
}
//這一行代碼中會暫時將傳入的 name 參數保存在一個全局變量中，
//所以 JsonWriter 在調用 value(...) 方法之前不能再調用 name(...) 方法了，不然在上方的判斷中會報錯
deferredName = name;
return this;
}
來看一下 value(...) 方法：
//JsonWriter.class
public JsonWriter value(String value) throws IOException {
if (value == null) {
//nullValue() 方法會在 value 值的地方存入一個 null
return nullValue();
}
//這一方法會將 之前保存在 deferredName 中的字符串寫入到 writer 中
//方法中會處理加逗號、將 deferredName 變量清空等問題
//核心是調用 string(...) 方法寫入
writeDeferredName();
//更新 stack 指令
beforeValue();
//和上方寫入 deferredName 一樣，此處調用寫入 value
string(value);
return this;
}
總的來說 JsonWriter 比 JsonReader 簡單，簡要描述一下不過多展開。
四 JSON 字符串轉 Bean該 part 的起點：
Person person = gson.fromJson(json,Person.class);
追蹤 fromJson(...) 方法：
//Gson.class publicT fromJson(String json, Class classOfT) throws JsonSyntaxException { //將字符串轉成 object 的主體方法 //3.1 Object object = fromJson(json, (Type) classOfT); return Primitives.wrap(classOfT).cast(object); }
先來看一下上述的第二行代碼：
return Primitives.wrap(classOfT).cast(object);
Primitives.wrap(...) 方法的實現：
//Primitives.class public staticClass wrap(Class type) { //PRIMITIVE_TO_WRAPPER_TYPE 是一個 map 對象 //$Gson$Preconditions.checkNotNull(...) 用來效驗 type 不為空 @SuppressWarnings("unchecked") Class wrapped = (Class ) PRIMITIVE_TO_WRAPPER_TYPE.get( $Gson$Preconditions.checkNotNull(type)); //如果 map 中不存在 type 為 key 的值，則返回 type，否則返回取到的 value return (wrapped == null) ? type : wrapped; }
PRIMITIVE_TO_WRAPPER_TYPE 是一個定義在 Primitives 中的 map 對象：
