摘要：接上篇三和在进行的序列化和反序列化源码解析之前先了解一下其主体工具类。是中用于序列化的主体。同时为了兼顾性能做了很多有意思的设计，比如获取适配器的时候的双缓存设计，应该是为了提高解析器的复用效率，具体有待研究。
接上篇 三 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 对象：
