在 Java 开发中，JSON（JavaScript Object Notation）作为一种轻量级的数据交换格式，被广泛应用于前后端数据交互、配置文件存储等场景，掌握如何在 Java 中定义 JSON 字符串是开发者的基础技能之一，本文将系统介绍 Java 中定义 JSON 字符串的多种方法，包括手动拼接、使用第三方库（如 Gson、Jackson、Fastjson）以及 Java 17+ 原生支持的 JSON API,并对比不同方法的优缺点及适用场景。
手动拼接 JSON 字符串
手动拼接是最直接的方式，通过字符串拼接操作构建 JSON 格式的内容，这种方法无需依赖外部库，适合简单 JSON 结构的快速实现,但存在明显局限性。
实现方式
以构建一个包含用户信息的 JSON 对象为例：
public class ManualJsonExample {
public static void main(String[] args) {
String jsonString = "{"
+ "\"name\": \"张三\","
+ "\"age\": 30,"
+ "\"isStudent\": false,"
+ "\"hobbies\": [\"阅读\", \"游泳\", \"编程\"],"
+ "\"address\": {"
+ " \"city\": \"北京\","
+ " \"district\": \"朝阳区\""
+ "}"
+ "}";
System.out.println(jsonString);
}
}
优缺点分析
- 优点：
- 无需额外依赖，适合轻量级场景；
- 实现直观，适合初学者理解 JSON 结构。
- 缺点：
- 可维护性差：当 JSON 结构复杂时，字符串拼接易出错，且难以阅读和修改；
- 性能较低：频繁的字符串拼接会创建多个临时对象，增加 GC 压力；
- 缺乏类型安全：无法在编译时检查 JSON 格式的正确性。
适用场景
仅适用于结构极其简单、不会频繁变动的 JSON 字符串定义,例如固定格式的配置信息。
使用 Gson 库定义 JSON 字符串
Google Gson 是一个开源的 Java JSON 库，提供简单易用的 API 将 Java 对象转换为 JSON 字符串，反之亦然，通过 Gson，开发者可以通过构建 Java 对象或使用 JsonParser 等方式定义 JSON。
通过 Java 对象转 JSON
首先定义与 JSON 结构对应的 Java 类，然后使用 Gson 实例进行转换：
import com.google.gson.Gson;
// 定义 Java 类
class User {
private String name;
private int age;
private boolean isStudent;
private String[] hobbies;
private Address address;
// 内部类 Address
static class Address {
private String city;
private String district;
public Address(String city, String district) {
this.city = city;
this.district = district;
}
}
// 构造方法、getter/setter（省略）
public User(String name, int age, boolean isStudent, String[] hobbies, Address address) {
this.name = name;
this.age = age;
this.isStudent = isStudent;
this.hobbies = hobbies;
this.address = address;
}
}
public class GsonExample {
public static void main(String[] args) {
User.Address address = new User.Address("北京", "朝阳区");
User user = new User("张三", 30, false, new String[]{"阅读", "游泳", "编程"}, address);
Gson gson = new Gson();
String jsonString = gson.toJson(user);
System.out.println(jsonString);
}
}
使用 JsonBuilder（Gson 2.8+ 版本支持）
Gson 提供了 JsonBuilder 流式 API，可更灵活地构建 JSON：
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
public class GsonBuilderExample {
public static void main(String[] args) {
JsonObject jsonObject = new JsonObject();
jsonObject.addProperty("name", "李四");
jsonObject.addProperty("age", 25);
jsonObject.addProperty("isStudent", true);
JsonArray hobbies = new JsonArray();
hobbies.add("篮球");
hobbies.add("音乐");
jsonObject.add("hobbies", hobbies);
JsonObject address = new JsonObject();
address.addProperty("city", "上海");
address.addProperty("district", "浦东新区");
jsonObject.add("address", address);
String jsonString = jsonObject.toString();
System.out.println(jsonString);
}
}
优缺点分析
- 优点：
- 支持复杂 JSON 结构，通过对象映射可避免手动拼接的错误；
- 提供流式 API，灵活构建嵌套 JSON；
- 自动处理 Java 对象与 JSON 的类型转换（如日期、枚举等）。
- 缺点：
- 需要引入外部依赖（Maven 依赖：
com.google.code.gson:gson:2.10.1）； - 对于简单场景，略显“重”。
- 需要引入外部依赖（Maven 依赖：
适用场景
适用于复杂 JSON 结构、需要频繁进行对象与 JSON 转换的项目,尤其是需要处理嵌套对象和数组时。
使用 Jackson 库定义 JSON 字符串
Jackson 是另一个高性能的 Java JSON 库，广泛用于 Spring 等框架中，其功能强大，支持流式 API、数据绑定等多种方式，定义 JSON 字符串的灵活性较高。
通过对象映射（ObjectMapper）
与 Gson 类似，Jackson 通过 ObjectMapper 将 Java 对象转换为 JSON：
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
class Student {
private String name;
private int age;
private boolean isStudent;
private String[] hobbies;
// 构造方法、getter/setter（省略）
public Student(String name, int age, boolean isStudent, String[] hobbies) {
this.name = name;
this.age = age;
this.isStudent = isStudent;
this.hobbies = hobbies;
}
}
public class JacksonExample {
public static void main(String[] args) throws JsonProcessingException {
Student student = new Student("王五", 22, true, new String[]{"画画", "旅行"});
ObjectMapper objectMapper = new ObjectMapper();
// 格式化输出（缩进 2 空格）
String jsonString = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(student);
System.out.println(jsonString);
}
}
使用 JsonNode 和 ObjectNode 动态构建
Jackson 提供了树模型 API，可通过 JsonNode 动态构建 JSON：
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 JacksonTreeExample {
public static void main(String[] args) throws JsonProcessingException {
ObjectMapper objectMapper = new ObjectMapper();
ObjectNode rootNode = objectMapper.createObjectNode();
rootNode.put("name", "赵六");
rootNode.put("age", 35);
rootNode.put("isStudent", false);
ArrayNode hobbiesNode = rootNode.putArray("hobbies");
hobbiesNode.add("跑步");
hobbiesNode.add("摄影");
ObjectNode addressNode = rootNode.putObject("address");
addressNode.put("city", "广州");
addressNode.put("district", "天河区");
String jsonString = objectMapper.writeValueAsString(rootNode);
System.out.println(jsonString);
}
}
优缺点分析
- 优点：
- 性能优异，适合高并发场景；
- 支持注解（如
@JsonProperty、@JsonIgnore）自定义 JSON 序列化； - 提供树模型 API，适合动态构建 JSON 结构。
- 缺点：
- API 相对复杂，学习成本略高于 Gson；
- 对于简单场景，配置较为繁琐。
适用场景
适用于大型项目、需要高性能 JSON 处理的场景，尤其是与 Spring 框架集成时。
使用 Fastjson 库定义 JSON 字符串
Fastjson 是阿里巴巴开源的 JSON 库，以高性能和易用性著称，曾是国内 Java 开发中使用最广泛的 JSON 库之一，尽管近年来因安全事件（如反序列化漏洞）使用频率有所下降,但在特定场景下仍具优势。
实现方式
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
public class FastjsonExample {
public static void main(String[] args) {
JSONObject jsonObject = new JSONObject();
jsonObject.put("name", "钱七");
jsonObject.put("age", 28);
jsonObject.put("isStudent", false);
JSONArray hobbies = new JSONArray();
hobbies.add("游戏");
hobbies.add("烹饪");
jsonObject.put("hobbies", hobbies);
JSONObject address = new JSONObject();
address.put("city", "深圳");
address.put("district", "南山区");
jsonObject.put("address", address);
String jsonString = jsonObject.toJSONString();
System.out.println(jsonString);
}
}
优缺点分析
- 优点：
- API 简洁，类似于 JavaScript 操作 JSON，上手快；
- 性能极高，序列化和反序列化速度快。
- 缺点：
- 安全性问题：历史版本存在反序列化漏洞，需使用最新版本并做好安全配置；
- 维护活跃度下降，社区支持不如 Gson 和 Jackson。
适用场景
适用于对性能要求极高、且已熟悉其 API 的项目,需注意版本安全。
Java 17+ 原生 JSON API（JEP 427: JSON API）
从 Java 17 开始，JDK 引入了内置的 JSON API（孵化模块），无需第三方依赖即可处理 JSON，目前仍处于孵化阶段,需手动启用模块支持。
实现方式
import java.util.Map;
import java.util.List;
import javax.json.JsonObject;
import javax.json.JsonArray;
import javax.json.JsonReader;
import javax.json.JsonWriter;
import javax.json.JsonString;
import javax.json.JsonNumber;
public class JavaNativeJsonExample {
public static void main(String[] args) {
// 构建 JsonObject
JsonObject jsonObject = javax.json.Json.createObjectBuilder()
.add("name", "孙八")
.add("age", 40)
.add("isStudent", false)
.add("hobbies", javax.json.Json.createArrayBuilder()
.add("登山")
.add("书法")
.build())
.add("address", javax.json.Json.createObjectBuilder()
.add("city", "成都")
.add("district", "锦江区")
.build())
.build();
// 转换为 JSON 字符串
String jsonString = jsonObject.toString();
System.out.println(jsonString);
}
}
优缺点分析
- 优点：
- 无需第三方依赖，减少项目依赖管理成本；
- 与 Java 语言深度集成，符合 Java 开发规范。
- 缺点：
- 目前为孵化阶段，API 可能不稳定，未来版本可能变更；
- 功能相对第三方库简单，不支持复杂注解和自定义序列化。
适用场景
适用于使用 Java 17+、且希望减少外部依赖的简单 JSON 处理场景。
方法对比与选择建议
| 方法 | 依赖情况 | 学习成本 | 性能 | 适用场景 |
|---|---|---|---|---|
| 手动拼接 | 无 | 低 | 低 | 极简单、固定结构的 JSON |
| Gson | 第三方 | 中 | 中 | 复杂结构、对象映射需求 |
| Jackson | 第三方 | 中高 | 高 | 高性能、Spring 集成场景 |
| Fastjson | 第三方 | 低 | 极高 | 对性能要求极高、熟悉 API |
| Java 17+ 原生 API | 无 | 中 | 中 | 简单场景、减少依赖需求 |
选择建议：
- 若 JSON 结构简单且无需依赖，优先考虑 Java 17+ 原生 API 或手动拼接；
- 若项目已使用 Spring 或需高性能处理，推荐 Jackson；
- 若注重易用性和对象映射，Gson 是不错的选择；
- 避免在新项目中使用 Fastjson,除非有特殊性能需求且已做好安全防护。
在 Java 中定义 JSON 字符串的方法多种多样，开发者需根据项目需求、技术栈和性能要求选择合适的方案，手动拼接适合快速实现，第三方库（Gson、Jackson）提供了更强大和灵活的功能，而 Java 17+ 的原生 API 则为未来无依赖 JSON 处理提供了可能，无论选择哪种方法，都需注意代码的可维护性、安全性以及性能的平衡，以确保 JSON 数据处理的稳定与高效。
