2021SC@SDUSC-SDUDOC-blog14

最新推荐文章于 2024-10-01 20:12:28 发布
最新推荐文章于 2024-10-01 20:12:28 发布
阅读量180 收藏
点赞数
分类专栏： 2021SC@SDUSC 文章标签： json
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Janchee/article/details/122160185
版权
本文深入解析JsonParser的工作原理，包括JsonFactory的创建、JsonParser的使用方法及过程，特别强调了其在解析速度上的优势。通过实例展示了如何利用它处理JSON数据并解析对象属性和数组。
摘要由CSDN通过智能技术生成

2021SC@SDUSC
engine部分。

后端核心engine部分架构：
在这里插入图片描述本篇分析JsonParser。
JasonParser是底层JSon解析器，类似于Java使用stAx解析xml，但JsonParser仅仅解析Json。JsonParser实现相较于ObjectMapper更底层，因此解析速度更快，但相对复杂。
一般情况下，要创建JsonParser需先创建JsonFactory。JsonFactory用于创建JsonParser实例，应该包含有几个createParser方法，实现对不同json来源的接收。
比如：

String carJson =
        "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";

JsonFactory factory = new JsonFactory();
JsonParser  parser  = factory.createParser(carJson);

创建完JsonParser实例后，可以用其解析json数据。JsonParser工作方式是将JSON分解成一系列标记(token)，逐个迭代这些标记进行解析。
分解方法：

String carJson =
        "{ \"brand\" : \"Mercedes\", \"doors\" : 5 }";

JsonFactory factory = new JsonFactory();
JsonParser  parser  = factory.createParser(carJson);

while(!parser.isClosed()){
    JsonToken jsonToken = parser.nextToken();

    System.out.println("jsonToken = " + jsonToken);
}

要JsonParser的isClosed()方法返回false，则说明源json仍有标记没有被解析。
通过JsonParser的nextToken()方法获得JsonToken，可以检查JsonToken实例的类型。
如果标记指针指向的是字段，JsonParser的getCurrentName()方法返回当前字段名称。getValueAsString() 返回当前标记值的字符串类型，同理 getValueAsInt()返回整型值，其他方法还有返回boolean, short, long, float, double 等类型。

本项目中使用的JsonParser ：

package cn.edu.sdu.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;


public class JsonParser {

    private final String json;

    public JsonParser(String json) {
        this.json = json;
    }

 
    public Object parse() {
        CharsRange trimmedJson = newRange(0, json.length()).trim();
        return processValue(trimmedJson);
    }

    private Object processPlainObject(CharsRange range) {
        List<Property> properties = processProperties(newRange(range.start + 1, range.end - 1));
        Map<String, Object> object = new HashMap<>();
        properties.forEach(prop -> object.put(prop.name, prop.value));
        //System.out.println(object);
        return object;
    }

    private List<Property> processProperties(CharsRange range) {
        List<Property> properties = new ArrayList<>();
        int nameStartMark = range.start;
        for (int i = range.start; i < range.end; i++) {
            char ch = json.charAt(i);
            if (ch == ':') {
                CharsRange nameToken = newRange(nameStartMark, i).trim();
                AtomicInteger readCursor = new AtomicInteger();
                CharsRange valueSegment = findNextValue(newRange(++i, range.end), readCursor);
                i = readCursor.intValue() + 1;
                nameStartMark = i;
                //System.out.println("nameToken:"+nameToken+",valueSegment:"+valueSegment);
                final String name = newRange(nameToken.start + 1, nameToken.end - 1).toString();
                final Object value = processValue(valueSegment);
                properties.add(Property.of(name, value));
            }
        }
        return properties;
    }

    private List<?> processArray(CharsRange range) {
        return processElements(newRange(range.start + 1, range.end - 1));
    }

    private List<?> processElements(CharsRange range) {
        List<Object> array = new ArrayList<>();
        int elementStartMark = range.start;
        for (int i = range.start; i < range.end; i++) {
            AtomicInteger readCursor = new AtomicInteger();
            CharsRange elementSegment = findNextValue(newRange(elementStartMark, range.end), readCursor);
            Object elementValue = processValue(elementSegment);
            array.add(elementValue);
            i = readCursor.intValue();
            elementStartMark = i + 1;
        }
        return array;
    }

    /**
     * @param chars
     * @return value segment trimmed.
     */
    private CharsRange findNextValue(CharsRange chars, AtomicInteger readCursor) {
        CharsRange trimChars = chars.trimLeft();
        if (trimChars.relativeChar(0) == '{') {
            return completeSymbolPair(trimChars, readCursor, "{}");
        } else if (trimChars.relativeChar(0) == '[') {
            return completeSymbolPair(trimChars, readCursor, "[]");
        } else {
            int i;
            for (i = trimChars.start + 1; i < trimChars.end; i++) {
                char ch = json.charAt(i);
                if (ch == ',') {
                    break;
                }
            }
            readCursor.set(i);
            return newRange(trimChars.start, i).trim();
        }
    }

    private CharsRange completeSymbolPair(CharsRange trimChars, AtomicInteger readCursor, String symbolPair) {
        int leftSymbol = symbolPair.charAt(0);
        int rightSymbol = symbolPair.charAt(1);
        int symbolsScore = 1;
        //nested object
        int i;
        CharsRange valueSegment = null;
        for (i = trimChars.start + 1; i < trimChars.end; i++) {
            char ch = json.charAt(i);
            if (ch == leftSymbol) {
                symbolsScore++;
            } else if (ch == rightSymbol) {
                symbolsScore--;
            }
            if (symbolsScore == 0) {
                valueSegment = newRange(trimChars.start, i + 1);
                break;
            }
        }

        for (; i < trimChars.end; i++) {
            char chx = json.charAt(i);
            if (chx == ',') {
                break;
            }
        }

        readCursor.set(i);
        return valueSegment;
    }

    private Object processValue(CharsRange valueSegment) {
        final Object value;
        if (valueSegment.relativeChar(0) == '"') {
            value = newRange(valueSegment.start + 1, valueSegment.end - 1).toString();
        } else if (valueSegment.relativeChar(0) == '{') {
            value = processPlainObject(valueSegment);
        } else if (valueSegment.relativeChar(0) == '[') {
            value = processArray(valueSegment);
        } else if (valueSegment.equalsString("true")) {
            value = true;
        } else if (valueSegment.equalsString("false")) {
            value = false;
        } else if (valueSegment.equalsString("null")) {
            value = null;
        } else {
            value = Double.parseDouble(valueSegment.toString());
        }
        return value;
    }

    static class Property {
        final String name;
        final Object value;

        Property(String name, Object value) {
            this.name = name;
            this.value = value;
        }

        static Property of(String name, Object value) {
            return new Property(name, value);
        }
    }

    CharsRange newRange(int start, int end) {
        return new CharsRange(start, end);
    }

    class CharsRange {
        final int start;
        final int end;

        CharsRange(int start, int end) {
            this.start = start;
            this.end = end;
        }

        CharsRange trimLeft() {
            int newStart = -1;
            for (int i = start; i < end; i++) {
                if (!Character.isWhitespace(json.charAt(i))) {
                    newStart = i;
                    break;
                }
            }

            if (newStart == -1) {
                throw new IllegalArgumentException("illegal blank string!");
            }
            return newRange(newStart, end);
        }

        CharsRange trimRight() {
            int newEnd = -1;

            for (int i = end - 1; i >= start; i--) {
                if (!Character.isWhitespace(json.charAt(i))) {
                    newEnd = i + 1;
                    break;
                }
            }
            if (newEnd == -1) {
                throw new IllegalArgumentException("illegal blank string!");
            }
            return newRange(start, newEnd);
        }

        CharsRange trim() {
            return this.trimLeft().trimRight();
        }

        char relativeChar(int index) {
            return json.charAt(start + index);
        }

        public boolean equalsString(String str) {
            return json.regionMatches(true, start, str, 0, str.length());
        }

        @Override
        public String toString() {
            return json.subSequence(start, end).toString();
        }
    }

}

构造方法中传入一个json对象

    public JsonParser(String json) {
        this.json = json;
    }

parse入口方法
return 解析完成的对象

 
    public Object parse() {
        CharsRange trimmedJson = newRange(0, json.length()).trim();
        return processValue(trimmedJson);
    }

定义私有方法processPlainObject中传入一个CharsRange对象，处理范围。

    private Object processPlainObject(CharsRange range) {
        List<Property> properties = processProperties(newRange(range.start + 1, range.end - 1));
        Map<String, Object> object = new HashMap<>();
        properties.forEach(prop -> object.put(prop.name, prop.value));
        //System.out.println(object);
        return object;
    }

CharsRange作为内部类实现：

  class CharsRange {
        final int start;
        final int end;

        CharsRange(int start, int end) {
            this.start = start;
            this.end = end;
        }

        CharsRange trimLeft() {
            int newStart = -1;
            for (int i = start; i < end; i++) {
                if (!Character.isWhitespace(json.charAt(i))) {
                    newStart = i;
                    break;
                }
            }

            if (newStart == -1) {
                throw new IllegalArgumentException("illegal blank string!");
            }
            return newRange(newStart, end);
        }

        CharsRange trimRight() {
            int newEnd = -1;

            for (int i = end - 1; i >= start; i--) {
                if (!Character.isWhitespace(json.charAt(i))) {
                    newEnd = i + 1;
                    break;
                }
            }
            if (newEnd == -1) {
                throw new IllegalArgumentException("illegal blank string!");
            }
            return newRange(start, newEnd);
        }

        CharsRange trim() {
            return this.trimLeft().trimRight();
        }

        char relativeChar(int index) {
            return json.charAt(start + index);
        }

        public boolean equalsString(String str) {
            return json.regionMatches(true, start, str, 0, str.length());
        }

        @Override
        public String toString() {
            return json.subSequence(start, end).toString();
        }
    }

给出了匹配处理方法。


    private List<Property> processProperties(CharsRange range) {
        List<Property> properties = new ArrayList<>();
        int nameStartMark = range.start;
        for (int i = range.start; i < range.end; i++) {
            char ch = json.charAt(i);
            if (ch == ':') {
                CharsRange nameToken = newRange(nameStartMark, i).trim();
                AtomicInteger readCursor = new AtomicInteger();
                CharsRange valueSegment = findNextValue(newRange(++i, range.end), readCursor);
                i = readCursor.intValue() + 1;
                nameStartMark = i;
                //System.out.println("nameToken:"+nameToken+",valueSegment:"+valueSegment);
                final String name = newRange(nameToken.start + 1, nameToken.end - 1).toString();
                final Object value = processValue(valueSegment);
                properties.add(Property.of(name, value));
            }
        }
        return properties;
    }

List存储property相关：

  private List<Property> processProperties(CharsRange range)
  private List<?> processArray(CharsRange range)
  private List<?> processElements

processvalue方法用分支结构处理，匹配、检测：
（整个处理部分其实可以优化）

    private Object processValue(CharsRange valueSegment) {
        final Object value;
        if (valueSegment.relativeChar(0) == '"') {
            value = newRange(valueSegment.start + 1, valueSegment.end - 1).toString();
        } else if (valueSegment.relativeChar(0) == '{') {
            value = processPlainObject(valueSegment);
        } else if (valueSegment.relativeChar(0) == '[') {
            value = processArray(valueSegment);
        } else if (valueSegment.equalsString("true")) {
            value = true;
        } else if (valueSegment.equalsString("false")) {
            value = false;
        } else if (valueSegment.equalsString("null")) {
            value = null;
        } else {
            value = Double.parseDouble(valueSegment.toString());
        }
        return value;
    }

查看当前的json定义：
主要是文档的名称、作者以及朝代等基础信息，预计后期开发还会进一步修改。根据新调整的xml标准，后期还要重新制定。


{
  "document_info":{
    "name":"文章名称",
    "Author": "作者名称",
    "dynasty": "朝代",
    "sections": ["Section.id", "Section.id", "Section.id", "......"],
    "......": "......"
  },
  "data":{
    "Page": [
      {
        "id": "",
        "image": ""
      }
    ],
    "Char": [
      {
        "id": "",
        "page": "Page.id",
        "points": [[0,0],[0,0],"..."],
        "x":0,
        "y":0,
        "word":"",
        "sentence":"",
        "paragraph":"",
        "section":""
      }
    ],
    "Word": [
      {
        "id": "",
        "page": "Page.id",
        "chars": ["Char.id", "Char.id", "Char.id", "......"]
      }
    ],
    "Sentence": [
      {
        "id": "",
        "page": "Page.id",
        "words": ["Word.id", "Word.id", "Word.id", "......"]
      }
    ],
    "Paragraph": [
      {
        "id": "",
        "page": "Page.id",
        "sentences": ["Sentence.id", "Sentence.id", "Sentence.id", "......"]
      }
    ],
    "Section": [
      {
        "id": "",
        "page": "Page.id",
        "paragraphs": ["Paragraph.id", "Paragraph.id", "Paragraph.id", "......"]
      }
    ]
  }
}
Chi Z犬里
关注
专栏目录
2021SC@SDUSC-SDUDOC-blog16
Ethereal的博客
12-27 270
本项目结构中，多个controller类进行后端事务的控制。 服务器和编辑器的通讯目前已经改成类protobuf接口，云端打开 有加入云端协作编辑的功能，暂时不表。 @RestController @RequestMapping("/article") public class DmsArticleController { @Resource private DmsArticleService dmsArticleService; @RequestMapping("/findA.
2021SC@SDUSC-SDUDOC-blog07
Ethereal的博客
11-01 321
2021SC@SDUSC 出现了些事故 本周分析项目后端sdudoc-mbg、sdudoc-mysql sdudoc-mbg MBG是Mybatis generator英文的缩写,是根据数据库中的表,反向生成实体类，DAO，Mapper文件的插件 pom.xml： <dependency> <groupId>org.mybatis</groupId> <artifactId>mybatis-spring&
2021SC@SDUSC-SDUDOC-blog15
Ethereal的博客
12-26 362
2021SC@SDUSC 后端engine config部分 体现分布式（双数据源）： //主数据源 ds1数据源 @Primary @Bean(name = "ds1DataSource") public DataSource ds1DataSource(@Qualifier("ds1DataSourceProperties") DataSourceProperties dataSourceProperties) { return dataSourceP
2021SC@SDUSC-SDUDOC-blog06
Ethereal的博客
11-01 263
demo代码分析 SDUDOC项目本周周会要求做svg示例，之前项目的学长给了demo示意，故本周分析此代码。电脑进水烧掉了，准备换。等发货再来补完这一个坑（或者删掉
2021SC@SDUSC-SDUDOC-blog00
Ethereal的博客
09-30 345
2021SC@SDUSC综述 小组选题为SDUDOC，与导师、学长交流后，通过组内协商，分工如下：戈同学负责逻辑引擎实现与基础UI绘制、刘同学负责图像渲染引擎与文档格式 杜同学负责后端服务器分布式架构、张同学负责后端数据库和数据分析。
2021SC@SDUSC-SDUDOC-blog17
Ethereal的博客
12-28 257
2021SC@SDUSC 分析登录控制模块。代码太长，直接写在注释里吧。 可以看出的功能是，登录仍然需要用户输入：账号密码。 虽然从现在主流的软件工程开发风格角度讲，账密不符合如今的低密码趋势，但是值得学习的地方是进行了加密操作。（起码不像某网站一样可以抓包到明文密码） @RestController @RequestMapping("/user") public class LoginController { @Autowired UmsUserRepository service;
2021SC@SDUSC-SDUDOC-blog09
Ethereal的博客
11-14 723
2021SC@SDUSC 中午和刘同学一起找戴老师查验了svg demo，进一步明确项目的用例规范方便未来扩展开发。 后端数据库部分，本周分析sdudoc-mysql的图片部分。
2021SC@SDUSC-SDUDOC-blog13
Ethereal的博客
12-20 233
2021SC@SDUSC 身份认证Authentication，和授权Authorization是不同的，Authentication指的是用户身份的认证，并不介入这个用户能够做什么，不能够做什么，仅仅是确认存在这个用户而已。而Authorization授权是建立的认证的基础上的，存在这个用户了，再来约定这个用户是否有权限处理这一件事。 AuthenticationEntryPoint是Spring Security Web一个概念模型接口，顾名思义，他所建模的概念是“认证入口点”。 它在用户请求处理过程
2021SC@SDUSC-SDUDOC-blog10
Ethereal的博客
12-13 122
2021SC@SDUSC 本周分析security部分的代码。 电脑最近一波九十九折，money- - 换新电脑没来得及配置手动忽略红线吧。 本片主要分析jwtAuthenticationTokenFilter部分。 整体看类间结构关系： public class RestfulAccessDeniedHandler implements AccessDeniedHandler public class RestAuthenticationEntryPoint implements Authentica
2021SC@SDUSC-山东大学软件工程与实践-Senta(七)
Casterrrrrrrr的博客
12-09 976
本期分析Senta中的评估标准Metric from __future__ import absolute_import from __future__ import division from __future__ import print_function import time import numpy as np from scipy.stats import pearsonr, spearmanr from six.moves import xrange import paddle.flui
2021SC@SDUSC-SDUDOC-blog11
Ethereal的博客
12-13 334
2021SC@SDUSC 接上篇继续分析dofilterinternal protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain) throws ServletException, IOException
2021SC@SDUSC amis-低代码前端框架代码分析 一
king_shenlin的博客
10-22 301
2021SC@SDUSC amis-低代码前端框架代码分析 一 目录2021SC@SDUSC amis-低代码前端框架代码分析 一概述代码分析总结 概述 amis是一个低代码前端框架。 本人首先分析布局，关于页面布局多为scss代码。 所以本人主要讲解scss代码部分，后续再分析其它类型代码。 代码分析 base 包里包含了三个scss代码 第一个_normalize.scss 源代码注释为英文，我改用中文来分析 html { line-height: 1.15; // line-height C
2021SC@SDUSC-山大智云源码分析（6）
Minori_wen的博客
11-14 446
2021SC@SDUSC 目录 2021SC@SDUSC server遗留问题 searpc_server_call_function searpc_compute_signature register_func searpc_server_register_marshal searpc-codegen.py type_table server遗留问题 searpc_server_call_function char* searpc_server_call_function (c
2021SC@SDUSC-山大智云源码分析（10）
Minori_wen的博客
12-11 1673
2021SC@SDUSC 异步接收消息的searpc客户端 searpc的客户端也支持了异步方法,在demo-async-client.c可以看到其使用方法. 在SearpcClient的定义中,已经为异步方法提供了支持;同时也定义了异步调用rpc函数的一些方法,如searpc_client_async_call__{}等 struct _SearpcClient { TransportCB send; void *arg; AsyncTransportSend async
话术挂断之后是否处理事件
H4_9Y的博客
09-30 395
流程：自动外呼进入机器人话术。问题：在机器人放音时用户挂断后，话术还会继续匹配流程，如果匹配上的是放音节点，还会进行放音，那么在数据库表中就会多出一条放音记录。出现这个问题是因为在cti.json文件中配置了，该配置的作用：挂断之后是否继续处理事件，如果不开启，用户说话之后没等ASR识别完成就挂机，会丢失识别结果，开启后会有complete事件参数HANGUP(F说话内容)；如果开启，在挂断之后会继续处理事件。
前台项目启动/打包报错 Error: error:0308010C:digital envelope routines::unsupported
BigBigHang的博客
09-26 350
前台项目启动/打包报错 Error: error:0308010C:digital envelope routines::unsupported
沂机管理系统/data/Ajax.aspx接口存在SQL注入漏洞
最新发布
2301_77012231的博客
10-01 278
沂机管理系统/data/Ajax.aspx接口存在SQL注入漏洞，攻击者可以获取服务器权限。bp 报错泄露绝对路径。sqlmap确认有漏洞。
点评项目-2-完善注册登录业务
m0_75138009的博客
09-29 481
需要处理的业务：在网页发送 /user/code 路径下的 post 请求后，我们需要检验手机号后，向合法的手机号发送一个随机生成的电话号。
APM1403SC-TRL-VB：P沟道20V MOSFET技术规格
"APM1403SC-TRL-VB是一种P沟道MOSFET，采用SC70-3封装，适用于负载开关和DC/DC转换器等应用。这款MOSFET具有无卤素、TrenchFET功率MOSFET技术、100%栅极电阻测试以及符合RoHS指令等特点。其主要参数包括最大20V的漏...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Chi Z犬里

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值