Gson中JsonReader的源码解析

于 2023-03-15 20:20:57 发布
阅读量445 收藏
点赞数
文章标签： java json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32035241/article/details/129567151
版权

JsonReader 的源码解析

JsonReader是用来反序列化Json字符串的主要类。

重点属性

stack： 一个int数组，默认32位

stackSize: 栈的长度

Peeked： 当前字符的状态 一共有17种状态

状态值作用
PEEKED_NONE0
PEEKED_BEGIN_OBJECT1
PEEKED_END_OBJECT2
PEEKED_BEGIN_ARRAY3
PEEKED_END_ARRAY4
PEEKED_TRUE5
PEEKED_FALSE6
PEEKED_NULL7
PEEKED_SINGLE_QUOTED8
PEEKED_DOUBLE_QUOTED9
PEEKED_UNQUOTED10
PEEKED_BUFFERED11
PEEKED_SINGLE_QUOTED_NAME12
PEEKED_DOUBLE_QUOTED_NAME13
PEEKED_UNQUOTED_NAME14
PEEKED_NUMBER15
PEEKED_EOF16

JsonScope：8种状态，当前层级的状态peekStack

状态值
EMPTY_ARRAY1
NONEMPTY_ARRAY2
EMPTY_OBJECT3
DANGLING_NAME4
NONEMPTY_OBJECT5
EMPTY_DOCUMENT6
NONEMPTY_DOCUMENT7
CLOSED8

重点方法：

  • doPeek()

这个方法是最重要的一个方法，该方法进行字符读取，并根据当前的层级状态peekStack来处理字符串，最后返回将要处理字符的状态Peeked。

我们需要知道Json是一个层级的树形，它是一层一层的，主要是通过[]、{}来对数据进行层级的分层。

{
  stack[stackSize++] = JsonScope.EMPTY_DOCUMENT;
}
  int peeked = PEEKED_NONE;

首先，它在构造代码块中先将层级定位1层，此时代码的层级是1，代码层级的状态是EMPTY_DOCUMENT，peeked的初始状态是PEEKED_NONE。

我们以一个简单的例子，走一下,在此为了更好的理解，会交叉写一下其他的方法。

{"a": ["one"], "b": 123}

若要反序列化这个字符串，需要这样读。

 JsonReader reader = new JsonReader(reader(
        "{\"a\": [\"one\"], \"b\": 123}"));
 reader.beginObject();
 reader.nextName();
 reader.beginArray();
 reader.nextString();
 reader.endArray();
 reader.nextName();
 reader.nextInt();
 reader.endObject();

reader.beginObject()中会看到:

 public void beginObject() throws IOException {
    int p = peeked;
    if (p == PEEKED_NONE) {
      p = doPeek();
    }
   ...
  }

都会先走dopeek()方法，获取PeekStack，进行判断字符状态。

在这里插入图片描述

初始化时，PeekStack=EMPTY_DOCUMENT

else if (peekStack == JsonScope.EMPTY_DOCUMENT) {
  if (lenient) {
    consumeNonExecutePrefix();//这一步就是把前面无关的字符删除，比如空格，· 等不属于json的字符
  }
  stack[stackSize - 1] = JsonScope.NONEMPTY_DOCUMENT;
} 
//此时stack[NONEMPTY_DOCUMENT],StackSize=1

将当前层级的状态修改为了JsonScope.NONEMPTY_DOCUMENT。

 int c = nextNonWhitespace(true); //这个方法是读取下一个字符
    switch (c) {
    ...
    case '{':
      return peeked = PEEKED_BEGIN_OBJECT;
    default:
      pos--; // Don't consume the first character in a literal value.
    }

根据字符的ASCii码对相应的字符返回相应的字符状态，根据以上代码会返回 peeked = PEEKED_BEGIN_OBJECT。

接着看beginObject(),

if (p == PEEKED_BEGIN_OBJECT) {
  push(JsonScope.EMPTY_OBJECT);
  peeked = PEEKED_NONE;
} else {
  throw new IllegalStateException("Expected BEGIN_OBJECT but was " + peek() + locationString());
}

  private void push(int newTop) {
      ...
      stack[stackSize++] = newTop;
    }
//此时stack[NONEMPTY_DOCUMENT,EMPTY_OBJECT],StackSize =2;

当字符是PEEKED_BEGIN_OBJECT时，会在stack[]中添加新的层级EMPTY_OBJECT,StackSize+1。接着看nextName(),

 public String nextName() throws IOException {
    int p = peeked;
    if (p == PEEKED_NONE) {
      p = doPeek();
    }
  ...
  }

它也会走dopeek()，这时取到的PeekStack = PEEKED_BEGIN_OBJECT。

if (peekStack == JsonScope.EMPTY_OBJECT || peekStack == JsonScope.NONEMPTY_OBJECT) {
      stack[stackSize - 1] = JsonScope.DANGLING_NAME;
      // Look for a comma before the next element.
 			...
      int c = nextNonWhitespace(true);
      switch (c) {
      case '"':
        return peeked = PEEKED_DOUBLE_QUOTED_NAME;
     ...
      default:
      ...
      }
    }
//此时stack[NONEMPTY_DOCUMENT,DANGLING_NAME],StackSize =2;

将当前的层级状态改为DANGLING_NAME，并返回字符状态为PEEKED_DOUBLE_QUOTED_NAME，再看nextName()

   String result;
    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_NONE;
    pathNames[stackSize - 1] = result;
    return result;

nextQuotedValue('"')会读取到""中的内容给result中，接着将peeked设置为PEEKED_NONE。到这里我们会发现PEEKED_NONE是新的字符开始读取和结束的状态。

接着 reader.beginArray();,beginArray()和beginObject()方法很像，我们走一下，还是先走doPeek()

if (peekStack == JsonScope.DANGLING_NAME) {
  stack[stackSize - 1] = JsonScope.NONEMPTY_OBJECT;
  // Look for a colon before the value.
  int c = nextNonWhitespace(true);
  switch (c) {
    case ':':
      break;
    case '=':
      checkLenient();
      if ((pos < limit || fillBuffer(1)) && buffer[pos] == '>') {
        pos++;
      }
      break;
    default:
      throw syntaxError("Expected ':'");
  }
}
//此时stack[NONEMPTY_DOCUMENT,NONEMPTY_OBJECT],StackSize =2;

此时的层级状态为DANGLING_NAME，会修改成NONEMPTY_OBJECT,在:处break,dopeek()接着往下走。

int c = nextNonWhitespace(true);//读取下一个字符
    switch (c) {
  		...
    case '[':
      return peeked = PEEKED_BEGIN_ARRAY;
      ...
    default:
      pos--; // Don't consume the first character in a literal value.
    }

会返回字符的状态PEEKED_BEGIN_ARRAY。 在看beginArray()，会在stack[]中再加一层，StackSize+1。

 //begainArray
if (p == PEEKED_BEGIN_ARRAY) {
      push(JsonScope.EMPTY_ARRAY);
      pathIndices[stackSize - 1] = 0;
      peeked = PEEKED_NONE;
    } else {
      throw new IllegalStateException("Expected BEGIN_ARRAY but was " + peek() + locationString() + "，v="+nextErrorString());
    }
//此时stack[NONEMPTY_DOCUMENT,NONEMPTY_OBJECT,EMPTY_ARRAY],StackSize =3

reader.nextString();仍然先走dopeek()

if (peekStack == JsonScope.EMPTY_ARRAY) {
  stack[stackSize - 1] = JsonScope.NONEMPTY_ARRAY;
}
 int c = nextNonWhitespace(true);
    switch (c) {
    case '"':
      return peeked = PEEKED_DOUBLE_QUOTED;
    default:
      pos--; // Don't consume the first character in a literal value.
    }
//此时stack[NONEMPTY_DOCUMENT,NONEMPTY_OBJECT,NONEMPTY_ARRAY],StackSize =3

然后在nextString()中将nextQuotedValue('"'),将双引号中的字符读取出来。字符状态恢复到PEEKED_NONE。

reader.endArray(); 仍然先走dopeek()

if (peekStack == JsonScope.NONEMPTY_ARRAY) {
  // Look for a comma before the next element.
  int c = nextNonWhitespace(true);
  switch (c) {
    case ']':
      return peeked = PEEKED_END_ARRAY;
    case ';':
      checkLenient(); // fall-through
    case ',':
      break;
    default:
      throw syntaxError("Unterminated array");
  }
}

会返回字符状态PEEKED_END_ARRAY，看一下endArray().

if (p == PEEKED_END_ARRAY) {
  stackSize--;
  pathIndices[stackSize - 1]++; //为了记录路径使用的
  peeked = PEEKED_NONE;
} else {
  throw new IllegalStateException("Expected END_ARRAY but was " + peek() + locationString());
}
//此时stack[NONEMPTY_DOCUMENT,NONEMPTY_OBJECT],StackSize =2 

//实际上stack[NONEMPTY_DOCUMENT,NONEMPTY_OBJECT,NONEMPTY_ARRAY]，但是NONEMPTY_ARRAY这个已经无关紧要了只是没有清0而已

reader.nextName();仍然先走doPeek().

if (peekStack == JsonScope.EMPTY_OBJECT || peekStack == JsonScope.NONEMPTY_OBJECT) {
      stack[stackSize - 1] = JsonScope.DANGLING_NAME;
      // Look for a comma before the next element.
      if (peekStack == JsonScope.NONEMPTY_OBJECT) {
        int c = nextNonWhitespace(true);
        switch (c) {
        ...
        case ',':
          break;
        ...
        }
      }
      int c = nextNonWhitespace(true);
      switch (c) {
      case '"':
        return peeked = PEEKED_DOUBLE_QUOTED_NAME;
        ...
      }
    }
//此时stack[NONEMPTY_DOCUMENT,DANGLING_NAME],StackSize =2

返回字符状态PEEKED_DOUBLE_QUOTED_NAME，nextName()中，会读取字符串的值，并将字符移动到"的位置。

reader.nextInt(),仍然先走doPeek()

if (peekStack == JsonScope.DANGLING_NAME) {
      stack[stackSize - 1] = JsonScope.NONEMPTY_OBJECT;
      // Look for a colon before the value.
      int c = nextNonWhitespace(true);
      switch (c) {
      case ':':
        break;
      default:
        throw syntaxError("Expected ':'");
      }
    } 
result = peekNumber();
if (result != PEEKED_NONE) {
  return result;
}
//此时stack[NONEMPTY_DOCUMENT,NONEMPTY_OBJECT],StackSize =2

peekNumber()方法会读取:后的数字，正常情路下主要返回PEEKED_LONG和PEEKED_NUMBER这两个状态，在nextInt()中去读取要读取的字符串。

reader.endObject(); 仍然走dopeek(),返回字符状态PEEKED_END_OBJECT。

if (peekStack == JsonScope.NONEMPTY_OBJECT) {
  int c = nextNonWhitespace(true);
  switch (c) {
    case '}':
      return peeked = PEEKED_END_OBJECT;
      ...
    default:
      throw syntaxError("Unterminated object");
  }
}

endObject()中会将stack[]进行更新。

 if (p == PEEKED_END_OBJECT) {
      stackSize--;
      pathNames[stackSize] = null; // Free the last path name so that it can be garbage collected!
      pathIndices[stackSize - 1]++;
      peeked = PEEKED_NONE;
    } else {
      throw new IllegalStateException("Expected END_OBJECT but was " + peek() + locationString());
    }
//此时stack[NONEMPTY_DOCUMENT],StackSize =1

到此整个上面代码的源码流程就走完了，因为走的是正常情况，中间的纠错没有细致来分析，但此时stack[]仍然是NONEMPTY_DOCUMENT，是不是就还可以继续往下走，可以用JsonReader#peek()，仍然走dopeek()

if (peekStack == JsonScope.NONEMPTY_DOCUMENT) {
  int c = nextNonWhitespace(false);
  if (c == -1) {
    return peeked = PEEKED_EOF;
  } else {
    checkLenient();
    pos--;
  }
}
//此时stack[NONEMPTY_DOCUMENT],StackSize =1 仍然不变

但是会返回字符状态PEEKED_EOF，这是结束的标志。

由以上的流程来总结一下doPeek()方法：

根据JsonCope来返回当前的字符状态，主要处理JsonCope的状态，读取下一个字符，判断当前字符的状态。

//第一个流程 能直接根据当前字符和JsonScope确定当前字符状态的
 if (peekStack == JsonScope.EMPTY_ARRAY) {
      stack[stackSize - 1] = JsonScope.NONEMPTY_ARRAY;
    } else if (peekStack == JsonScope.NONEMPTY_ARRAY) {
      // Look for a comma before the next element.
      int c = nextNonWhitespace(true);
      switch (c) {
      case ']':
        return peeked = PEEKED_END_ARRAY;
      case ';':
        checkLenient(); // fall-through
      case ',':
        break;
      default:
        throw syntaxError("Unterminated array");
      }
    } else if (peekStack == JsonScope.EMPTY_OBJECT || peekStack == JsonScope.NONEMPTY_OBJECT) {
      stack[stackSize - 1] = JsonScope.DANGLING_NAME;
      // Look for a comma before the next element.
      if (peekStack == JsonScope.NONEMPTY_OBJECT) {
        int c = nextNonWhitespace(true);
        switch (c) {
        case '}':
          return peeked = PEEKED_END_OBJECT;
        case ';':
          checkLenient(); // fall-through
        case ',':
          break;
        default:
          throw syntaxError("Unterminated object");
        }
      }
      int c = nextNonWhitespace(true);
      switch (c) {
      case '"':
        return peeked = PEEKED_DOUBLE_QUOTED_NAME;
      case '\'':
        checkLenient();
        return peeked = PEEKED_SINGLE_QUOTED_NAME;
      case '}':
        if (peekStack != JsonScope.NONEMPTY_OBJECT) {
          return peeked = PEEKED_END_OBJECT;
        } else {
          throw syntaxError("Expected name");
        }
      default:
        checkLenient();
        pos--; // Don't consume the first character in an unquoted string.
        if (isLiteral((char) c)) {
          return peeked = PEEKED_UNQUOTED_NAME;
        } else {
          throw syntaxError("Expected name");
        }
      }
    } else if (peekStack == JsonScope.DANGLING_NAME) {
      stack[stackSize - 1] = JsonScope.NONEMPTY_OBJECT;
      // Look for a colon before the value.
      int c = nextNonWhitespace(true);
      switch (c) {
      case ':':
        break;
      case '=':
        checkLenient();
        if ((pos < limit || fillBuffer(1)) && buffer[pos] == '>') {
          pos++;
        }
        break;
      default:
        throw syntaxError("Expected ':'");
      }
    } else if (peekStack == JsonScope.EMPTY_DOCUMENT) {
      if (lenient) {
        consumeNonExecutePrefix();
      }
      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--;
      }
    } else if (peekStack == JsonScope.CLOSED) {
      throw new IllegalStateException("JsonReader is closed");
    }
//第二步 消费下一个字符 
 int c = nextNonWhitespace(true);
    switch (c) {
    case ']':
      if (peekStack == JsonScope.EMPTY_ARRAY) {
        return peeked = PEEKED_END_ARRAY;
      }
      // fall-through to handle ",]"
    case ';':
    case ',':
      // In lenient mode, a 0-length literal in an array means 'null'.
      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--; // Don't consume the first character in a literal value.
    }
//若以上未消费，
int result = peekKeyword();//主要是处理true,false,null
    if (result != PEEKED_NONE) {
      return result;
    }

    result = peekNumber();//主要是处理int,short,byte,long,flat,double类型的
    if (result != PEEKED_NONE) {
      return result;
    }
qq_32035241
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Gson解析Json示例源码
09-13
在Gson类库有一个Gson类，这个Gson类提供了两个方法：toJson() 和fromJson()，我们主要就是调用这两个方法来分别实现序列化Java对象为JSON字符串和反序列化JSON字符串成Java对象。 通过代码示例来对Gson类的常用方法...
Gson读取Json文件并解析
qq_52160611的博客
04-19 980
读取hotCitySites所有的city对象，所以还需要建一个实体类。在maven 项目下，需要导入Gson坐标。
巧用JsonReader+JsonPath解析大json文本（300M+），解决Java heap space，支持根据json的key值自定义解析
javaMylief的博客
08-09 1599
将json文件内容read出来 然后 JsonUtils 工具类转换 list 内容一旦很多，就容易java help space。我采用的是com.google.gson.stream.JsonReader这个工具类是按照符号顺序读取的，不是一下加载到内存中的，因此可以支持大json文件...............
Gson全解析之二：JsonReader的其它方法
王梵
04-14 7239
上篇文章的示例代码 String json = "{\"name\":\"wisely\",\"age\":\"18\"}"; private void readJson2User(){ User user = new User(); StringReader reader = new StringReader(json); JsonReader jsonReader
【第14篇】通过GSON的JsonReader去读取数据处理json数据
jilongliang的专栏
01-19 6814
通过GSON的JsonReader去读取数据处理json数据
使用Gson的JsonReader解析Json数据
wuyou1336的博客
07-27 9527
原址：http://blog.csdn.net/jackie_xiaonan/article/details/15026901 自定义解析过程         这里把问题简化一下，比如获得到的json字符串是 [{"name":"Jackie","age":30,"contact":{"email":"email","phoneno":"phoneno"}},{"name":"
Gson_Json解析源码
02-03
Gson_Json解析源码
Android中使用Gson解析JSON数据的两种方法
09-05
Json是一种类似于XML的通用数据交换格式,具有比XML更高的传输效率;本文将介绍两种方法解析JSON数据，需要的朋友可以参考下
gson-2.8.0，解析json
11-03
Gson解析json，下载后打开zip文件即可得到里面gson2.8.0.jar导入AS工具即可使用
gson-master解析
06-02
gson-master解析 gson解析，demo. 可以拿来借鉴一下，参考一下开发。
JsonReader的使用
小姓程，请叫我序员的专栏
02-27 9059
public void test() throws IOException { String jsonString = "[{\"username\":\"xujiaowei\",\"userId\":\"28\"},{\"username\":\"Jason\",\"userId\":\"002\"}}]"; JsonReader jsonReader = new JsonReader(ne
Fastjson源码分析—JSONReader的使用和原理
qq_45854465的博客
11-24 4105
2021SC@SDUSC 目录JSONReader使用方法JSONReader源码分析startArray方法readStringJSONReader性能测试Gson测试代码：Gson内存和cpu占用情况FastJSON测试代码FastJSON内存和cpu占用情况总结 前面几篇文章分析的都是Fastjson对于少量json字符串的反序列化。我们不需要考虑内存的消耗，也难以察觉出Fastjson性能上的优越。但是当数据量庞大时，单纯的使用JSON.parseObject会产生严重问题，最明显的就是内存溢出。
Gson全解析之一：JsonReader的beginObject(）
王梵
04-12 3173
Gson是Google出品的开源项目，专门用来解析json格式的数据，整个Gson源码全解析主要分为如下几个部分 JsonReader的源码分析 JsonReader 如果按重要性，对Gson中的类排个序，我绝对把JsonReader排在第一，它是底层真正解析json格式数据的支持类，是非常值得一看的类。 我们来看一个简单的解析。 String json = "{\"na
java gson解析,追踪解析Gson源码(2)
weixin_35361584的博客
03-19 279
接上篇三 JsonReader 和 JsonWriter在进行 json 的序列化和反序列化源码解析之前先了解一下其主体工具类。1 JsonReaderJsonReader 是 Gson 中用于 json 反序列化的主体。在 Gson 包中可以不使用 Gson 门面而单独使用 JsonReader 进行 json 的反序列化：public static void main(String[] arg...
Json树的使用案例,用到Gson和JsonReader
赫双炎
02-08 458
案例说明 我有一个json格式的数据文件叫hashTagTree.json，这个文件里面存放的是一个树状的数据。 对应的单个节点的，java实体如下： public class JsonTreeNode { private String name; private BigDecimal value; private List<JsonTreeNode> children; public String getName() { return n.
Java基础之JsonReader解析Json数组 196 JsonReader解析复杂Json文件 197 生成JSON数据与GSON工具的使用 198
C_time的博客
05-05 3785
9、JSON 刚刚上个博客说的XML一般用于做配置文件 数据传输 但是JSON更适合做数据传输 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 JSON 官方:http://www.json.org Notation标记 JSON 数据格式的特点 JSON 建构于两种结构： 1、 “名称/值”对的集合 2.、 值的有序列表（数组） JSON 表示名称...
Android 之 json数据的解析（jsonReader）
baidu_28924013的博客
11-27 636
json数据的解析相对而言，还是比较容易的，实现的代码也十分简单。这里用的是jsonReade方法来进行json数据解析。   1.在解析之前，大家需要知道什么是json数据。   json数据存储的对象是无序的“名称/值”对的集合。和其他的数据存储方式相比，json数据的可读性，可扩展性，编码难度，解码难度都有一定的优势。在json数据中，   对于一个对象： （1）一个对象以“{
使用JsonTextReader提高Json.NET反序列化的性能
无风听海
02-24 249
在服务器的文件系统上有一个业务生成的BigTable.json文件，其可能包含的JSON字符串很大，同时里边的集合会包含很多的记录；我们使用以下的代码来反序列化，虽然使用了异步的ReadAllTextAsync来读取文件，但是还是需要将整个的文件内容都读取到内存中，这样会极大的占用服务器内存，同时分配太多对象或分配非常大的对象会导致垃圾收集减慢甚至停止应用程序；通过以上分析，我们可以直接使用二进制的文件流来读取文件，并将它传递给JsonTextReader，这样就可以实现小片段的读取并序列化；
Json文件解析
unspoken0714的博客
06-06 938
Json文件 参考blog：json文件格式详解 JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。 易于人阅读和编写。同时也易于机器解析和生成。 示例： { "topics": [ { "topic": "/RFC01", "type": "ld_image" }, { "topic": "/hesai_2", "type":
Gson String格式json解析
最新发布
06-10
在这个例子中，我们首先定义了一个包含JSON数据的字符串，然后使用Gson对象来将其解析成一个Person对象。在fromJson()方法中，第一个参数是要解析的JSON字符串，第二个参数是要转换成的Java对象的类型。在这个例子中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值