【Jackson】在Java项目中使用Jackson解析JSON字符串

🕗 发布于 2024-07-26 12:10 java json

在Java中，Jackson库是一个非常流行和强大的JSON处理库。它提供了简洁易用的API，可以用于将Java对象序列化为JSON字符串，以及将JSON字符串反序列化为Java对象。在下面的案例中，我们将详细演示如何使用Jackson包解析JSON字符串。

如何使用Jackson包解析JSON字符串

为了展示如何使用Jackson来解析JSON，我们将进行以下步骤：

引入Jackson库。
定义一个简单的Java类。
将JSON字符串解析为Java对象。
从JSON字符串解析复杂的嵌套结构。
处理JSON数组。
从Java对象生成JSON字符串。

1. 引入Jackson库

在Java项目中使用Jackson库，你需要将相关的依赖添加到项目中。如果你使用Maven项目，可以在pom.xml中添加以下依赖：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.15.2</version>
</dependency>

如果使用Gradle，则需要在build.gradle中添加：

implementation 'com.fasterxml.jackson.core:jackson-databind:2.15.2'

2. 定义一个简单的Java类

在这一步，我们将定义一个简单的Java类来表示我们希望解析的JSON结构。假设我们有一个表示用户信息的JSON：

{
  "name": "John Doe",
  "age": 30,
  "email": "john.doe@example.com"
}

为此，我们可以创建一个名为User的Java类：

// User.java
public class User {
    private String name;
    private int age;
    private String email;

    // 构造方法
    public User() {}

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    // 重写toString方法，便于打印对象信息
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                '}';
    }
}

3. 将JSON字符串解析为Java对象

接下来，我们将使用Jackson库将上面的JSON字符串解析为User对象。

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) {
        // JSON字符串
        String json = "{\"name\": \"John Doe\", \"age\": 30, \"email\": \"john.doe@example.com\"}";

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 将JSON字符串解析为User对象
            User user = objectMapper.readValue(json, User.class);

            // 打印解析得到的User对象
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

4. 从JSON字符串解析复杂的嵌套结构

假设我们有一个更复杂的JSON结构，其中包含嵌套对象，例如：

{
  "name": "John Doe",
  "age": 30,
  "email": "john.doe@example.com",
  "address": {
    "street": "123 Main St",
    "city": "Springfield",
    "zip": "12345"
  }
}

我们可以为Address类创建一个新的Java类，然后将其包含在User类中。

// Address.java
public class Address {
    private String street;
    private String city;
    private String zip;

    // 构造方法
    public Address() {}

    // Getter和Setter方法
    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getZip() {
        return zip;
    }

    public void setZip(String zip) {
        this.zip = zip;
    }

    // 重写toString方法
    @Override
    public String toString() {
        return "Address{" +
                "street='" + street + '\'' +
                ", city='" + city + '\'' +
                ", zip='" + zip + '\'' +
                '}';
    }
}

// User.java
public class User {
    private String name;
    private int age;
    private String email;
    private Address address; // 新增Address字段

    // 构造方法
    public User() {}

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    // 重写toString方法
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", address=" + address +
                '}';
    }
}

现在，我们可以解析包含嵌套结构的JSON字符串：

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExample {
    public static void main(String[] args) {
        // 包含嵌套结构的JSON字符串
        String json = """
            {
              "name": "John Doe",
              "age": 30,
              "email": "john.doe@example.com",
              "address": {
                "street": "123 Main St",
                "city": "Springfield",
                "zip": "12345"
              }
            }
            """;

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 将JSON字符串解析为User对象
            User user = objectMapper.readValue(json, User.class);

            // 打印解析得到的User对象
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

5. 处理JSON数组

如果我们有一个JSON数组，例如：

[
  {
    "name": "John Doe",
    "age": 30,
    "email": "john.doe@example.com"
  },
  {
    "name": "Jane Smith",
    "age": 25,
    "email": "jane.smith@example.com"
  }
]

我们可以将其解析为User对象的列表：

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

public class JacksonArrayExample {
    public static void main(String[] args) {
        // JSON数组字符串
        String jsonArray = """
            [
              {
                "name": "John Doe",
                "age": 30,
                "email": "john.doe@example.com"
              },
              {
                "name": "Jane Smith",
                "age": 25,
                "email": "jane.smith@example.com"
              }
            ]
            """;

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 将JSON数组字符串解析为List<User>
            List<User> users = objectMapper.readValue(jsonArray, new TypeReference<List<User>>() {});

            // 打印解析得到的User列表
            users.forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

6. 从Java对象生成JSON字符串

Jackson不仅可以将JSON字符串解析为Java对象，还可以将Java对象序列化为JSON字符串。以下是一个简单的例子：

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonSerializationExample {
    public static void main(String[] args) {
        // 创建User对象
        User user = new User();
        user.setName("John Doe");
        user.setAge(30);
        user.setEmail("john.doe@example.com");

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 将User对象序列化为JSON字符串
            String jsonString = objectMapper.writeValueAsString(user);

            // 打印JSON字符串
            System.out.println(jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

完整示例代码

以下是完整示例代码的汇总，包括了所有步骤：

// Address.java
public class Address {
    private String street;
    private String city;
    private String zip;

    // 构造方法
    public Address() {}

    // Getter和Setter方法
    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getZip() {
        return zip;
    }

    public void setZip(String zip) {
        this.zip = zip;
    }

    // 重写toString方法
    @Override
    public String toString() {
        return "Address{" +
                "street='" + street + '\'' +
                ", city='" + city + '\'' +
                ", zip='" + zip + '\'' +
                '}';
    }
}

// User.java
public class User {
    private String name;
    private int age;
    private String email;
    private Address address; // 新增Address字段

    // 构造方法
    public User() {}

    // Getter和Setter方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public Address getAddress() {
        return address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    // 重写toString方法
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", email='" + email + '\'' +
                ", address=" + address +
                '}';
    }
}

// JacksonExample.java
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;

public class JacksonExample {
    public static void main(String[] args) {
        // 解析简单JSON字符串为User对象
        parseSimpleJson();

        // 解析嵌套JSON字符串为User对象
        parseNestedJson();

        // 解析JSON数组为List<User>
        parseJsonArray();

        // 将User对象序列化为JSON字符串
        serializeObjectToJson();
    }

    public static void parseSimpleJson() {
        // JSON字符串
        String json = "{\"name\": \"John Doe\", \"age\": 30, \"email\": \"john.doe@example.com\"}";

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 将JSON字符串解析为User对象
            User user = objectMapper.readValue(json, User.class);

            // 打印解析得到的User对象
            System.out.println("Simple JSON:");
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void parseNestedJson() {
        // 包含嵌套结构的JSON字符串
        String json = """
            {
              "name": "John Doe",
              "age": 30,
              "email": "john.doe@example.com",
              "address": {
                "street": "123 Main St",
                "city": "Springfield",
                "zip": "12345"
              }
            }
            """;

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 将JSON字符串解析为User对象
            User user = objectMapper.readValue(json, User.class);

            // 打印解析得到的User对象
            System.out.println("Nested JSON:");
            System.out.println(user);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void parseJsonArray() {
        // JSON数组字符串
        String jsonArray = """
            [
              {
                "name": "John Doe",
                "age": 30,
                "email": "john.doe@example.com"
              },
              {
                "name": "Jane Smith",
                "age": 25,
                "email": "jane.smith@example.com"
              }
            ]
            """;

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 将JSON数组字符串解析为List<User>
            List<User> users = objectMapper.readValue(jsonArray, new TypeReference<List<User>>() {});

            // 打印解析得到的User列表
            System.out.println("JSON Array:");
            users.forEach(System.out::println);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void serializeObjectToJson() {
        // 创建User对象
        User user = new User();
        user.setName("John Doe");
        user.setAge(30);
        user.setEmail("john.doe@example.com");

        // 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();

        try {
            // 将User对象序列化为JSON字符串
            String jsonString = objectMapper.writeValueAsString(user);

            // 打印JSON字符串
            System.out.println("Serialized JSON:");
            System.out.println(jsonString);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

运行结果

在控制台运行上述代码后，你将看到如下输出：

Simple JSON:
User{name='John Doe', age=30, email='john.doe@example.com', address=null}

Nested JSON:
User{name='John Doe', age=30, email='john.doe@example.com', address=Address{street='123 Main St', city='Springfield', zip='12345'}}

JSON Array:
User{name='John Doe', age=30, email='john.doe@example.com', address=null}
User{name='Jane Smith', age=25, email='jane.smith@example.com', address=null}

Serialized JSON:
{"name":"John Doe","age":30,"email":"john.doe@example.com","address":null}

小结

通过本案例，我们学习了如何使用Jackson库来解析和生成JSON字符串：

将JSON字符串解析为Java对象。
解析包含嵌套结构的JSON。
解析JSON数组为Java对象列表。
将Java对象序列化为JSON字符串。

Jackson库还提供了许多其他功能，如自定义序列化和反序列化、支持JSON流处理等，可以满足各种复杂的JSON处理需求。

原文地址：https://blog.csdn.net/u013675821/article/details/140686755

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：PHP基础语法-Part2
下一篇：C++ set

excel如何快速选中某个数字或者某串数字
鼠标光标放在某个数字或者某串数字的末尾，进行双击鼠标左键即可（就会选中当前鼠标光标前相邻的所有数字）：
阅读更多2024-09-17
面试官问：请描述一次你成功解决问题的经历？
面试官为什么要这么问？面试官问你描述一次成功解决问题的经历，主要是为了评估你的几个关键方面：问题解决能力：了解你在面对挑战时的思维方式和应对策略。决策能力：考察你在压力下做出明智决定的能力。沟通技巧：
阅读更多2024-09-17
VLMEvalKit 评测实践:InternVL2 VS Qwen2VL
多模态技术的突破，正在改变我们理解和交互世界的方式。无论是强大的感知能力、复杂的推理分析，还是图文融合的创新应用，InternVL2 与 Qwen2-VL 展现了大模型的无限可能。
阅读更多2024-09-17
mybatis开启日志
步骤很详细，直接上教程……
阅读更多2024-09-17
MySQL——数据库的高级操作（一）数据备份与还原（1）数据的备份
MySQL——数据库的高级操作（一）数据备份与还原（1）数据的备份
阅读更多2024-09-17
Blender渲染太慢怎么办？blender云渲染已开启
此次，渲染101云渲染农场正式加入了对Blender的全面支持，涵盖Blender的所有版本，不论是较新的Blender 4.0还是早期版本，都可轻松对接渲染101平台服务。不论是小型独立项目还是大型
阅读更多2024-09-17
ubuntu安装mysql 8.0忘记root初始密码，如何重新修改密码
修改my.cnf文件，在文件新增 skip-grant-tables，在启动mysql时不启动grant-tables，授权表。5.注释掉skip-grant-tables后重启mysql。2、修改m
阅读更多2024-09-17
JVM面试真题总结（十一）
总的来说，Java内存模型主要解决了多线程环境下共享数据的一致性、可见性等问题，是Java并发编程的基础。这种模型的好处是，由于启动类加载器是最顶部的加载器，因此它加载的都是最可信任的类库（Java的
阅读更多2024-09-17
Ubuntu 软件仓库镜像使用帮助
选择镜像。
阅读更多2024-09-17
用于稀疏自适应深度细化的掩码空间传播网络 CVPR2024
图像引导的深度补全是一项通过利用稀疏深度测量和RGB图像来估计密集深度图的任务；它通过估算深度来填充未测量的区域。由于许多深度传感器（如LiDAR和飞行时间相机（ToF））只能提供稀疏的深度图，这项任
阅读更多2024-09-17