jsonobject解析json字符串特别慢（json格式转换文本的方法）

版本约定

• jackson 版本：2.11.0
• spring framework 版本：5.2.6.release
• spring boot 版本：2.3.0.release

什么叫读 json？就是把一个 json 字符串 解析为对象 or 树模型嘛，因此也称作解析 json 串。jackson 底层流式 api 使用jsonparser来完成json 字符串的解析。

最简使用 demo

准备一个 pojo：

@data
public class person {
    private string name;
    private integer age;
}

测试用例：把一个 json 字符串绑定（封装）进一个 pojo 对象里

@test
public void test1() throws ioexception {
    string jsonstr = "{"name":"yourbatman","age":18}";
    person person = new person();

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {

        // 只要还没结束"}"，就一直读
        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("name".equals(fieldname)) {
                jsonparser.nexttoken();
                person.setname(jsonparser.gettext());
            } else if ("age".equals(fieldname)) {
                jsonparser.nexttoken();
                person.setage(jsonparser.getintvalue());
            }
        }

        system.out.println(person);
    }
}

运行程序，输出：

person(name=yourbatman, age=18)

成功把一个 json 字符串的值解析到 person 对象。你可能会疑问，怎么这么麻烦？那当然，这是底层流式 api，纯手动档嘛。你获得了性能，可不要失去一些便捷性嘛。

小贴士：底层流式 api 一般面向“专业人士”，应用级开发使用高阶 api objectmapper即可。当然，读完本系列就能让你完全具备“专业人士”的实力

jsonparser针对不同的 value 类型，提供了非常多的方法用于实际值的获取。

直接值获取：

// 获取字符串类型
public abstract string gettext() throws ioexception;

// 数字 number 类型值 标量值（支持的 number 类型参照 numbertype 枚举）
public abstract number getnumbervalue() throws ioexception;
public enum numbertype {
    int, long, big_integer, float, double, big_decimal
};

public abstract int getintvalue() throws ioexception;
public abstract long getlongvalue() throws ioexception;
...
public abstract byte[] getbinaryvalue(base64variant bv) throws ioexception;

这类方法可能会抛出异常：比如 value 值本不是数字但你调用了 getinvalue()方法~

小贴士：如果 value 值是 null，像 getintvalue()、getbooleanvalue()等这种直接获取方法是会抛出异常的，但 gettext()不会

带默认值的值获取，具有更好安全性：

public string getvalueasstring() throws ioexception {
    return getvalueasstring(null);
}
public abstract string getvalueasstring(string def) throws ioexception;
...
public long getvalueaslong() throws ioexception {
    return getvalueaslong(0);
}
public abstract long getvalueaslong(long def) throws ioexception;
...

此类方法若碰到数据的转换失败时，不会抛出异常，把def作为默认值返回。

组合方法

同jsongenerator一样，jsonparser 也提供了高钙片组合方法，让你更加便捷的使用。

自动绑定

听起来像高级功能，是的，它必须依赖于objectcodec去实现，因为实际是全部委托给了它去完成的，也就是我们最为熟悉的 readxxx 系列方法：

我们知道，objectmapper 就是一个 objectcodec，它属于高级 api，本文显然不会用到 objectmapper 它喽，因此我们自己手敲一个实现来完成此功能。

自定义一个 objectcodec，person 类专用：用于把 json 串自动绑定到实例属性。

public class personobjectcodec extends objectcodec {
    ...
    @sneakythrows
    @override
    public <t> t readvalue(jsonparser jsonparser, class<t> valuetype) throws ioexception {
        person person = (person) valuetype.newinstance();

        // 只要还没结束"}"，就一直读
        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("name".equals(fieldname)) {
                jsonparser.nexttoken();
                person.setname(jsonparser.gettext());
            } else if ("age".equals(fieldname)) {
                jsonparser.nexttoken();
                person.setage(jsonparser.getintvalue());
            }
        }

        return (t) person;
    }
    ...
}

有了它，就可以实现我们的自动绑定了，书写测试用例：

@test
public void test3() throws ioexception {
    string jsonstr = "{"name":"yourbatman","age":18, "pickname":null}";

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {
        jsonparser.setcodec(new personobjectcodec());

        system.out.println(jsonparser.readvalueas(person.class));
    }
}

运行程序，输出：

person(name=yourbatman, age=18)

这就是 objectmapper 自动绑定的核心原理所在，其它更为强大能力将在后续章节详细展开。

jsontoken

在上例解析过程中，有一个非常重要的角色，那便是：jsontoken。它表示解析 json 内容时，用于返回结果的基本标记类型的枚举。

public enum jsontoken {
    not_available(null, jsontokenid.id_not_available),

    start_object("{", jsontokenid.id_start_object),
    end_object("}", jsontokenid.id_end_object),
    start_array("[", jsontokenid.id_start_array),
    end_array("]", jsontokenid.id_end_array),

    // 属性名（key）
    field_name(null, jsontokenid.id_field_name),

    // 值（value）
    value_embedded_object(null, jsontokenid.id_embedded_object),
    value_string(null, jsontokenid.id_string),
    value_number_int(null, jsontokenid.id_number_int),
    value_number_float(null, jsontokenid.id_number_float),
    value_true("true", jsontokenid.id_true),
    value_false("false", jsontokenid.id_false),
    value_null("null", jsontokenid.id_null),
}

为了辅助理解，a 哥用一个例子，输出各个部分一目了然：

@test
public void test2() throws ioexception {
    string jsonstr = "{"name":"yourbatman","age":18, "pickname":null}";
    system.out.println(jsonstr);
    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {

        while (true) {
            jsontoken token = jsonparser.nexttoken();
            system.out.println(token + " -> 值为:" + jsonparser.getvalueasstring());

            if (token == jsontoken.end_object) {
                break;
            }
        }
    }
}

运行程序，输出：

{"name":"yourbatman","age":18, "pickname":null}
start_object -> 值为:null

field_name -> 值为:name
value_string -> 值为:yourbatman

field_name -> 值为:age
value_number_int -> 值为:18

field_name -> 值为:pickname
value_null -> 值为:null

end_object -> 值为:null

从左至右解析，一一对应。各个部分用下面这张图可以简略表示出来：

小贴士：解析时请确保你的的 json 串是合法的，否则抛出jsonparseexception异常

jsonparser 的 feature

它是 jsonparser 的一个内部枚举类，共 15 个枚举值：

public enum feature {
    auto_close_source(true),

    allow_comments(false),
    allow_yaml_comments(false),
    allow_unquoted_field_names(false),
    allow_single_quotes(false),
    @deprecated
    allow_unquoted_control_chars(false),
    @deprecated
    allow_backslash_escaping_any_character(false),
    @deprecated
    allow_numeric_leading_zeros(false),
    @deprecated
    allow_leading_decimal_point_for_numbers(false),
    @deprecated
    allow_non_numeric_numbers(false),
    @deprecated
    allow_missing_values(false),
    @deprecated
    allow_trailing_comma(false),

    strict_duplicate_detection(false),
    ignore_undefined(false),
    include_source_in_location(true);
}

小贴士：枚举值均为 bool 类型，括号内为默认值

每个枚举值都控制着jsonparser不同的行为。下面分类进行解释

底层 i/o 流相关

自 2.10 版本后，使用streamreadfeature#auto_close_source代替

jackson 的流式 api 指的是 i/o 流，所以即使是读，底层也是用 i/o 流（reader）去读取然后解析的。

autoclosesource(true)

原理和 jsongenerator 的auto_close_target(true)一样，不再解释。

支持非标准格式

json 是有规范的，在它的规范里并没有描述到对注释的规定、对控制字符的处理等等，也就是说这些均属于非标准行为。比如这个 json 串：

{
    "name" : "yourbarman", // 名字
    "age" : 18 // 年龄
}

你看，若你这么写 idea 都会飘红提示你：

但是，在很多使用场景（特别是 javascript）里，我们会在 json 串里写注释（属性多时尤甚）那么对于这种串，jsonparser 如何控制处理呢？它提供了对非标准 json 格式的兼容，通过下面这些特征值来控制。

allow_comments(false)

自 2.10 版本后，使用jsonreadfeature#allow_java_comments代替

是否允许/* */或者//这种类型的注释出现。

@test
public void test4() throws ioexception {
    string jsonstr = "{n" +
            "t"name" : "yourbarman", // 名字n" +
            "t"age" : 18 // 年龄n" +
            "}";

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {
        // 开启注释支持
        // jsonparser.enable(jsonparser.feature.allow_comments);

        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("name".equals(fieldname)) {
                jsonparser.nexttoken();
                system.out.println(jsonparser.gettext());
            } else if ("age".equals(fieldname)) {
                jsonparser.nexttoken();
                system.out.println(jsonparser.getintvalue());
            }
        }
    }
}

运行程序，抛出异常：

com.fasterxml.jackson.core.jsonparseexception: unexpected character ('/' (code 47)): maybe a (non-standard) comment? (not recognized as one since feature 'allow_comments' not enabled for parser)
 at [source: (string)"{
    "name" : "yourbarman", // 名字
    "age" : 18 // 年龄
}"; line: 2, column: 26]

放开注释的代码，再次运行程序，正常 work。

allowyamlcomments(false)

自 2.10 版本后，使用jsonreadfeature#allow_yaml_comments代替

顾名思义，开启后将支持 yaml 格式的的注释，也就是#形式的注释语法。

allowunquotedfield_names(false)

自 2.10 版本后，使用jsonreadfeature#
allow_unquoted_field_names代替

是否允许属性名不带双引号””，比较简单，示例略。

allowsinglequotes(false)

自 2.10 版本后，使用jsonreadfeature#allow_single_quotes代替

是否允许属性名支持单引号，也就是使用”包裹，形如这样：

{
    'age' : 18
}

allowunquotedcontrol_chars(false)

自 2.10 版本后，使用jsonreadfeature#
allow_unescaped_control_chars代替

是否允许 json 字符串包含非引号控制字符（值小于 32 的 ascii 字符，包含制表符和换行符）。 由于 json 规范要求对所有控制字符使用引号，这是一个非标准的特性，因此默认禁用。

那么，哪些字符属于控制字符呢？做个简单科普：我们一般说的 ascii 码共 128 个字符(7bit)，共分为两大类

控制字符

控制字符，也叫不可打印字符。第0～32 号及第 127 号(共 34 个)是控制字符，例如常见的：lf（换行）、cr（回车）、ff（换页）、del（删除）、bs（退格)等都属于此类。

控制字符大部分已经废弃不用了，它们的用途主要是用来操控已经处理过的文字，ascii 值为 8、9、10 和 13 分别转换为退格、制表、换行和回车字符。它们并没有特定的图形显示，但会依不同的应用程序，而对文本显示有不同的影响。

话外音：你看不见我，但我对你影响还蛮大

非控制字符

也叫可显示字符，或者可打印字符，能从键盘直接输入的字符。比如 0-9 数字，逗号、分号这些等等。

话外音：你肉眼能看到的字符就属于非控制字符

allowbackslashescapinganycharacter(false)

自 2.10 版本后，使用jsonreadfeature#
allow_backslash_escaping_any_character代替

是否允许反斜杠转义任何字符。这句话不是非常好理解，看下面这个例子：

@test
public void test4() throws ioexception {
    string jsonstr = "{"name" : "yourb\'atman" }";

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {
        // jsonparser.enable(jsonparser.feature.allow_backslash_escaping_any_character);

        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("name".equals(fieldname)) {
                jsonparser.nexttoken();
                system.out.println(jsonparser.gettext());
            }
        }
    }
}

运行程序，报错：

com.fasterxml.jackson.core.jsonparseexception: unrecognized character escape ''' (code 39)
 at [source: (string)"{"name" : "yourb'atman" }"; line: 1, column: 19]
 ...

放开注释掉的代码，再次运行程序，一切正常，输出：yourb’atman。

allownumericleading_zeros(false)

自 2.10 版本后，使用jsonreadfeature#
allow_leading_zeros_for_numbers代替

是否允许像00001这样的“数字”出现（而不报错）。看例子：

@test
public void test5() throws ioexception {
    string jsonstr = "{"age" : 00018 }";

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {
        // jsonparser.enable(jsonparser.feature.allow_numeric_leading_zeros);

        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("age".equals(fieldname)) {
                jsonparser.nexttoken();
                system.out.println(jsonparser.getintvalue());
            }
        }
    }
}

运行程序，输出：

com.fasterxml.jackson.core.jsonparseexception: invalid numeric value: leading zeroes not allowed
 at [source: (string)"{"age" : 00018 }"; line: 1, column: 11]
 ...

放开注掉的代码，再次运行程序，一切正常。输出18。

allowleadingdecimalpointfor_numbers(false)

自 2.10 版本后，使用jsonreadfeature#
allow_leading_decimal_point_for_numbers代替

是否允许小数点.打头，也就是说.1这种小数格式是否合法。默认是不合法的，需要开启此特征才能支持，例子就略了，基本同上。

allownonnumeric_numbers(false)

自 2.10 版本后，使用jsonreadfeature#allow_non_numeric_numbers代替

是否允许一些解析器识别一组“非数字”(如 nan)作为合法的浮点数值。这个属性和上篇文章的jsongenerator#quote_non_numeric_numbers特征值是遥相呼应的。

@test
public void test5() throws ioexception {
    string jsonstr = "{"percent" : nan }";

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {
        // jsonparser.enable(jsonparser.feature.allow_non_numeric_numbers);

        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("percent".equals(fieldname)) {
                jsonparser.nexttoken();
                system.out.println(jsonparser.getfloatvalue());
            }
        }
    }
}

运行程序，抛错：

com.fasterxml.jackson.core.jsonparseexception: non-standard token 'nan': enable jsonparser.feature.allow_non_numeric_numbers to allow
 at [source: (string)"{"percent" : nan }"; line: 1, column: 17]

放开注释掉的代码，再次运行，一切正常。输出：

nan

小贴士：nan 也可以表示一个 float 对象，是的你没听错，即使它不是数字但它也是 float 类型。具体你可以看看 float 源码里的那几个常量

allowmissingvalues(false)

自 2.10 版本后，使用jsonreadfeature#allow_missing_values代替

是否允许支持json 数组中“缺失”值。怎么理解：数组中缺失了值表示两个逗号之间，啥都没有，形如这样[value1, , value3]。

@test
public void test6() throws ioexception {
    string jsonstr = "{"names" : ["yourbatman",,"a 哥",,] }";

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {
        // jsonparser.enable(jsonparser.feature.allow_missing_values);

        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("names".equals(fieldname)) {
                jsonparser.nexttoken();

                while (jsonparser.nexttoken() != jsontoken.end_array) {
                    system.out.println(jsonparser.gettext());
                }
            }
        }
    }
}

运行程序，抛错：

yourbatman // 能输出一个，毕竟第一个 part（jsontoken）是正常的嘛

com.fasterxml.jackson.core.jsonparseexception: unexpected character (',' (code 44)): expected a valid value (json string, number, array, object or token 'null', 'true' or 'false')
 at [source: (string)"{"names" : ["yourbatman",,"a 哥",,] }"; line: 1, column: 27]

放开注释掉的代码，再次运行，一切正常，结果为：

yourbatman
null
a 哥
null
null

请注意：此时数组的长度是 5 哦。

小贴士：此处用的 string 类型展示结果，是因为 null 可以作为 string 类型（jsonparser.gettext()得到 null 是合法的）。但如果你使用的 int 类型（或者 bool 类型），那么如果是 null 的话就报错喽current token (value_null) not of boolean type，有兴趣的亲可自行尝试，巩固下理解的效果。报错原因文上已有说明~

allowtrailingcomma(false)

自 2.10 版本后，使用jsonreadfeature#allow_trailing_comma代替

是否允许最后一个多余的逗号（一定是最后一个）。这个特征是非常重要的，若开关打开，有如下效果：

• [true,true,]等价于[true, true]
• {“a”: true,}等价于{“a”: true}

当这个特征和上面的allow_missing_values特征同时使用时，本特征优先级更高。也就是说：会先去除掉最后一个逗号后，再进行数组长度的计算。

举个例子：当然这两个特征开关都打开时，[true,true,]等价于[true, true]好理解；并且呢，[true,true,,]是等价于[true, true, null]的哦，可千万别忽略最后的这个 null。

@test
public void test7() throws ioexception {
    string jsonstr = "{"results" : [true,true,,] }";

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {
        jsonparser.enable(jsonparser.feature.allow_missing_values);
        // jsonparser.enable(jsonparser.feature.allow_trailing_comma);

        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("results".equals(fieldname)) {
                jsonparser.nexttoken();

                while (jsonparser.nexttoken() != jsontoken.end_array) {
                    system.out.println(jsonparser.getbooleanvalue());
                }
            }
        }
    }
}

运行程序，输出：

yourbatman
null
a 哥
null
null

这完全就是上例的效果嘛。现在我放开注释掉的代码，再次运行，结果为：

yourbatman
null
a 哥
null

请注意对比前后的结果差异，并自己能能自己合理解释。

校验相关

jackson 在 json 标准之外，给出了两个校验相关的特征。

strictduplicatedetection(false)

自 2.10 版本后，使用streamreadfeature#
strict_duplicate_detection代替

是否允许 json 串有两个相同的属性 key，默认是允许的。

@test
public void test8() throws ioexception {
    string jsonstr = "{"age":18, "age": 28 }";

    jsonfactory factory = new jsonfactory();
    try (jsonparser jsonparser = factory.createparser(jsonstr)) {
        // jsonparser.enable(jsonparser.feature.strict_duplicate_detection);

        while (jsonparser.nexttoken() != jsontoken.end_object) {
            string fieldname = jsonparser.getcurrentname();
            if ("age".equals(fieldname)) {
                jsonparser.nexttoken();
                system.out.println(jsonparser.getintvalue());
            }
        }
    }
}

运行程序，正常输出：

18
28

若放开注释代码，再次运行，则抛错：

18 // 第一个数字还是能正常输出的哟

com.fasterxml.jackson.core.jsonparseexception: duplicate field 'age'
 at [source: (string)"{"age":18, "age": 28 }"; line: 1, column: 17]

ignore_undefined(false)

自 2.10 版本后，使用streamreadfeature#ignore_undefined代替

是否忽略没有定义的属性 key。和jsongenerator.feature#ignore_unknown的这个特征一样，它作用于预先定义了格式的数据类型，如avro、protobuf等等，json 是不需要预先定义的哦~

同样的，你可以通过这个 api 预先设置格式：

jsonparser:

    public void setschema(formatschema schema) {
        ...
    }

其它

includesourcein_location(true)

自 2.10 版本后，使用streamreadfeature#
include_source_in_location代替

是否构建jsonlocation对象来表示每个 part 的来源，你可以通过jsonparser#getcurrentlocation()来访问。作用不大，就此略过。

总结

本文介绍了底层流式 api jsonparser 读 json 的方式，它不仅仅能够处理标准 json，也能通过 feature 特征值来控制，开启对一些非标准但又比较常用的 json 串的支持，这不正式一个优秀框架/库应有的态度麽：兼容性。

结合上篇文章对写 json 时jsongenerator的描述，能够总结出两点原则：

• 写：100%遵循规范
• 读：最大程度兼容并包

写代表你的输出，遵循规范的输出能确保第三方在用你输出的数据时不至于对你破口大骂，所以这是你应该做好的本分。读代表你的输入，能够处理规范的格式是你的职责，但我若还能额外的处理一些非标准格式（一般为常用的），那绝对是闪耀点，也就是你给的情分。本分是你应该做的，而情分就是你的加分项