跳到主要内容

Java JSON创建

JSON (JavaScript Object Notation) 是一种轻量级的数据交换格式，在现代Web应用和API中被广泛使用。作为一名Java开发者，掌握如何创建和操作JSON数据是非常重要的技能。本文将详细介绍在Java中创建JSON数据的各种方法和技巧。

JSON 简介​

JSON使用简单的文本格式来表示数据结构，主要有两种形式：

  1. JSON对象：由键值对组成，格式为 {"key": value}
  2. JSON数组：由有序值列表组成，格式为 [value1, value2, ...]

JSON值可以是：

  • 字符串、数字、布尔值
  • null
  • 另一个JSON对象
  • JSON数组

Java 中创建JSON的方法​

在Java中，有多种库可以帮助我们创建和处理JSON数据。下面我们将介绍几种常用的方法。

使用org.json库​

org.json是一个简单易用的JSON处理库，适合初学者入门。

添加依赖​

Maven依赖:

xml
<dependency>
    <groupId>org.json</groupId>
    <artifactId>json</artifactId>
    <version>20230227</version>
</dependency>

创建JSON对象​

java
import org.json.JSONObject;

public class JsonCreationExample {
    public static void main(String[] args) {
        // 创建一个JSONObject对象
        JSONObject person = new JSONObject();
        
        // 添加键值对
        person.put("name", "张三");
        person.put("age", 25);
        person.put("isStudent", true);
        
        // 打印JSON字符串
        System.out.println(person.toString());
    }
}

输出:

{"name":"张三","age":25,"isStudent":true}

创建嵌套JSON对象​

java
import org.json.JSONObject;

public class NestedJsonExample {
    public static void main(String[] args) {
        // 创建主JSON对象
        JSONObject person = new JSONObject();
        
        // 添加基本属性
        person.put("name", "李四");
        person.put("age", 30);
        
        // 创建地址子对象
        JSONObject address = new JSONObject();
        address.put("city", "北京");
        address.put("street", "朝阳区");
        address.put("zipCode", "100000");
        
        // 将地址对象添加到人员对象中
        person.put("address", address);
        
        // 打印JSON字符串
        System.out.println(person.toString(2)); // 使用缩进格式化输出
    }
}

输出:

json
{
  "name": "李四",
  "age": 30,
  "address": {
    "city": "北京",
    "street": "朝阳区",
    "zipCode": "100000"
  }
}

创建JSON数组​

java
import org.json.JSONArray;
import org.json.JSONObject;

public class JsonArrayExample {
    public static void main(String[] args) {
        // 创建JSON数组
        JSONArray peopleArray = new JSONArray();
        
        // 创建第一个人的对象
        JSONObject person1 = new JSONObject();
        person1.put("name", "张三");
        person1.put("age", 25);
        
        // 创建第二个人的对象
        JSONObject person2 = new JSONObject();
        person2.put("name", "李四");
        person2.put("age", 30);
        
        // 将人员对象添加到数组
        peopleArray.put(person1);
        peopleArray.put(person2);
        
        // 打印JSON数组
        System.out.println(peopleArray.toString(2));
    }
}

输出:

json
[
  {
    "name": "张三",
    "age": 25
  },
  {
    "name": "李四",
    "age": 30
  }
]

使用Jackson库​

Jackson是Java中最受欢迎的JSON处理库之一，功能强大且性能优良。

添加依赖​

Maven依赖:

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

使用ObjectMapper创建JSON​

Jackson的强大之处在于可以直接将Java对象转换为JSON，无需手动构建。

java
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.ArrayNode;

public class JacksonExample {
    public static void main(String[] args) {
        try {
            // 创建ObjectMapper对象
            ObjectMapper mapper = new ObjectMapper();
            
            // 创建JSON对象
            ObjectNode person = mapper.createObjectNode();
            person.put("name", "王五");
            person.put("age", 28);
            person.put("isStudent", false);
            
            // 创建地址子对象
            ObjectNode address = mapper.createObjectNode();
            address.put("city", "上海");
            address.put("street", "浦东新区");
            
            // 添加地址对象到人员对象
            person.set("address", address);
            
            // 创建兴趣爱好数组
            ArrayNode hobbies = mapper.createArrayNode();
            hobbies.add("阅读");
            hobbies.add("旅行");
            hobbies.add("编程");
            
            // 添加兴趣爱好数组到人员对象
            person.set("hobbies", hobbies);
            
            // 打印美化后的JSON
            String jsonStr = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(person);
            System.out.println(jsonStr);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出:

json
{
  "name" : "王五",
  "age" : 28,
  "isStudent" : false,
  "address" : {
    "city" : "上海",
    "street" : "浦东新区"
  },
  "hobbies" : [ "阅读", "旅行", "编程" ]
}

将Java对象转换为JSON​

java
import com.fasterxml.jackson.databind.ObjectMapper;
import java.util.Arrays;
import java.util.List;

// 定义一个Person类
class Person {
    private String name;
    private int age;
    private List<String> hobbies;
    
    // 构造函数
    public Person(String name, int age, List<String> hobbies) {
        this.name = name;
        this.age = age;
        this.hobbies = hobbies;
    }
    
    // Getters和Setters (Jackson需要这些方法来访问字段)
    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 List<String> getHobbies() { return hobbies; }
    public void setHobbies(List<String> hobbies) { this.hobbies = hobbies; }
}

public class ObjectToJsonExample {
    public static void main(String[] args) {
        try {
            // 创建一个Person对象
            Person person = new Person("赵六", 35, Arrays.asList("游泳", "爬山", "绘画"));
            
            // 创建ObjectMapper
            ObjectMapper mapper = new ObjectMapper();
            
            // 将对象转换为JSON字符串
            String jsonString = mapper.writeValueAsString(person);
            System.out.println(jsonString);
            
            // 美化输出
            String prettyJson = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(person);
            System.out.println("\n美化输出:");
            System.out.println(prettyJson);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

输出:

{"name":"赵六","age":35,"hobbies":["游泳","爬山","绘画"]}

美化输出:
{
  "name" : "赵六",
  "age" : 35,
  "hobbies" : [ "游泳", "爬山", "绘画" ]
}

使用Gson库​

Google的Gson库也是一个流行的选择，特别是在Android开发中。

添加依赖​

Maven依赖:

xml
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.10.1</version>
</dependency>

使用Gson创建JSON​

java
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.JsonArray;

public class GsonExample {
    public static void main(String[] args) {
        // 创建JsonObject
        JsonObject student = new JsonObject();
        student.addProperty("name", "小明");
        student.addProperty("studentId", "20230001");
        student.addProperty("gpa", 3.8);
        
        // 创建课程数组
        JsonArray courses = new JsonArray();
        
        JsonObject course1 = new JsonObject();
        course1.addProperty("name", "Java编程");
        course1.addProperty("credit", 3);
        courses.add(course1);
        
        JsonObject course2 = new JsonObject();
        course2.addProperty("name", "数据结构");
        course2.addProperty("credit", 4);
        courses.add(course2);
        
        // 添加课程数组到学生对象
        student.add("courses", courses);
        
        // 使用Gson格式化输出
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        String json = gson.toJson(student);
        System.out.println(json);
    }
}

输出:

json
{
  "name": "小明",
  "studentId": "20230001",
  "gpa": 3.8,
  "courses": [
    {
      "name": "Java编程",
      "credit": 3
    },
    {
      "name": "数据结构",
      "credit": 4
    }
  ]
}

将Java对象转换为JSON​

java
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
import java.util.Arrays;
import java.util.List;

class Student {
    private String name;
    private String studentId;
    private double gpa;
    private List<Course> courses;
    
    // 构造函数
    public Student(String name, String studentId, double gpa, List<Course> courses) {
        this.name = name;
        this.studentId = studentId;
        this.gpa = gpa;
        this.courses = courses;
    }
}

class Course {
    private String name;
    private int credit;
    
    // 构造函数
    public Course(String name, int credit) {
        this.name = name;
        this.credit = credit;
    }
}

public class GsonObjectToJsonExample {
    public static void main(String[] args) {
        // 创建课程
        Course java = new Course("Java编程", 3);
        Course dataStructure = new Course("数据结构", 4);
        Course algorithms = new Course("算法", 3);
        
        // 创建学生
        Student student = new Student("小红", "20230002", 3.9, 
                                     Arrays.asList(java, dataStructure, algorithms));
        
        // 使用Gson转换为JSON
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        String json = gson.toJson(student);
        
        System.out.println(json);
    }
}

输出:

json
{
  "name": "小红",
  "studentId": "20230002",
  "gpa": 3.9,
  "courses": [
    {
      "name": "Java编程",
      "credit": 3
    },
    {
      "name": "数据结构",
      "credit": 4
    },
    {
      "name": "算法",
      "credit": 3
    }
  ]
}

实际应用场景​

场景1: 构建RESTful API响应​

在构建Web应用的后端时，通常需要返回JSON格式的响应给前端。

java
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.node.ArrayNode;
import java.util.Date;

public class ApiResponseExample {
    public static void main(String[] args) {
        try {
            // 模拟API请求处理
            String userId = "user123";
            
            // 创建API响应
            ObjectMapper mapper = new ObjectMapper();
            ObjectNode response = mapper.createObjectNode();
            
            // 添加状态信息
            response.put("status", "success");
            response.put("timestamp", new Date().toString());
            
            // 添加用户数据
            ObjectNode userData = mapper.createObjectNode();
            userData.put("id", userId);
            userData.put("username", "javauser");
            userData.put("email", "javauser@example.com");
            userData.put("memberSince", "2022-01-15");
            
            // 添加用户订单
            ArrayNode orders = mapper.createArrayNode();
            
            ObjectNode order1 = mapper.createObjectNode();
            order1.put("orderId", "ORD-2023-001");
            order1.put("amount", 150.75);
            order1.put("date", "2023-01-10");
            orders.add(order1);
            
            ObjectNode order2 = mapper.createObjectNode();
            order2.put("orderId", "ORD-2023-015");
            order2.put("amount", 89.99);
            order2.put("date", "2023-02-22");
            orders.add(order2);
            
            // 将订单添加到用户数据
            userData.set("orders", orders);
            
            // 将用户数据添加到响应
            response.set("data", userData);
            
            // 输出API响应
            String jsonResponse = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(response);
            System.out.println(jsonResponse);
            
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

场景2: 配置文件生成​

很多应用程序使用JSON作为配置文件格式。

java
import org.json.JSONObject;
import java.io.FileWriter;
import java.io.IOException;

public class ConfigFileGenerator {
    public static void main(String[] args) {
        // 创建应用配置
        JSONObject config = new JSONObject();
        
        // 基本设置
        config.put("appName", "MyJavaApp");
        config.put("version", "1.0.0");
        config.put("debug", true);
        
        // 数据库配置
        JSONObject dbConfig = new JSONObject();
        dbConfig.put("url", "jdbc:mysql://localhost:3306/mydb");
        dbConfig.put("username", "dbuser");
        dbConfig.put("password", "dbpassword");
        dbConfig.put("poolSize", 10);
        
        // 添加数据库配置
        config.put("database", dbConfig);
        
        // 日志配置
        JSONObject logConfig = new JSONObject();
        logConfig.put("level", "INFO");
        logConfig.put("path", "/var/log/myapp");
        logConfig.put("maxFileSize", "10MB");
        
        // 添加日志配置
        config.put("logging", logConfig);
        
        // 将配置写入文件
        try (FileWriter file = new FileWriter("config.json")) {
            file.write(config.toString(2));
            System.out.println("配置文件已生成: config.json");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
备注

在实际应用中，敏感信息（如数据库密码）不应直接硬编码在配置文件中。上面的例子仅用于演示目的。

性能优化技巧​

在处理大型JSON数据时，有一些技巧可以帮助优化性能：

  1. 重用ObjectMapper: 如果使用Jackson，创建ObjectMapper的实例比较昂贵，应该重用它而不是每次都创建新实例。
java
// 推荐做法：创建一个静态实例
private static final ObjectMapper MAPPER = new ObjectMapper();

// 不推荐：每次方法调用都创建新实例
public String convertToJson(Object obj) {
    ObjectMapper mapper = new ObjectMapper(); // 不推荐
    return mapper.writeValueAsString(obj);
}

  1. 使用流处理大型JSON: 处理大型JSON数据时，使用流式API可以减少内存使用。

  2. 选择合适的库: 不同库在性能和功能上有所不同，根据需要选择：

    • Jackson：功能全面，性能好
    • Gson：使用简单，在Android上常用
    • org.json：轻量级，简单易用但功能有限

总结​

在本文中，我们学习了如何在Java中创建JSON数据，包括：

  • 使用org.json库创建简单和嵌套的JSON对象与数组
  • 使用Jackson库的ObjectMapper创建JSON并将Java对象转换为JSON
  • 使用Gson库处理JSON数据
  • 在实际应用场景中应用JSON创建（RESTful API响应和配置文件生成）
  • JSON处理的性能优化技巧

掌握这些技能后，你将能够在Java应用程序中有效地处理JSON数据，无论是Web应用、RESTful API还是配置管理。

练习​

  1. 创建一个包含学生信息（姓名、年龄、成绩列表）的JSON对象，并将其保存到文件中。
  2. 编写一个程序，创建一个表示产品目录的JSON结构，包含分类和产品信息。
  3. 使用Jackson或Gson，将一个包含多个对象的Java集合转换成JSON数组。
  4. 模拟一个API响应，返回分页数据的JSON结构，包含元数据和数据列表。

额外资源​

通过实践这些概念和示例，你将能够在Java应用程序中熟练地创建和处理JSON数据。