程序员scholar
  • Java开发工具包
  • Java常用开发工具包
scholar
2024-08-20
目录

FastJson2

前言

Fastjson2 是 FASTJSON项目的重要升级版本，致力于提供高性能的 JSON 处理库。相比于 Fastjson 1.x，Fastjson2 具有更高的性能和更好的安全性，完全移除了 autoType 白名单以提高安全性。

# 一、引入 fastjson2 依赖

在 Maven 项目中，您可以使用以下依赖引入 fastjson2：

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

# 二、JSON 对象与 JSON 数组的创建

# 1. JSON 对象的创建

在日常开发中，经常需要将数据封装为 JSON 对象进行传输和存储，例如用户信息、配置信息等。下面展示如何使用 JSONObject 来创建一个 JSON 对象。

代码示例：

import com.alibaba.fastjson2.JSONObject;

public class JsonObjectCreationExample {
    public static void main(String[] args) {
        // 创建一个 JSON 对象
        JSONObject info = new JSONObject();

        // 添加键值对
        // 必须参数说明：key 是字段名称，value 是字段对应的值
        info.put("name", "张三"); // 用户姓名
        info.put("age", 18); // 用户年龄
        info.put("地理", 70); // 地理成绩
        info.put("英语", 60); // 英语成绩

        // 输出 JSON 对象的字符串形式
        System.out.println(info.toJSONString());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果：

{
    "name": "张三",
    "age": 18,
    "地理": 70,
    "英语": 60
}
1
2
3
4
5
6

重要参数说明：

  • put(String key, Object value): 向 JSON 对象中添加键值对。key 是 JSON 字段名称，value 是字段对应的值，都是必须的。
  • toJSONString(): 将 JSONObject 转换为 JSON 字符串格式，便于输出或传输。

# 2. JSON 数组的创建

当需要存储或传输多个数据时，可以将这些数据放入 JSON 数组中。例如在展示多个用户信息时，每个用户是一个 JSON 对象，这些对象可以组合成一个 JSON 数组。

代码示例：

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;

public class JsonArrayCreationExample {
    public static void main(String[] args) {
        // 创建多个 JSON 对象，分别表示不同的用户信息
        JSONObject info1 = new JSONObject();
        info1.put("name", "张三");
        info1.put("age", 18);

        JSONObject info2 = new JSONObject();
        info2.put("name", "李四");
        info2.put("age", 19);

        // 创建 JSON 数组，并将用户 JSON 对象添加到数组中
        JSONArray array = new JSONArray();
        array.add(info1); // 添加第一个用户信息
        array.add(info2); // 添加第二个用户信息

        // 输出 JSON 数组的字符串形式
        System.out.println(array.toJSONString());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

输出结果：

[
    {
        "name": "张三",
        "age": 18
    },
    {
        "name": "李四",
        "age": 19
    }
]
1
2
3
4
5
6
7
8
9
10

重要参数说明：

  • add(Object element): 向 JSON 数组中添加元素。element 可以是基本类型、JSON 对象或其他 JSON 数组。
  • toJSONString(): 将 JSONArray 转换为 JSON 字符串格式，便于输出或传输。

# 三、JSON 对象取值与 JSON 数组遍历取值

在开发中，往往需要从 JSON 对象中提取特定字段的值，或者遍历 JSON 数组以获取各个元素的信息。下面展示如何实现这些操作。

# 1. 从 JSON 对象中取值

代码示例：

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;

public class JsonGetValueExample {
    public static void main(String[] args) {
        // 创建一个包含嵌套数据的 JSON 对象
        JSONArray classes = new JSONArray();
        classes.add("1班");
        classes.add("2班");

        JSONObject schoolInfo = new JSONObject();
        schoolInfo.put("schoolName", "第一中学");
        schoolInfo.put("teacher", "刘梅");

        JSONObject studentInfo = new JSONObject();
        studentInfo.put("name", "张三");
        studentInfo.put("age", 18);
        studentInfo.put("classes", classes); // 嵌套 JSON 数组
        studentInfo.put("schoolInfo", schoolInfo); // 嵌套 JSON 对象

        // 从 JSON 对象中取值
        System.out.println("姓名: " + studentInfo.getString("name")); // 输出: 张三
        System.out.println("年龄: " + studentInfo.getIntValue("age")); // 输出: 18
        System.out.println("班级: " + studentInfo.getJSONArray("classes")); // 输出: ["1班","2班"]
        System.out.println("学校信息: " + studentInfo.getJSONObject("schoolInfo")); // 输出: {"schoolName":"第一中学","teacher":"刘梅"}
    }
}
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

输出结果：

姓名: 张三
年龄: 18
班级: ["1班","2班"]
学校信息: {"schoolName":"第一中学","teacher":"刘梅"}
1
2
3
4

重要参数说明：

  • getString(String key): 获取指定字段的字符串值。
  • getIntValue(String key): 获取指定字段的整型值。
  • getJSONArray(String key): 获取指定字段的 JSON 数组。
  • getJSONObject(String key): 获取指定字段的 JSON 对象。

# 2. 遍历 JSON 数组并取值

代码示例：

import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;

public class JsonArrayTraversalExample {
    public static void main(String[] args) {
        // 创建多个 JSON 对象，表示学生信息
        JSONObject student1 = new JSONObject();
        student1.put("name", "张三");
        student1.put("age", 18);

        JSONObject student2 = new JSONObject();
        student2.put("name", "李四");
        student2.put("age", 19);

        // 将学生信息添加到 JSON 数组中
        JSONArray students = new JSONArray();
        students.add(student1);
        students.add(student2);

        // 遍历 JSON 数组，获取每个学生的信息
        for (int i = 0; i < students.size(); i++) {
            JSONObject student = students.getJSONObject(i);
            System.out.println("学生姓名: " + student.getString("name"));
            System.out.println("学生年龄: " + student.getIntValue("age"));
        }
    }
}
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

输出结果：

学生姓名: 张三
学生年龄: 18
学生姓名: 李四
学生年龄: 19
1
2
3
4

重要参数说明：

  • getJSONObject(int index): 获取 JSON 数组中指定索引处的 JSON 对象。

# 四、JSON 对象与字符串的转换

在数据传输中，通常需要在对象与字符串之间进行转换。Fastjson2 提供了简单的方法来实现这些转换。

# 1. JSON 对象与字符串的互相转换

代码示例：

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;

public class JsonStringConversionExample {
    public static void main(String[] args) {
        // 创建 JSON 对象
        JSONObject info = new JSONObject();
        info.put("name", "张三");
        info.put("age", 18);

        // 将 JSON 对象转换为字符串
        String jsonString = JSON.toJSONString(info);
        System.out.println("JSON 对象转字符串: " + jsonString);

        // 将字符串转换回 JSON 对象
        JSONObject jsonObject = JSON.parseObject(jsonString);
        System.out.println("字符串转 JSON 对象: " + jsonObject);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果：

JSON 对象转字符串: {"name":"张三","age":18}
字符串转 JSON 对象: {"name":"张三","age":18}
1
2

重要参数说明：

  • JSON.toJSONString(Object object): 将对象转换为 JSON 字符串。
  • JSON.parseObject(String text): 将 JSON 字符串转换为 JSON 对象。

# 2. JSON 字符串的字节数组转换

代码示例：

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;

public class JsonByteArrayConversionExample {
    public static void main(String[] args)

 {
        // 创建 JSON 字符串
        String jsonString = "{\"name\":\"张三\",\"age\":18}";

        // 将字符串转换为字节数组
        byte[] bytes = jsonString.getBytes();

        // 将字节数组转换为 JSON 对象
        JSONObject jsonObject = JSON.parseObject(bytes);
        System.out.println("字节数组转 JSON 对象: " + jsonObject);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果：

字节数组转 JSON 对象: {"name":"张三","age":18}
1

重要参数说明：

  • JSON.parseObject(byte[] bytes): 将字节数组转换为 JSON 对象。

# 五、JSON 数组与字符串的转换

在处理数组数据时，通常需要在 JSON 数组与字符串之间进行转换。

代码示例：

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;

public class JsonArrayStringConversionExample {
    public static void main(String[] args) {
        // 创建 JSON 字符串
        String text = "[\"张三\",\"李四\",\"王五\"]";

        // 将字符串转换为 JSON 数组
        JSONArray jsonArray = JSON.parseArray(text);
        System.out.println("JSON 字符串转 JSON 数组: " + jsonArray);

        // 将 JSON 数组转换回字符串
        String jsonString = JSON.toJSONString(jsonArray);
        System.out.println("JSON 数组转 JSON 字符串: " + jsonString);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

输出结果：

JSON 字符串转 JSON 数组: ["张三","李四","王五"]
JSON 数组转 JSON 字符串: ["张三","李四","王五"]
1
2

重要参数说明：

  • JSON.parseArray(String text): 将字符串转换为 JSON 数组。
  • JSON.toJSONString(Object object): 将对象转换为 JSON 字符串。

# 六、JSON 字符串与 Java 对象的转换

在实际开发中，经常需要将 JSON 数据与 Java 对象之间进行互转。

# 1. JSON 字符串转 Java 对象

假设有一个 Student 类：

public class Student {
    private String name;
    private int age;

    // 构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Getter 和 Setter 省略

    @Override
    public String toString() {
        return "Student{name='" + name + "', age=" + age + '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

代码示例：

import com.alibaba.fastjson2.JSON;

public class JsonToJavaObjectExample {
    public static void main(String[] args) {
        // JSON 字符串
        String studentJson = "{\"name\":\"张三\",\"age\":18}";

        // 将 JSON 字符串转换为 Java 对象
        Student student = JSON.parseObject(studentJson, Student.class);
        System.out.println("JSON 字符串转 Java 对象: " + student);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12

输出结果：

JSON 字符串转 Java 对象: Student{name='张三', age=18}
1

重要参数说明：

  • JSON.parseObject(String text, Class<T> clazz): 将 JSON 字符串转换为指定类型的 Java 对象。clazz 是目标类的类型。

# 2. Java 对象与字节数组的转换

代码示例：

import com.alibaba.fastjson2.JSON;

public class JavaObjectByteArrayConversionExample {
    public static void main(String[] args) {
        // 创建 Student 对象
        Student student = new Student("张三", 18);

        // 将 Java 对象转换为字节数组
        byte[] bytes = JSON.toJSONBytes(student);

        // 将字节数组转换回 Java 对象
        Student parsedStudent = JSON.parseObject(bytes, Student.class);
        System.out.println("字节数组转 Java 对象: " + parsedStudent);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

输出结果：

字节数组转 Java 对象: Student{name='张三', age=18}
1

重要参数说明：

  • JSON.toJSONBytes(Object object): 将对象序列化为字节数组。
  • JSON.parseObject(byte[] bytes, Class<T> clazz): 将字节数组反序列化为指定类型的 Java 对象。

# 七、JSON 字符串与 Map 的转换

在开发中，JSON 字符串与 Map 的互转也是常见的需求，例如在处理键值对数据时。

# 1. JSON 字符串转 Map

代码示例：

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONObject;

import java.util.Map;

public class JsonStringToMapExample {
    public static void main(String[] args) {
        // JSON 字符串
        String jsonString = "{ \"gradle\":\"高一\", \"number\":\"2\", \"people\":[{\"name\":\"张三\",\"age\":15}, {\"name\":\"李四\",\"age\":16}] }";

        // 将 JSON 字符串转换为 Map
        Map<String, Object> map = JSONObject.parseObject(jsonString, Map.class);

        // 输出 Map 中的数据
        System.out.println("年级: " + map.get("gradle"));
        System.out.println("人数: " + map.get("number"));
        System.out.println("人员信息: " + map.get("people"));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果：

年级: 高一
人数: 2
人员信息: [{name=张三, age=15}, {name=李四, age=16}]
1
2
3

重要参数说明：

  • JSONObject.parseObject(String text, TypeReference<T> typeReference): 将 JSON 字符串转换为指定类型的对象，如 Map。

# 2. Map 转 JSON 字符串

代码示例：

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONWriter;

import java.util.HashMap;
import java.util.Map;

public class MapToJsonStringExample {
    public static void main(String[] args) {
        // 创建 Map
        Map<String, String> map = new HashMap<>();
        map.put("测试1", null);
        map.put("测试2", "hello");

        // 将 Map 转换为 JSON 字符串，并保留 null 值
        String jsonString = JSON.toJSONString(map, JSONWriter.Feature.WriteMapNullValue);
        System.out.println("Map 转 JSON 字符串: " + jsonString);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

输出结果：

Map 转 JSON 字符串: {"测试1":null,"测试2":"hello"}
1

重要参数说明：

  • JSONWriter.Feature.WriteMapNullValue: 保留 Map 中的 null 值，在序列化时不忽略 null。

# 八、JSON 数组转 List

在开发中，通常需要将 JSON 数组数据映射为 Java 的 List，以便更方便地操作。

代码示例：

import com.alibaba.fastjson2.JSONArray;

import java.util.List;
import java.util.Map;

public class JsonArrayToListExample {
    public static void main(String[] args) {
        // JSON 字符串
        String jsonString = "{ \"gradle\":\"高一\", \"number\":\"2\", \"people\":[{\"name\":\"张三\",\"age\":15}, {\"name\":\"李四\",\"age\":16}] }";

        // 解析 JSON 字符串并获取 JSON 数组
        JSONArray peopleArray = JSONArray.parseObject(jsonString).getJSONArray("people");

        // 将 JSON 数组转换为 List
        List<Map> peopleList = peopleArray.toJavaList(Map.class);

        // 输出 List 中的数据
        for (Map person : peopleList) {
            System.out.println(person);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出结果：

{name=张三, age=15}
{name=李四, age=16}
1
2

重要参数说明：

  • JSONArray.toJavaList(Class<T> clazz): 将 JSON 数组转换为指定类型的 List。

# 九、JSON 字符串格式化

在调试或日志记录时，格式化 JSON 数据有助于更好地阅读和理解数据结构。

代码示例：

import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.JSONWriter;

public class JsonStringFormatExample {
    public static void main(String[] args) {
        // 复杂的 JSON 字符串
        String jsonString = "[{\"id\":\"123\",\"name\":\"张三\",\"address\":{\"city\":\"北京\",\"street\":\"长安街\"}}]";

        // 判断 JSON 字符串是数组还是对象
        jsonString = jsonString.trim();
        String formattedJson;

        if (jsonString.startsWith("[")) {
            // JSON 数组格式化
            JSONArray jsonArray = JSON.parseArray(jsonString);
            formattedJson = JSONArray.toJSONString(jsonArray, JSONWriter.Feature.PrettyFormat);
        } else {
            // JSON 对象格式化
            JSONObject jsonObject = JSON.parseObject(jsonString);
            formattedJson = JSON.toJSONString(jsonObject, JSONWriter.Feature.PrettyFormat);
        }

        // 输出格式化的 JSON 字符串
        System.out.println(formattedJson);
    }
}
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

输出结果：

[
    {
        "id": "123",
        "name": "张三",
        "address": {
            "city": "北京",
            "street": "长安街"
        }
    }
]
1
2
3
4
5
6
7
8
9
10

重要参数说明：

  • JSONWriter.Feature.PrettyFormat: 使输出的 JSON 字符串具有易读的格式，包含换行和缩进。

总结

Fastjson2 提供了丰富且灵活的 JSON 处理 API，适用于各种场景。通过以上示例，您可以轻松地将 JSON 与 Java 对象、字符串、字节数组、Map 等进行转换，并应用在实际开发中。

编辑此页 (opens new window)
上次更新: 2025/01/05, 02:09:04
Jackson
Gson

← Gson→

Theme by Vdoing | Copyright © 2019-2025 程序员scholar