Java 处理 JSON 编程实用技巧

3.1.3 集合类型的序列化与反序列化

// 序列化集合
List<User> userList = Arrays.asList(
    new User("张三", 25),
    new User("李四", 30)
);
String jsonList = gson.toJson(userList);

// 反序列化集合 - 方法 1：使用 TypeToken
Type userListType = new TypeToken<List<User>>(){}.getType();
List<User> parsedList = gson.fromJson(jsonList, userListType);

// 反序列化集合 - 方法 2：先转为数组再转集合
User[] userArray = gson.fromJson(jsonList, User[].class);
List<User> userList2 = Arrays.asList(userArray);

3.2 高级特性

3.2.1 GsonBuilder 配置

Gson gson = new GsonBuilder()
    .setPrettyPrinting()              // 格式化输出
    .serializeNulls()                 // 序列化 null 值
    .setDateFormat("yyyy-MM-dd HH:mm:ss") // 设置日期格式
    .excludeFieldsWithoutExposeAnnotation() // 只序列化有@Expose 注解的字段
    .registerTypeAdapter(Date.class, new DateSerializer()) // 注册自定义类型适配器
    .disableHtmlEscaping()            // 禁用 HTML 转义
    .create();

3.2.2 自定义序列化和反序列化

// 自定义序列化器
public class UserSerializer implements JsonSerializer<User> {
    @Override
    public JsonElement serialize(User user, Type type, JsonSerializationContext context) {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("userName", user.getName()); // 字段名映射
        jsonObject.addProperty("userAge", user.getAge());
        return jsonObject;
    }
}

// 自定义反序列化器
public class UserDeserializer implements JsonDeserializer<User> {
    @Override
    public User deserialize(JsonElement json, Type type, JsonDeserializationContext context) throws JsonParseException {
        JsonObject jsonObject = json.getAsJsonObject();
        String name = jsonObject.get("userName").getAsString();
        int age = jsonObject.get("userAge").getAsInt();
        return new User(name, age);
    }
}

// 注册使用
Gson gson = new GsonBuilder()
    .registerTypeAdapter(User.class, new UserSerializer())
    .registerTypeAdapter(User.class, new UserDeserializer())
    .create();

3.2.3 使用注解控制序列化

public class User {
    @SerializedName("user_name") // 字段重命名
    private String name;
    
    @SerializedName(value = "user_age", alternate = {"age", "userAge"}) // 多字段名映射
    private int age;
    
    @Expose(serialize = true, deserialize = false) // 控制序列化和反序列化
    private String password;
    
    @Expose(serialize = false, deserialize = true)
    private String email;
    
    // getter 和 setter 方法...
}

// 注意：使用@Expose 需要配合 excludeFieldsWithoutExposeAnnotation()
Gson gson = new GsonBuilder().excludeFieldsWithoutExposeAnnotation().create();

3.2.4 处理复杂嵌套对象

// 使用 JsonElement 处理未知结构的 JSON
String complexJson = "{\"name\":\"张三\",\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\"}}";
JsonElement jsonElement = JsonParser.parseString(complexJson);
JsonObject jsonObject = jsonElement.getAsJsonObject();

// 获取简单字段
String name = jsonObject.get("name").getAsString();

// 获取嵌套对象的字段
JsonObject addressObject = jsonObject.getAsJsonObject("address");
String city = addressObject.get("city").getAsString();

// 安全地获取可能不存在的字段
if (jsonObject.has("phone")) {
    String phone = jsonObject.get("phone").getAsString();
}

**技巧：**Gson 2.8.6+版本中，JsonParser 的静态方法已被弃用，建议使用以下方式：

Gson gson = new Gson();
JsonReader reader = new JsonReader(new StringReader(jsonString));
reader.setLenient(true);
JsonElement jsonElement = gson.fromJson(reader, JsonElement.class);

4. Jackson 使用技巧

4.1 基础用法

Jackson 是一个功能强大的 Java 库，用于处理 JSON 数据格式。它被广泛应用于 Spring 框架中，性能优异且功能丰富。

4.1.1 Maven 依赖

<!-- 核心依赖 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.0</version>
</dependency>
<!-- 可选：处理 XML -->
<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-xml</artifactId>
    <version>2.13.0</version>
</dependency>

4.1.2 基本序列化与反序列化

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

// Java 对象转 JSON 字符串
User user = new User("张三", 25);
String json = objectMapper.writeValueAsString(user);
System.out.println(json); // {"name":"张三","age":25}

// JSON 字符串转 Java 对象
String jsonString = "{\"name\":\"李四\",\"age\":30}";
User parsedUser = objectMapper.readValue(jsonString, User.class);
System.out.println(parsedUser.getName()); // 李四

// 格式化输出 JSON
String prettyJson = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(user);

4.1.3 集合类型的序列化与反序列化

// 序列化集合
List<User> userList = Arrays.asList(
    new User("张三", 25),
    new User("李四", 30)
);
String jsonList = objectMapper.writeValueAsString(userList);

// 反序列化集合
List<User> parsedList = objectMapper.readValue(
    jsonList,
    new TypeReference<List<User>>() {}
);

// 反序列化为 Map
Map<String, Object> map = objectMapper.readValue(
    jsonString,
    new TypeReference<Map<String, Object>>() {}
);

4.2 高级特性

4.2.1 ObjectMapper 配置

ObjectMapper objectMapper = new ObjectMapper()
    .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false) // 忽略未知属性
    .configure(SerializationFeature.INDENT_OUTPUT, true)                // 格式化输出
    .configure(SerializationFeature.WRITE_NULL_MAP_VALUES, false)       // 不序列化 null 值
    .configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)   // 日期不使用时间戳
    .setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"))          // 设置日期格式
    .registerModule(new JavaTimeModule());                               // 支持 Java 8 日期时间 API

4.2.2 自定义序列化和反序列化

// 自定义序列化器
public class UserSerializer extends JsonSerializer<User> {
    @Override
    public void serialize(User user, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeStartObject();
        jsonGenerator.writeStringField("userName", user.getName());
        jsonGenerator.writeNumberField("userAge", user.getAge());
        jsonGenerator.writeEndObject();
    }
}

// 自定义反序列化器
public class UserDeserializer extends JsonDeserializer<User> {
    @Override
    public User deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        JsonNode node = jsonParser.getCodec().readTree(jsonParser);
        String name = node.get("userName").asText();
        int age = node.get("userAge").asInt();
        return new User(name, age);
    }
}

// 注册使用
SimpleModule module = new SimpleModule();
module.addSerializer(User.class, new UserSerializer());
module.addDeserializer(User.class, new UserDeserializer());
objectMapper.registerModule(module);

4.2.3 使用注解控制序列化

public class User {
    @JsonProperty("user_name") // 字段重命名
    private String name;
    
    @JsonIgnore // 忽略此字段
    private String password;
    
    @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss") // 日期格式化
    private Date createTime;
    
    @JsonInclude(JsonInclude.Include.NON_NULL) // 只序列化非 null 值
    private String email;
    
    @JsonInclude(JsonInclude.Include.NON_EMPTY) // 只序列化非空值
    private List<String> hobbies;
    
    // getter 和 setter 方法...
}

4.2.4 处理复杂 JSON 结构

// 使用 JsonNode 处理未知结构的 JSON
String complexJson = "{\"name\":\"张三\",\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\"}}";
JsonNode rootNode = objectMapper.readTree(complexJson);

// 获取字段
String name = rootNode.get("name").asText();
String city = rootNode.get("address").get("city").asText();

// 安全地获取可能不存在的字段
if (rootNode.has("phone")) {
    String phone = rootNode.get("phone").asText();
}

// 遍历数组
JsonNode arrayNode = rootNode.get("contacts");
if (arrayNode != null && arrayNode.isArray()) {
    for (JsonNode node : arrayNode) {
        String contactName = node.get("name").asText();
    }
}

4.2.5 使用树模型

// 创建树模型
ObjectMapper mapper = new ObjectMapper();
ObjectNode rootNode = mapper.createObjectNode();
rootNode.put("name", "张三");
rootNode.put("age", 25);

// 创建嵌套对象
ObjectNode addressNode = mapper.createObjectNode();
addressNode.put("city", "北京");
addressNode.put("district", "朝阳区");
rootNode.set("address", addressNode);

// 创建数组
ArrayNode hobbiesNode = mapper.createArrayNode();
hobbiesNode.add("读书");
hobbiesNode.add("游泳");
rootNode.set("hobbies", hobbiesNode);

// 转换为 JSON 字符串
String json = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(rootNode);

5. Fastjson 使用技巧

5.1 基础用法

Fastjson 是阿里巴巴开发的 JSON 库，以其极高的性能著称，API 简洁易用。

**安全提示：**Fastjson 历史上存在一些安全漏洞，使用时请确保更新到最新版本，并根据官方建议进行安全配置。

5.1.1 Maven 依赖

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.79</version>
</dependency>

5.1.2 基本序列化与反序列化

// Java 对象转 JSON 字符串
User user = new User("张三", 25);
String json = JSON.toJSONString(user);
System.out.println(json); // {"age":25,"name":"张三"}

// JSON 字符串转 Java 对象
String jsonString = "{\"name\":\"李四\",\"age\":30}";
User parsedUser = JSON.parseObject(jsonString, User.class);
System.out.println(parsedUser.getName()); // 李四

// 格式化输出
String prettyJson = JSON.toJSONString(user, SerializerFeature.PrettyFormat);

5.1.3 集合类型的序列化与反序列化

// 序列化集合
List<User> userList = Arrays.asList(
    new User("张三", 25),
    new User("李四", 30)
);
String jsonList = JSON.toJSONString(userList);

// 反序列化集合
List<User> parsedList = JSON.parseArray(jsonList, User.class);

// 反序列化为 JSONObject
JSONObject jsonObject = JSON.parseObject(jsonString);
String name = jsonObject.getString("name");
int age = jsonObject.getInteger("age");

5.2 高级特性

5.2.1 SerializerFeature 配置

// 配置序列化特性
String json = JSON.toJSONString(user,
    SerializerFeature.PrettyFormat,           // 格式化输出
    SerializerFeature.WriteNullStringAsEmpty, // null 字符串输出为""
    SerializerFeature.WriteNullNumberAsZero,  // null 数字输出为 0
    SerializerFeature.WriteNullBooleanAsFalse,// null 布尔值输出为 false
    SerializerFeature.WriteNullListAsEmpty,   // null 列表输出为 []
    SerializerFeature.DisableCircularReferenceDetect, // 禁用循环引用检测
    SerializerFeature.WriteDateUseDateFormat, // 日期格式化
    SerializerFeature.WriteMapNullValue       // 输出 null 值
);

5.2.2 自定义序列化和反序列化

// 自定义序列化器
public class UserSerializer implements ObjectSerializer {
    @Override
    public void write(JSONSerializer serializer, Object object, Object fieldName, Type fieldType, int features) throws IOException {
        User user = (User) object;
        SerializeWriter out = serializer.out;
        out.write('{');
        out.writeFieldName("userName");
        serializer.write(user.getName());
        out.write(',');
        out.writeFieldName("userAge");
        serializer.write(user.getAge());
        out.write('}');
    }
}

// 自定义反序列化器
public class UserDeserializer implements ObjectDeserializer {
    @Override
    public User deserialize(DefaultJSONParser parser, Type type, Object fieldName) {
        JSONObject jsonObject = parser.parseObject();
        String name = jsonObject.getString("userName");
        int age = jsonObject.getInteger("userAge");
        return new User(name, age);
    }
    
    @Override
    public int getFastMatchToken() {
        return 0;
    }
}

// 注册使用
ParserConfig.getGlobalInstance().putDeserializer(User.class, new UserDeserializer());
SerializeConfig.getGlobalInstance().put(User.class, new UserSerializer());

5.2.3 使用注解控制序列化

public class User {
    @JSONField(name = "user_name") // 字段重命名
    private String name;
    
    @JSONField(serialize = false) // 不序列化此字段
    private String password;
    
    @JSONField(deserialize = false) // 不反序列化此字段
    private String token;
    
    @JSONField(format = "yyyy-MM-dd HH:mm:ss") // 日期格式化
    private Date createTime;
    
    @JSONField(ordinal = 1) // 字段序列化顺序
    private String email;
    
    // getter 和 setter 方法...
}

5.2.4 使用 JSONObject 和 JSONArray

// 创建 JSONObject
JSONObject jsonObject = new JSONObject();
jsonObject.put("name", "张三");
jsonObject.put("age", 25);

// 创建嵌套 JSONObject
JSONObject addressObject = new JSONObject();
addressObject.put("city", "北京");
addressObject.put("district", "朝阳区");
jsonObject.put("address", addressObject);

// 创建 JSONArray
JSONArray hobbiesArray = new JSONArray();
hobbiesArray.add("读书");
hobbiesArray.add("游泳");
jsonObject.put("hobbies", hobbiesArray);

// 转换为 JSON 字符串
String json = jsonObject.toJSONString();

// 解析复杂 JSON
JSONObject parsedObject = JSON.parseObject(complexJson);
String city = parsedObject.getJSONObject("address").getString("city");
JSONArray contacts = parsedObject.getJSONArray("contacts");
for (int i = 0; i < contacts.size(); i++) {
    String contactName = contacts.getJSONObject(i).getString("name");
}

5.2.5 安全配置

// 禁用 AutoType，防止反序列化漏洞
ParserConfig.getGlobalInstance().setAutoTypeSupport(false);

// 如果需要使用 AutoType，建议使用白名单机制
ParserConfig parserConfig = ParserConfig.getGlobalInstance();
parserConfig.addAccept("com.example.model."); // 只允许反序列化指定包下的类

// 或者使用安全的 JSONReader
JSONReader jsonReader = new JSONReader(new StringReader(jsonString));
jsonReader.config(Feature.SupportAutoType, false);

6. 性能优化技巧

6.1 通用优化原则

• **重用对象：**避免重复创建 JSON 解析器实例（Gson、ObjectMapper 或 JSON），这些实例是线程安全的
• **避免不必要的转换：**直接在流上进行操作，减少中间字符串的创建
• **选择合适的解析模式：**根据需求选择树模型或流式 API
• **优化数据结构：**减少不必要的嵌套和冗余字段
• **合理使用缓存：**缓存序列化/反序列化的结果

6.2 Gson 性能优化

// 1. 重用 Gson 实例
public class GsonHolder {
    private static final Gson GSON = new GsonBuilder()
        .setPrettyPrinting()
        .create();
    
    public static Gson getGson() {
        return GSON;
    }
}

// 2. 使用 TypeAdapter 进行高性能序列化/反序列化
TypeAdapter<User> userAdapter = GsonHolder.getGson().getAdapter(User.class);
// 序列化到流
userAdapter.write(new JsonWriter(new FileWriter("user.json")), user);
// 从流反序列化
User user = userAdapter.read(new JsonReader(new FileReader("user.json")));

// 3. 避免使用 toJsonTree 再 toJson，直接使用 toJson
String json = GsonHolder.getGson().toJson(user);

6.3 Jackson 性能优化

// 1. 重用 ObjectMapper 实例
public class ObjectMapperHolder {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper()
        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
    
    public static ObjectMapper getObjectMapper() {
        return OBJECT_MAPPER;
    }
}

// 2. 使用流式 API 处理大型 JSON
// 序列化大型对象到文件
ObjectMapperHolder.getObjectMapper().writeValue(new File("large.json"), largeObject);
// 反序列化大型 JSON
LargeObject largeObject = ObjectMapperHolder.getObjectMapper()
    .readValue(new File("large.json"), LargeObject.class);

// 3. 使用 JsonNode 高效处理部分字段
JsonNode rootNode = ObjectMapperHolder.getObjectMapper().readTree(jsonString);
String neededField = rootNode.get("neededField").asText();

// 4. 使用 TypeFactory 预构建复杂类型
JavaType listType = ObjectMapperHolder.getObjectMapper().getTypeFactory()
    .constructCollectionType(List.class, User.class);

6.4 Fastjson 性能优化

// 1. 使用 TypeReference 提高泛型反序列化性能
List<User> userList = JSON.parseObject(jsonList, new TypeReference<List<User>>() {});

// 2. 使用 JSONB 格式（Fastjson 2.0+）
byte[] bytes = JSONB.toJSONBBytes(user);
User parsedUser = JSONB.parseObject(bytes, User.class);

// 3. 自定义序列化过滤器提高性能
PropertyFilter propertyFilter = new PropertyFilter() {
    @Override
    public boolean apply(Object object, String name, Object value) {
        // 只序列化需要的字段
        return !"password".equals(name);
    }
};
String json = JSON.toJSONString(user, propertyFilter);

// 4. 使用 JSONReader 处理大型 JSON
JSONReader reader = new JSONReader(new StringReader(largeJson));
reader.startObject();
while (reader.hasNext()) {
    String key = reader.readString();
    if ("neededField".equals(key)) {
        String value = reader.readString();
        // 处理需要的字段
    } else {
        reader.skipValue();
    }
}
reader.endObject();

**注意：**性能优化需要根据具体场景进行测试和验证，不同的框架在不同场景下可能有不同的表现。建议使用 JMH 等基准测试工具进行性能对比。

7. 最佳实践

7.1 选择合适的框架

• 如果项目使用 Spring 框架，优先考虑 Jackson
• 如果对性能要求极高，可考虑 Fastjson（注意安全问题）
• 如果追求 API 简洁和易用性，可选择 Gson

7.2 代码组织最佳实践

// 示例：创建统一的 JSON 工具类
public class JsonUtils {
    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper()
        .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
        .setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    
    // 序列化方法
    public static String toJson(Object obj) {
        try {
            return OBJECT_MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("JSON 序列化失败", e);
        }
    }
    
    // 反序列化方法
    public static <T> T fromJson(String json, Class<T> clazz) {
        try {
            return OBJECT_MAPPER.readValue(json, clazz);
        } catch (JsonProcessingException e) {
            throw new RuntimeException("JSON 反序列化失败", e);
        }
    }
    
    // 反序列化集合
    public static <T> List<T> fromJsonList(String json, Class<T> clazz) {
        try {
            return OBJECT_MAPPER.readValue(
                json,
                OBJECT_MAPPER.getTypeFactory().constructCollectionType(List.class, clazz)
            );
        } catch (JsonProcessingException e) {
            throw new RuntimeException("JSON 列表反序列化失败", e);
        }
    }
}

7.3 错误处理和异常管理

// 优雅处理 JSON 解析异常
try {
    User user = JsonUtils.fromJson(jsonString, User.class);
    // 处理用户对象
} catch (RuntimeException e) {
    // 记录详细错误信息
    log.error("JSON 解析失败：{}", jsonString, e);
    // 友好的错误响应
    throw new BusinessException("数据格式错误，请检查输入");
}

// 验证 JSON 格式
try {
    ObjectMapperHolder.getObjectMapper().readTree(jsonString); // JSON 格式有效
} catch (Exception e) {
    // JSON 格式无效
    throw new IllegalArgumentException("无效的 JSON 格式");
}

7.4 安全处理

**安全提示：**处理外部 JSON 数据时，务必注意安全问题，特别是反序列化操作可能导致远程代码执行漏洞。

// Jackson 安全配置
ObjectMapper mapper = new ObjectMapper();
// 禁用外部实体，防止 XXE 攻击
mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
// 限制反序列化的类
mapper.registerModule(new SimpleModule()
    .addDeserializer(Object.class, new SafeObjectDeserializer()));

// Fastjson 安全配置
ParserConfig.getGlobalInstance().setAutoTypeSupport(false);
// 使用白名单
ParserConfig.getGlobalInstance().addAccept("com.example.model.");

// Gson 安全配置
Gson gson = new GsonBuilder()
    .registerTypeAdapterFactory(new SafeTypeAdapterFactory())
    .create();

7.5 处理日期时间

// Jackson 日期时间处理
ObjectMapper mapper = new ObjectMapper();
// 配置日期格式
mapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
// 支持 Java 8 日期时间 API
mapper.registerModule(new JavaTimeModule());
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

// Gson 日期时间处理
Gson gson = new GsonBuilder()
    .setDateFormat("yyyy-MM-dd HH:mm:ss")
    .registerTypeAdapter(LocalDateTime.class, new LocalDateTimeSerializer())
    .registerTypeAdapter(LocalDateTime.class, new LocalDateTimeDeserializer())
    .create();

// Fastjson 日期时间处理
String json = JSON.toJSONString(dateObject, SerializerFeature.WriteDateUseDateFormat);
// 自定义日期格式
JSON.DEFFAULT_DATE_FORMAT = "yyyy-MM-dd HH:mm:ss";
String formattedJson = JSON.toJSONString(dateObject, SerializerFeature.WriteDateUseDateFormat);

8. 常见问题与解决方案

8.1 字段名不匹配

**问题：**JSON 中的字段名与 Java 类中的字段名不一致，导致反序列化失败。

解决方案：

• Gson: 使用@SerializedName 注解
• Jackson: 使用@JsonProperty 注解
• Fastjson: 使用@JSONField 注解

8.2 处理 null 值

**问题：**JSON 中包含 null 值，如何控制其序列化和反序列化行为。

解决方案：

• Gson: 使用 GsonBuilder.serializeNulls() 控制
• Jackson: 使用@JsonInclude(JsonInclude.Include.NON_NULL) 注解或配置
• Fastjson: 使用 SerializerFeature.WriteMapNullValue 或@JSONField 注解

8.3 循环引用问题

**问题：**对象之间存在循环引用，导致序列化时出现 StackOverflowError。

解决方案：

• Gson: 默认处理循环引用，但会生成$ref 引用标记
• Jackson: 使用@JsonManagedReference 和@JsonBackReference 注解
• Fastjson: 使用 SerializerFeature.DisableCircularReferenceDetect 禁用循环引用检测

8.4 处理复杂嵌套结构

**问题：**JSON 结构复杂，难以直接映射到 Java 类。

解决方案：

• Gson: 使用 JsonParser 和 JsonElement API
• Jackson: 使用 JsonNode 树模型 API
• Fastjson: 使用 JSONObject 和 JSONArray API

8.5 性能问题

**问题：**处理大型 JSON 数据时性能不佳。

解决方案：

• 重用解析器实例
• 使用流式 API 而不是树模型
• 避免不必要的字符串转换
• 使用更高效的 JSON 库（如需要高性能可考虑 Fastjson）

9. 总结与建议

选择建议

• **Spring 项目：**优先使用 Jackson，与 Spring 框架集成良好
• **对性能要求极高的场景：**考虑 Fastjson，但需注意安全问题
• **追求简洁 API：**Gson 是不错的选择
• **混合环境：**可以根据不同模块的需求选择不同的框架

重要提示

• 始终使用最新稳定版本的 JSON 库，以获取安全补丁和性能改进
• 在处理外部输入的 JSON 数据时，务必注意安全问题
• 对于复杂的 JSON 处理需求，考虑封装统一的工具类
• 在关键性能路径上，进行性能测试以选择最优方案

通过本文介绍的技巧和最佳实践，相信您能够在 Java 项目中更加高效、安全地处理 JSON 数据。选择合适的工具，遵循最佳实践，将使您的代码更加健壮和可维护。