当前位置：首页 > 文章列表 > 文章 > java教程 > Java解析JSON入门教程详解

Java解析JSON入门教程详解

2025-09-01 10:45:15 0浏览收藏

从现在开始，我们要努力学习啦！今天我给大家带来《Java生成解析JSON入门指南》，感兴趣的朋友请继续看下去吧！下文中的内容我们主要会涉及到等等知识点，如果在阅读本文过程中有遇到不清楚的地方，欢迎留言呀！我们一起讨论，一起学习！

在Java中处理JSON数据的核心是使用第三方库如Jackson或Gson进行序列化和反序列化，首先需定义与JSON结构对应的Java POJO；2. 使用Jackson时需在Maven中引入jackson-databind依赖，通过ObjectMapper类的writeValueAsString()方法将Java对象转换为JSON字符串（序列化）；3. 通过ObjectMapper的readValue()方法将JSON字符串转换为Java对象（反序列化），支持字段缺失时自动设为null；4. Jackson支持通过@JsonFormat注解或ObjectMapper配置自定义日期格式，避免默认的时间戳输出；5. 使用@JsonInclude(JsonInclude.Include.NON_NULL)可忽略值为null的字段，减小JSON体积；6. 对于特殊类型如自定义Money类，可通过实现JsonSerializer和JsonDeserializer并配合@JsonSerialize和@JsonDeserialize注解实现自定义序列化逻辑；7. 处理嵌套JSON对象时，Java POJO中应包含对应类型的对象字段，Jackson会自动递归映射；8. JSON数组可映射为Java中的List或数组类型，字符串数组对应List，对象数组对应List，Jackson能自动完成集合的序列化与反序列化。

java怎样生成和解析JSON格式数据 javaJSON处理的入门编程指南

在Java中处理JSON数据，无论是将其转换为JSON字符串（序列化）还是从JSON字符串中提取数据（反序列化），核心都是依赖于强大的第三方库。这通常涉及将Java对象与JSON结构进行映射，然后通过库的方法实现转换。最常用的库包括Jackson和Gson，它们提供了简洁而高效的API来完成这些任务。

解决方案

要生成和解析JSON数据，我们通常会定义一个Java对象（POJO），其字段与JSON的键值对相对应。以Jackson库为例，以下是基本操作：

首先，确保你的项目中引入了Jackson的依赖。如果你使用Maven，可以在pom.xml中添加：

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.17.0</version> <!-- 使用最新稳定版本 -->
</dependency>

1. 定义一个Java对象（POJO）：

// User.java
public class User {
    private String name;
    private int age;
    private String email; // 假设有时可能为空

    // 默认构造函数是必须的，Jackson会用它来实例化对象
    public User() {
    }

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

    // 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;
    }

    @Override
    public String toString() {
        return "User{" +
               "name='" + name + '\'' +
               ", age=" + age +
               ", email='" + email + '\'' +
               '}';
    }
}

2. 生成JSON（序列化）：

将Java对象转换为JSON字符串。

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonGeneratorExample {
    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();
        User user = new User("张三", 30, "zhangsan@example.com");

        try {
            // 将Java对象序列化为JSON字符串
            String jsonString = objectMapper.writeValueAsString(user);
            System.out.println("生成的JSON字符串:\n" + jsonString);

            // 也可以格式化输出，使其更易读
            String prettyJsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);
            System.out.println("\n格式化后的JSON字符串:\n" + prettyJsonString);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出可能类似： {"name":"张三","age":30,"email":"zhangsan@example.com"}

3. 解析JSON（反序列化）：

将JSON字符串转换回Java对象。

import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonParserExample {
    public static void main(String[] args) {
        ObjectMapper objectMapper = new ObjectMapper();
        String jsonString = "{\"name\":\"李四\",\"age\":25,\"email\":\"lisi@example.com\"}";

        try {
            // 将JSON字符串反序列化为Java对象
            User user = objectMapper.readValue(jsonString, User.class);
            System.out.println("解析后的Java对象:\n" + user);

            // 尝试解析一个email字段缺失的JSON
            String jsonWithoutEmail = "{\"name\":\"王五\",\"age\":40}";
            User user2 = objectMapper.readValue(jsonWithoutEmail, User.class);
            System.out.println("解析email缺失的Java对象:\n" + user2); // email会是null

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出可能类似： 解析后的Java对象: User{name='李四', age=25, email='lisi@example.com'}解析email缺失的Java对象: User{name='王五', age=40, email='null'}

选择合适的Java JSON处理库：Jackson与Gson的考量

在Java生态中，处理JSON数据几乎离不开两个主流库：Jackson和Gson。作为开发者，选择哪个，有时确实是个让人纠结的问题。我的经验是，它们各有千秋，但Jackson在大多数企业级应用中表现更全面、更灵活。

Jackson Jackson是目前Java领域最流行的JSON处理库，功能非常强大。它不仅仅能做基本的序列化和反序列化，还提供了丰富的注解（如@JsonProperty, @JsonIgnore, @JsonFormat等）来精细控制JSON的映射关系。当你的JSON结构复杂、需要处理日期格式、空值、继承关系，或者需要自定义序列化/反序列化逻辑时，Jackson的灵活性和可配置性会让你感到非常顺手。它的性能也相当不错，在大数据量处理时通常表现优异。它的API虽然初看可能比Gson略显复杂，但一旦掌握，你会发现其强大的表现力。

Gson Gson是Google开源的JSON库，以其API的简洁性著称。对于简单的JSON操作，或者当你的项目追求快速开发、对JSON映射的精细控制要求不高时，Gson是一个非常好的选择。它的学习曲线非常平缓，几行代码就能搞定基本的转换。然而，在处理一些复杂场景，比如多态、循环引用、或者需要高度定制化序列化逻辑时，Gson的灵活性相对Jackson来说会弱一些，可能需要更多的手动实现JsonSerializer和JsonDeserializer接口。

我的看法： 如果你正在启动一个新项目，并且预计未来会与各种复杂的API接口打交道，或者需要处理大量异构数据，我个人会倾向于推荐Jackson。它的生态系统更成熟，社区支持也更广泛，遇到问题更容易找到解决方案。当然，如果你的项目体量较小，或者只是做一些简单的JSON转换，Gson的简洁性无疑会让你感到愉悦。选择哪个，很多时候也取决于团队的偏好和项目的具体需求，没有绝对的对错，只有更适合。

Java JSON序列化进阶：日期、空值与自定义处理

在实际开发中，JSON数据的序列化和反序列化远不止基本类型那么简单。日期格式、空值处理以及一些特殊类型的映射，常常会成为让人头疼的细节。Jackson提供了强大的配置能力来应对这些挑战。

1. 日期格式化： JSON本身没有日期类型，日期通常以字符串形式表示。常见的格式有ISO 8601 ("yyyy-MM-dd'T'HH:mm:ss.SSSZ")、Unix时间戳（毫秒或秒）或自定义字符串。 Jackson默认会将java.util.Date或java.time.LocalDateTime等类型序列化为Unix时间戳（毫秒），或者ISO 8601格式（如果配置了）。

你可以通过@JsonFormat注解来指定日期的输出格式：

import com.fasterxml.jackson.annotation.JsonFormat;
import java.util.Date;

public class Event {
    private String name;
    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss")
    private Date eventTime;

    // 构造函数、Getter/Setter...
    public Event() {}
    public Event(String name, Date eventTime) {
        this.name = name;
        this.eventTime = eventTime;
    }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Date getEventTime() { return eventTime; }
    public void setEventTime(Date eventTime) { this.eventTime = eventTime; }
}

// 序列化示例
// ObjectMapper mapper = new ObjectMapper();
// Event event = new Event("生日派对", new Date());
// String json = mapper.writeValueAsString(event); // eventTime将按"yyyy-MM-dd HH:mm:ss"格式输出

或者通过ObjectMapper进行全局配置：

ObjectMapper mapper = new ObjectMapper();
// 配置日期格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 或者使用更现代的Java 8日期API
// mapper.registerModule(new JavaTimeModule()); // 注册Java 8日期模块
// mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS); // 不写成时间戳

2. 空值处理： 默认情况下，Jackson在序列化时会包含值为null的字段。但在很多场景下，我们希望忽略这些null字段，以减小JSON的体积或避免不必要的传输。

你可以使用@JsonInclude注解在字段或类级别控制空值的包含策略：

import com.fasterxml.jackson.annotation.JsonInclude;

@JsonInclude(JsonInclude.Include.NON_NULL) // 类级别：所有null字段不参与序列化
public class Product {
    private String productId;
    private String productName;
    private String description; // 可能会是null

    // 构造函数、Getter/Setter...
    public Product() {}
    public Product(String productId, String productName, String description) {
        this.productId = productId;
        this.productName = productName;
        this.description = description;
    }
    public String getProductId() { return productId; }
    public void setProductId(String productId) { this.productId = productId; }
    public String getProductName() { return productName; }
    public void setProductName(String productName) { this.productName = productName; }
    public String getDescription() { return description; }
    public void setDescription(String description) { this.description = description; }
}

// 序列化示例
// ObjectMapper mapper = new ObjectMapper();
// Product p1 = new Product("P001", "电脑", "高性能笔记本");
// Product p2 = new Product("P002", "鼠标", null);
// String json1 = mapper.writeValueAsString(p1); // {"productId":"P001","productName":"电脑","description":"高性能笔记本"}
// String json2 = mapper.writeValueAsString(p2); // {"productId":"P002","productName":"鼠标"} (description字段被忽略)

3. 自定义序列化与反序列化： 当默认的映射规则无法满足需求时，你可以实现自定义的序列化器和反序列化器。这在处理一些非标准数据类型、或者需要对数据进行特定转换时非常有用。

例如，如果你有一个自定义的Money类，你可能希望它在JSON中表示为一个简单的数值（例如，100.50而不是{"amount":100.50,"currency":"USD"}）。

import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;

import java.io.IOException;
import java.math.BigDecimal;

// 自定义Money类
class Money {
    private BigDecimal amount;
    private String currency;

    public Money(BigDecimal amount, String currency) {
        this.amount = amount;
        this.currency = currency;
    }
    public BigDecimal getAmount() { return amount; }
    public String getCurrency() { return currency; }
}

// 自定义Money的序列化器
class MoneySerializer extends JsonSerializer<Money> {
    @Override
    public void serialize(Money value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        // 只输出金额部分
        gen.writeNumber(value.getAmount());
    }
}

// 自定义Money的反序列化器
class MoneyDeserializer extends JsonDeserializer<Money> {
    @Override
    public Money deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
        // 从数字反序列化为Money对象，假设货币是固定的USD
        BigDecimal amount = p.getDecimalValue();
        return new Money(amount, "USD");
    }
}

// 在POJO中使用自定义序列化/反序列化器
public class Order {
    private String orderId;
    @JsonSerialize(using = MoneySerializer.class)
    @JsonDeserialize(using = MoneyDeserializer.class)
    private Money totalAmount;

    // 构造函数、Getter/Setter...
    public Order() {}
    public Order(String orderId, Money totalAmount) {
        this.orderId = orderId;
        this.totalAmount = totalAmount;
    }
    public String getOrderId() { return orderId; }
    public void setOrderId(String orderId) { this.orderId = orderId; }
    public Money getTotalAmount() { return totalAmount; }
    public void setTotalAmount(Money totalAmount) { this.totalAmount = totalAmount; }
}

// 示例
// ObjectMapper mapper = new ObjectMapper();
// Order order = new Order("ORD001", new Money(new BigDecimal("99.99"), "EUR"));
// String json = mapper.writeValueAsString(order); // {"orderId":"ORD001","totalAmount":99.99}
// Order parsedOrder = mapper.readValue("{\"orderId\":\"ORD002\",\"totalAmount\":123.45}", Order.class);
// System.out.println(parsedOrder.getTotalAmount().getCurrency()); // 输出 USD

这种自定义机制为处理复杂或非标准的数据类型提供了极大的灵活性。

深入解析Java JSON数据：处理嵌套与数组结构

真实世界的JSON数据往往不是扁平的，它们经常包含嵌套的对象和数组。Jackson库能够非常优雅地处理这些复杂的结构，通常你只需要正确地定义你的Java POJO即可。

1. 处理嵌套对象： 如果JSON中包含一个嵌套的JSON对象，你只需要在你的Java POJO中定义一个对应类型的字段即可。Jackson会自动识别并进行递归映射。

假设我们有这样的JSON：

{
  "orderId": "ORD123",
  "customer": {
    "id": "CUST001",
    "name": "张三",
    "contact": {
      "email": "zhangsan@example.com",
      "phone": "13800138000"
    }
  },
  "totalAmount": 150.75
}

你需要定义三个POJO来匹配这个结构：

public class Order {
    private String orderId;
    private Customer customer; // 嵌套对象
    private double totalAmount;

    // 构造函数、Getter/Setter
    public Order() {}
    public Order(String orderId, Customer customer, double totalAmount) {
        this.orderId = orderId;
        this.customer = customer;
        this.totalAmount = totalAmount;
    }
    public String getOrderId() { return orderId; }
    public void setOrderId(String orderId) { this.orderId = orderId; }
    public Customer getCustomer() { return customer; }
    public void setCustomer(Customer customer) { this.customer = customer; }
    public double getTotalAmount() { return totalAmount; }
    public void setTotalAmount(double totalAmount) { this.totalAmount = totalAmount; }
}

public class Customer {
    private String id;
    private String name;
    private Contact contact; // 再次嵌套

    // 构造函数、Getter/Setter
    public Customer() {}
    public Customer(String id, String name, Contact contact) {
        this.id = id;
        this.name = name;
        this.contact = contact;
    }
    public String getId() { return id; }
    public void setId(String id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public Contact getContact() { return contact; }
    public void setContact(Contact contact) { this.contact = contact; }
}

public class Contact {
    private String email;
    private String phone;

    // 构造函数、Getter/Setter
    public Contact() {}
    public Contact(String email, String phone) {
        this.email = email;
        this.phone = phone;
    }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    public String getPhone() { return phone; }
    public void setPhone(String phone) { this.phone = phone; }
}

// 反序列化示例
// ObjectMapper mapper = new ObjectMapper();
// String json = "{\"orderId\":\"ORD123\",\"customer\":{\"id\":\"CUST001\",\"name\":\"张三\",\"contact\":{\"email\":\"zhangsan@example.com\",\"phone\":\"13800138000\"}},\"totalAmount\":150.75}";
// Order order = mapper.readValue(json, Order.class);
// System.out.println(order.getCustomer().getContact().getEmail()); // 输出 zhangsan@example.com

2. 处理JSON数组： JSON数组在Java中通常映射为List、Set或数组类型。

假设我们有这样的JSON：

{
  "productId": "PROD001",
  "productName": "智能手机",
  "tags": ["电子产品", "通讯", "数码"],
  "variants": [
    {
      "color": "黑色",
      "price": 999.00
    },
    {
      "color": "白色",
      "price": 1029.00
    }
  ]
}

对应的POJO结构：

import java.util.List;

public class ProductDetail {
    private String productId;
    private String productName;
    private List<String> tags; // 字符串数组
    private List<ProductVariant> variants; // 对象数组

    // 构造函数、Getter/Setter
    public ProductDetail() {}
    public ProductDetail(String productId, String productName, List<String> tags, List<ProductVariant> variants) {
        this.productId = productId;
        this.productName = productName;
        this.tags = tags;
        this.variants = variants;
    }
    public String getProductId() { return productId; }
    public void setProductId(String productId) { this.productId = productId; }
    public String getProductName() { return productName; }
    public void setProductName(String productName) { this.productName = productName; }
    public List<String> getTags() { return tags; }
    public void setTags(List<String> tags) { this.tags = tags; }
    public List<ProductVariant> getVariants() { return variants; }
    public void setVariants(List<ProductVariant> variants) { this.variants = variants; }
}

public class ProductVariant {
    private String color;
    private double price;

    // 构造函数、Getter/Setter
    public ProductVariant() {}
    public ProductVariant(String color, double price) {
        this.color = color;
        this.price = price;
    }
    public String getColor() { return color; }
    public void setColor(String color) { this.color = color; }
    public double getPrice() { return price; }
    public void setPrice(double price) { this.price = price; }
}

// 反序列化示例
// ObjectMapper mapper = new ObjectMapper();
// String json = "{\"productId\":\"PROD001\",\"productName\":\"智能手机\",\"tags\":[\"电子产品\",\"通讯\",\"数码\"],\"variants\":[{\"color\":\"黑色\",\"price\":999.00},{\"color\":\"白色\",\"price\":1029.00}]}";
// ProductDetail product = mapper.readValue(json, ProductDetail.class);
// System.out.println(product.getTags().get(0)); // 输出 电子产品
// System.out.println(product.getVariants().get(1).getColor()); // 输出 白色

**3. 处理未知或动态结构

到这里，我们也就讲完了《Java解析JSON入门教程详解》的内容了。个人认为，基础知识的学习和巩固，是为了更好的将其运用到项目中，欢迎关注golang学习网公众号，带你了解更多关于反序列化,序列化,jackson,POJO,JavaJSON的知识点！

反序列化序列化 jackson POJO JavaJSON