java怎么组成json

Java中如何组成JSON：从基础到实践的全面指南

在Java开发中，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，因其易于人阅读和编写、易于机器解析和生成，已成为前后端数据交互、API接口响应、配置文件存储等场景的标配，Java中如何将数据组合成JSON格式呢？本文将从基础概念出发，介绍主流的JSON处理库，并通过代码示例演示Java组成JSON的多种方式,最后总结不同方法的适用场景。

JSON与Java：数据结构的天然映射

在具体实现前，需要明确JSON与Java数据结构的对应关系，这是理解“如何组成JSON”的基础：

理解这种对应关系后，Java组成JSON的核心就是：将Java对象（如Map、List、实体类等）按照JSON格式规范转换为字符串。

主流JSON处理库：选择你的“武器”

Java生态中，处理JSON的库众多，各有特点,目前主流的有以下几种：

1. Jackson：高性能、功能全，Spring Framework默认JSON库，支持注解定制、流式处理等，适合复杂场景。
2. Gson：Google开发，API简洁，对Java对象与JSON的互转支持友好，适合中小型项目。
3. Fastjson：阿里巴巴开源，解析速度快，但早期版本存在安全漏洞（新版本已修复），国内企业使用较多。
4. org.json：轻量级API简单，但功能相对基础，适合简单JSON操作。

本文以Jackson（最推荐）和Gson（最易上手）为重点，兼顾org.json的轻量级方案。

使用Jackson组成JSON

Jackson是Java生态中最成熟的JSON库之一，其核心模块jackson-databind提供了强大的数据绑定能力,以下是组成JSON的几种常见方式：

准备依赖

在Maven项目的pom.xml中添加Jackson依赖（以jackson-databind为核心）：

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

通过ObjectMapper直接转换Java对象

ObjectMapper是Jackson的核心类，支持将Java对象（如Map、List、实体类）直接序列化为JSON字符串。

示例1：将Map转换为JSON

Map天然符合JSON对象的“键值对”结构,是组成JSON的常用方式。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.HashMap;
import java.util.Map;
public class JacksonMapToJson {
    public static void main(String[] args) {
        // 1. 创建Map，模拟Java对象数据
        Map<String, Object> data = new HashMap<>();
        data.put("name", "张三");
        data.put("age", 25);
        data.put("isStudent", false);
        // 嵌套Map（模拟JSON对象中的嵌套对象）
        Map<String, String> address = new HashMap<>();
        address.put("city", "北京");
        address.put("district", "朝阳区");
        data.put("address", address);
        // 2. 创建ObjectMapper实例
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            // 3. 将Map转换为JSON字符串（默认格式化，缩进2空格）
            String jsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(data);
            System.out.println("JSON字符串：");
            System.out.println(jsonString);
        } catch (JsonProcessingException e) {
            System.err.println("JSON转换失败：" + e.getMessage());
        }
    }
}

输出结果：

{
  "name" : "张三",
  "age" : 25,
  "isStudent" : false,
  "address" : {
    "city" : "北京",
    "district" : "朝阳区"
  }
}

示例2：将Java实体类转换为JSON

通过定义Java实体类（POJO）,可以更结构化地表示JSON数据。

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.List;
// 实体类：用户
class User {
    private String name;
    private int age;
    private boolean isStudent;
    private Address address; // 嵌套实体类
    // 构造方法、getter/setter（省略，实际开发中需要）
    public User(String name, int age, boolean isStudent, Address address) {
        this.name = name;
        this.age = age;
        this.isStudent = isStudent;
        this.address = address;
    }
    public String getName() { return name; }
    public int getAge() { return age; }
    public boolean isStudent() { return isStudent; }
    public Address getAddress() { return address; }
}
// 实体类：地址
class Address {
    private String city;
    private String district;
    public Address(String city, String district) {
        this.city = city;
        this.district = district;
    }
    public String getCity() { return city; }
    public String getDistrict() { return district; }
}
public class JacksonBeanToJson {
    public static void main(String[] args) {
        // 1. 创建嵌套实体类对象
        Address address = new Address("上海", "浦东新区");
        User user = new User("李四", 30, false, address);
        // 2. 使用ObjectMapper转换
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            String jsonString = objectMapper.writeValueAsString(user);
            System.out.println("JSON字符串：");
            System.out.println(jsonString);
        } catch (JsonProcessingException e) {
            System.err.println("JSON转换失败：" + e.getMessage());
        }
    }
}

输出结果（紧凑格式，无缩进）：

{"name":"李四","age":30,"isStudent":false,"address":{"city":"上海","district":"浦东新区"}}

示例3：处理复杂结构（List嵌套对象）

JSON数组对应Java的List，以下演示List<User>转换为JSON数组：

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;
import java.util.List;
public class JacksonListToJson {
    public static void main(String[] args) {
        // 1. 创建List<User>，模拟用户列表
        Address address1 = new Address("广州", "天河区");
        Address address2 = new Address("深圳", "南山区");
        List<User> users = Arrays.asList(
            new User("王五", 22, true, address1),
            new User("赵六", 28, false, address2)
        );
        // 2. 使用ObjectMapper转换
        ObjectMapper objectMapper = new ObjectMapper();
        try {
            String jsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(users);
            System.out.println("JSON数组：");
            System.out.println(jsonString);
        } catch (JsonProcessingException e) {
            System.err.println("JSON转换失败：" + e.getMessage());
        }
    }
}

输出结果：

[
  {
    "name" : "王五",
    "age" : 22,
    "isStudent" : true,
    "address" : {
      "city" : "广州",
      "district" : "天河区"
    }
  },
  {
    "name" : "赵六",
    "age" : 28,
    "isStudent" : false,
    "address" : {
      "city" : "深圳",
      "district" : "南山区"
    }
  }
]

使用JsonNode手动构建JSON（灵活控制）

如果需要动态构建JSON（如字段名、值需运行时确定），可以使用Jackson的JsonNode API（树模型）。

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;
import com.fasterxml.jackson.databind.node.ObjectNode;
public class JacksonJsonNodeExample {
    public static void main(String[] args) {
        // 1. 创建ObjectMapper和根节点（ObjectNode，对应JSON对象）
        ObjectMapper objectMapper