Java 处理 JSON 的实战技巧与性能优化

高级配置

默认行为未必符合业务需求，通过 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();

注意： Gson 2.8.6+ 版本中，JsonParser 的静态方法已被弃用，建议使用 JsonReader 方式解析，兼容性更好。

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

对于复杂嵌套结构或未知格式的 JSON，直接使用 JsonElement 操作比强转对象更灵活。

String complexJson = "{\"name\":\"张三\",\"address\":{\"city\":\"北京\",\"district\":\"朝阳区\"}}";
JsonElement jsonElement = JsonParser.parseString(complexJson);
JsonObject jsonObject = jsonElement.getAsJsonObject();

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

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

Jackson 实战技巧

Jackson 是 Spring Boot 的默认 JSON 库，生态完善，性能强劲，企业级开发首选。

基础用法

核心类是 ObjectMapper，同样建议单例复用。

ObjectMapper objectMapper = new ObjectMapper();

// Java 对象转 JSON 字符串
User user = new User("张三", 25);
String json = objectMapper.writeValueAsString(user);

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

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

处理泛型集合时，Jackson 提供了 TypeReference，写法比 Gson 的 TypeToken 更直观。

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

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

高级配置

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

如果需要对特定字段进行特殊处理，或者完全控制 JSON 生成过程，可以实现 JsonSerializer 和 JsonDeserializer。

// 自定义序列化器
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();
    }
}

// 注册模块
SimpleModule module = new SimpleModule();
module.addSerializer(User.class, new UserSerializer());
objectMapper.registerModule(module);

对于动态结构或需要遍历修改的 JSON，JsonNode 树模型非常有用。

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();

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

Fastjson 实战技巧

Fastjson 以高性能著称，API 设计偏向便捷，但在安全性上需要格外小心。

基础用法

阿里巴巴出品，使用 JSON 工具类即可，无需额外实例化。

// Java 对象转 JSON 字符串
User user = new User("张三", 25);
String json = JSON.toJSONString(user);

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

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

高级特性

Fastjson 提供了丰富的 SerializerFeature 来控制输出行为，比如空值处理、循环引用检测等。

String json = JSON.toJSONString(user, 
    SerializerFeature.PrettyFormat,             // 格式化输出
    SerializerFeature.WriteNullStringAsEmpty,   // null 字符串输出为""
    SerializerFeature.WriteNullNumberAsZero,    // null 数字输出为 0
    SerializerFeature.DisableCircularReferenceDetect // 禁用循环引用检测
);

安全提示： Fastjson 历史上存在过严重的安全漏洞（如反序列化漏洞）。生产环境务必升级到最新稳定版，并严格限制 AutoType 功能。

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

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

性能优化技巧

在实际项目中，JSON 处理往往是高频操作，优化得当能显著提升吞吐量。

通用原则

1. 重用对象： Gson、ObjectMapper 都是线程安全的，千万不要每次请求都 new 一个新实例，这会造成巨大的 GC 压力。
2. 避免不必要的转换： 尽量直接在流上操作，减少中间字符串的创建。
3. 选择合适的解析模式： 只需要部分字段时，优先使用流式 API 而不是树模型。

各框架优化示例

Gson: 使用 TypeAdapter 可以进一步提升特定类型的序列化效率。

TypeAdapter<User> userAdapter = GsonHolder.getGson().getAdapter(User.class);
// 序列化到流
userAdapter.write(new JsonWriter(new FileWriter("user.json")), user);

Jackson: 处理大文件时，直接写入 File 对象比转成 String 内存占用更小。

// 序列化大型对象到文件
ObjectMapperHolder.getObjectMapper().writeValue(new File("large.json"), largeObject);

// 反序列化大型 JSON
LargeObject largeObject = ObjectMapperHolder.getObjectMapper()
    .readValue(new File("large.json"), LargeObject.class);

Fastjson: 使用 JSONB 二进制格式可以大幅提升序列化速度，但兼容性稍差。

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

最佳实践与总结

统一封装

不要到处调用框架 API，建议封装统一的工具类，方便后续切换实现或增加日志监控。

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

错误处理

外部传入的 JSON 数据不可信，必须捕获异常并给出友好提示，避免将堆栈信息直接暴露给前端。

try {
    User user = JsonUtils.fromJson(jsonString, User.class);
} catch (RuntimeException e) {
    log.error("JSON 解析失败：{}", jsonString, e);
    throw new BusinessException("数据格式错误，请检查输入");
}

选型建议

• Spring 项目： 无脑选 Jackson，集成度最高。
• 追求极致性能： 考虑 Fastjson，但务必做好安全加固。
• 轻量级/Android： Gson 依然是不错的选择。

最后提醒一点，无论选哪个库，都要保持版本更新，特别是涉及安全补丁的部分。对于复杂的 JSON 处理逻辑，提前进行 JMH 基准测试，确保不会成为系统瓶颈。