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