fastjson2来了

笔记

转载于：github.com/alibaba/fastjson2/releases

FastJson2介绍

fastjson2是fastjson项目的重要升级，目标是为下一个十年提供一个高性能的JSON库，同一套API支持JSON/JSONB两种协议，JSONPath是一等公民，支持全量解析和部分解析，支持Java服务端、客户端Android、大数据场景。

使用

  1. maven依赖

    1
    2
    3
    4
    5
    <dependency>
        <groupId>com.alibaba.fastjson2</groupId>
        <artifactId>fastjson2</artifactId>
        <version>2.0.1</version>
    </dependency>

    如果原来使用fastjson 1.2.x版本，可以使用兼容包，兼容包不能保证100%兼容，请仔细测试验证。

    1
    2
    3
    4
    5
    6

    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>2.0.1</version>
    </dependency>

  2. 常用类和方法

    如果你之前用的是fastjson1，大多数情况直接更包名就即可。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70

    package com.alibaba.fastjson2;

    class JSON {
        // 将字符串解析成JSONObject
        static JSONObject parseObject(String str);
        
        // 将字符串解析成JSONArray
        static JSONArray parseArray(String str);
        
        // 将字符串解析成Java对象
        static T parseObject(byte[] utf8Bytes, Class<T> objectClass);
        // 将Java对象输出成字符串
        static String toJSONString(Object object);
        
        // 将Java对象输出成UT8编码的byte[]
        static byte[] toJSONBytes(Object object);
    }

    class JSONB {
        // 将jsonb格式的byte[]解析成Java对象
        static T parseObject(byte[] jsonbBytes, Class<T> objectClass);
        
        // 将Java对象输出成jsonb格式的byte[]
        static byte[] toBytes(Object object);
    }

    class JSONObject {
        Object get(String key);
        int getIntValue(String key);
        Integer getInteger(String key);
        long getLongValue(String key);
        Long getLong(String key);
        T getObject(String key, Class<T> objectClass);
        
        // 将JSONObject对象转换为Java对象
        T toJavaObject(Class<T> objectClass);
    }

    class JSONArray {
        Object get(int index);
        int getIntValue(int index);
        Integer getInteger(int index);
        long getLongValue(int index);
        Long getLong(int index);
        T getObject(int index, Class<T> objectClass);

    class JSONPath {
        // 构造JSONPath
        static JSONPath of(String path);
        // 根据path直接解析输入，会部分解析优化，不会全部解析
        Object extract(JSONReader jsonReader);
        
        // 根据path对对象求值
        Object eval(Object rootObject);
    }

    class JSONReader {
        // 构造基于String输入的JSONReader
        static JSONReader of(String str);
        
        // 构造基于ut8编码byte数组输入的JSONReader
        static JSONReader of(byte[] utf8Bytes);
        
        // 构造基于char[]输入的JSONReader
        static JSONReader of(char[] chars);
        
        // 构造基于json格式byte数组输入的JSONReader
        static JSONReader ofJSONB(byte[] jsonbBytes)
    }

读取JSON对象

1
2
3
4
5
6
7
String str = "{\"id\":123}";
JSONObject jsonObject = JSON.parseObject(str);
int id = jsonObject.getIntValue("id");
String str = "[\"id\", 123]";
JSONArray jsonArray = JSON.parseArray(str);
String name = jsonArray.getString(0);
int id = jsonArray.getIntValue(1);

将JavaBean对象生成JSON

  1. 将JavaBean对象生成JSON格式的字符串

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    class Product {
        public int id;
        public String name;
    }

    Product product = new Product();
    product.id = 1001;
    product.name = "DataWorks";

    JSON.toJSONString(product);
    // 生成如下的结果
    {
    "id": 1001,
    "name": "DataWorks"
    }

    JSON.toJSONString(product, JSONWriter.Feature.BeanToArray);
    // 生成如下的结果
    [123, "DataWorks"]

  2. 将JavaBean对象生成UTF8编码的byte[]

    1
    2
    Product product = ...;
    byte[] utf8JSONBytes = JSON.toJSONBytes(product);

  3. 将JavaBean对象生成JSONB格式的byte[]

    1
    2
    3
    4
    Product product = ...;
    byte[] jsonbBytes = JSONB.toBytes(product);

    byte[] jsonbBytes = JSONB.toBytes(product, JSONWriter.Feature.BeanToArray);

读取JavaBean

  1. 将字符串读取成JavaBean

    1
    String str = "{\"id\":123}";``Product product = JSON.parseObject(str, Product.class);

  2. 将UTF8编码的byte[]读取成JavaBean

    1
    byte[] utf8Bytes = "{\"id\":123}".getBytes(StandardCharsets.UTF_8);Product product = JSON.parseObject(utf8Bytes, Product.class);

  3. 将JSONB数据读取成JavaBean

    1
    2
    byte[] jsonbBytes = ...Product product = JSONB.parseObject(jsonbBytes, Product.class);
    Product product = JSONB.parseObject(jsonbBytes, Product.class, JSONReader.Feature.SupportBeanArrayMapping);

使用JSONPath

  1. 使用JSONPath部分读取数据

    1
    2
    3
    String str = ...;
    JSONPath path = JSONPath.of("$.id"); // 缓存起来重复使用能提升性能
    JSONReader parser = JSONReader.of(str);Object result = path.extract(parser);

  2. 使用JSONPath读取部分utf8Bytes的数据

    1
    2
    3
    byte[] utf8Bytes = ...;
    JSONPath path = JSONPath.of("$.id"); // 缓存起来重复使用能提升性能
    JSONReader parser = JSONReader.of(utf8Bytes);Object result = path.extract(parser);

  3. 使用JSONPath读取部分jsonbBytes的数据

    1
    2
    3
    byte[] jsonbBytes = ...;
    JSONPath path = JSONPath.of("$.id"); // 缓存起来重复使用能提升性能
    JSONReader parser = JSONReader.ofJSONB(jsonbBytes); // 注意，这是利用ofJSONB方法Object result = path.extract(parser);