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

Jackson

前言

Jackson 是 Spring Boot 默认集成的 JSON 处理库，它功能强大且使用简单，适用于大多数场景。Spring Boot 自动引入 Jackson 的依赖并提供开箱即用的支持，无需额外配置即可使用。

# 一、引入 Jackson 依赖

在 Spring Boot 项目中，Jackson 是默认集成的，因此一般无需手动添加依赖。如果需要手动添加，可以使用以下 Maven 配置：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
</dependency>
1
2
3
4

# 二、将对象转换为 JSON 字符串

Jackson 提供了强大的 ObjectMapper 类用于将 Java 对象序列化为 JSON 字符串。

代码示例：

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonObjectToJsonExample {
    public static void main(String[] args) {
        try {
            // 创建 ObjectMapper 实例
            ObjectMapper objectMapper = new ObjectMapper();

            // 创建一个对象
            User user = new User("张三", 25);

            // 将对象转换为 JSON 字符串
            String jsonString = objectMapper.writeValueAsString(user);
            System.out.println("对象转 JSON 字符串: " + jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter 和 setter 省略
}
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

输出结果：

{
    "name": "张三",
    "age": 25
}
1
2
3
4

重要参数说明：

  • writeValueAsString(Object value): 将对象序列化为 JSON 字符串。

# 三、将 JSON 字符串转换为对象

Jackson 同样支持将 JSON 字符串反序列化为 Java 对象。

代码示例：

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonJsonToObjectExample {
    public static void main(String[] args) {
        try {
            // 创建 ObjectMapper 实例
            ObjectMapper objectMapper = new ObjectMapper();

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

            // 将 JSON 字符串转换为对象
            User user = objectMapper.readValue(jsonString, User.class);
            System.out.println("JSON 字符串转对象: " + user.getName() + ", " + user.getAge());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

输出结果：

JSON 字符串转对象: 张三, 25
1

重要参数说明：

  • readValue(String content, Class<T> valueType): 将 JSON 字符串反序列化为指定类型的对象。

# 四、JSON 对象与树形结构的处理（使用 JsonNode）

Jackson 提供了 JsonNode 类，可以将 JSON 数据解析为树形结构，便于复杂 JSON 数据的访问与操作。

# 1. 解析 JSON 字符串为 JsonNode

代码示例：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonJsonNodeExample {
    public static void main(String[] args) {
        try {
            // 创建 ObjectMapper 实例
            ObjectMapper objectMapper = new ObjectMapper();

            // JSON 字符串
            String jsonString = "{\"name\":\"赵六\",\"age\":22,\"address\":{\"city\":\"上海\",\"zip\":\"200000\"}}";

            // 将 JSON 字符串解析为 JsonNode
            JsonNode jsonNode = objectMapper.readTree(jsonString);

            // 访问 JSON 字段
            String name = jsonNode.get("name").asText();
            int age = jsonNode.get("age").asInt();
            String city = jsonNode.get("address").get("city").asText();

            System.out.println("姓名: " + name);
            System.out.println("年龄: " + age);
            System.out.println("城市: " + city);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
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

输出结果：

姓名: 赵六
年龄: 22
城市: 上海
1
2
3

重要参数说明：

  • readTree(String content): 将 JSON 字符串解析为 JsonNode。
  • get(String fieldName): 获取指定字段的值。
  • asText(), asInt() 等方法用于将节点转换为具体的类型值。

# 2. 访问复杂 JSON 数据结构

JsonNode 支持对嵌套的 JSON 结构进行访问，可以处理复杂的 JSON 数据。

代码示例：

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonComplexJsonExample {
    public static void main(String[] args) {
        try {
            // 创建 ObjectMapper 实例
            ObjectMapper objectMapper = new ObjectMapper();

            // 复杂的 JSON 字符串
            String jsonString = "{\"name\":\"张三\",\"age\":25,\"address\":{\"city\":\"北京\",\"street\":\"长安街\"},\"hobbies\":[\"篮球\",\"音乐\"]}";

            // 将 JSON 字符串解析为 JsonNode
            JsonNode jsonNode = objectMapper.readTree(jsonString);

            // 获取嵌套的 JSON 数据
            String city = jsonNode.get("address").get("city").asText();
            String street = jsonNode.get("address").get("street").asText();
            String hobby1 = jsonNode.get("hobbies").get(0).asText();

            System.out.println("城市: " + city);
            System.out.println("街道: " + street);
            System.out.println("兴趣爱好: " + hobby1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
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

输出结果：

城市: 北京
街道: 长安街
兴趣爱好: 篮球
1
2
3

# 五、JSON 与 Java 集合的转换

Jackson 提供了简单的方式将 JSON 数据与 Java 集合（如 List, Map）之间进行互转。

# 1. JSON 字符串转 List

代码示例：

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.List;

public class JacksonJsonToListExample {
    public static void main(String[] args) {
        try {
            // 创建 ObjectMapper 实例
            ObjectMapper objectMapper = new ObjectMapper();

            // JSON 字符串
            String jsonString = "[{\"name\":\"张三\",\"age\":25},{\"name\":\"李四\",\"age\":30}]";

            // 将 JSON 字符串转换为 List
            List<User> users = objectMapper.readValue(jsonString, new TypeReference<List<User>>() {});
            users.forEach(user -> System.out.println("姓名: " + user.getName() + ", 年龄: " + user.getAge()));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter 和 setter 省略
}
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

输出结果：

姓名: 张三, 年龄: 25
姓名: 李四, 年龄: 30
1
2

重要参数说明：

  • readValue(String content, TypeReference<T> valueTypeRef): 将 JSON 字符串反序列化为指定类型的对象（如 List, Map 等）。

# 2. JSON 字符串转 Map

代码示例：

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Map;

public class JacksonJsonToMapExample {
    public static void main(String[] args) {
        try {
            // 创建 ObjectMapper 实例
            ObjectMapper objectMapper = new ObjectMapper();

            // JSON 字符串
            String jsonString = "{\"name\":\"张三\",\"age\":25,\"address\":\"北京\"}";

            // 将 JSON 字符串转换为 Map
            Map<String, Object> map = objectMapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
            System.out.println("姓名: " + map.get("name"));
            System.out.println("年龄: " + map.get("age"));
            System.out.println("地址: " + map.get("address"));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
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
地址: 北京
1
2
3

重要参数说明：

  • readValue(String content, TypeReference<T> valueTypeRef): 将 JSON 字符串反序列化为指定类型的 Map。

# 3. 将 Java 对象转换为 JSON 字符串

同样，Jackson 支持将 List, Map 等 Java 集合对象转换为 JSON 字符串。

代码示例：



import com.fasterxml.jackson.databind.ObjectMapper;

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

public class JacksonMapToJsonExample {
    public static void main(String[] args) {
        try {
            // 创建 ObjectMapper 实例
            ObjectMapper objectMapper = new ObjectMapper();

            // 创建一个 Map
            Map<String, Object> map = new HashMap<>();
            map.put("name", "张三");
            map.put("age", 25);
            map.put("address", "北京");

            // 将 Map 转换为 JSON 字符串
            String jsonString = objectMapper.writeValueAsString(map);
            System.out.println("Map 转 JSON 字符串: " + jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
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

输出结果：

{
    "name": "张三",
    "age": 25,
    "address": "北京"
}
1
2
3
4
5

# 六、JSON 字符串格式化

在调试和日志记录时，格式化 JSON 数据有助于更好地阅读和理解数据结构。Jackson 提供了简单的方式来实现格式化输出。

代码示例：

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

public class JacksonJsonFormattingExample {
    public static void main(String[] args) {
        try {
            // 创建 ObjectMapper 实例并开启格式化输出
            ObjectMapper objectMapper = new ObjectMapper();
            objectMapper.enable(SerializationFeature.INDENT_OUTPUT);

            // 创建一个对象
            User user = new User("张三", 25);

            // 将对象转换为格式化的 JSON 字符串
            String jsonString = objectMapper.writeValueAsString(user);
            System.out.println("格式化 JSON 字符串: \n" + jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // getter 和 setter 省略
}
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

输出结果：

{
  "name" : "张三",
  "age" : 25
}
1
2
3
4

重要参数说明：

  • enable(SerializationFeature.INDENT_OUTPUT): 开启 JSON 字符串格式化输出，使其更具可读性。

总结

Jackson 是 Spring Boot 默认集成的 JSON 处理库，提供了丰富的 API 用于各种场景。通过以上示例，您可以轻松实现对象与 JSON 之间的互转，处理复杂的 JSON 数据结构，并进行格式化输出。在实际开发中，Jackson 是处理 JSON 的首选工具，具备良好的性能和易用性。

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

FastJson2→

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