Java 处理 JSON 编程实用技巧

Java 处理 JSON 编程实用技巧 | 极客日志

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

// 创建 Gson 实例
Gson gson = new Gson();
// Java 对象转 JSON 字符串
User user = new User("张三", 25);
String json = gson.toJson(user);
System.out.println(json); // {"name":"张三","age":25}
// JSON 字符串转 Java 对象
String jsonString = "{\"name\":\"李四\",\"age\":30}";
User parsedUser = gson.fromJson(jsonString, User.class);
System.out.println(parsedUser.getName()); // 李四

// 序列化集合
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);

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

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

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

// 使用 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 gson = new Gson();
JsonReader reader = new JsonReader(new StringReader(jsonString));
reader.setLenient(true);
JsonElement jsonElement = gson.fromJson(reader, JsonElement.class);

<!-- 核心依赖 -->
<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>

// 创建 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);

// 序列化集合
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>>() {}
);

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

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

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 方法...
}

// 使用 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();
    }
}

// 创建树模型
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);

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

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

// 序列化集合
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");

// 配置序列化特性
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 值
);

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

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 方法...
}

// 创建 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");
}

// 禁用 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);

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

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

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

// 示例：创建统一的 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);
        }
    }
}

// 优雅处理 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 格式");
}

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

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

Java 处理 JSON 编程实用技巧

1. 前言

2. JSON 处理框架对比

3. Gson 使用技巧

3.1 基础用法

3.1.1 Maven 依赖

3.1.2 基本序列化与反序列化

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

3.2 高级特性

3.2.1 GsonBuilder 配置

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

3.2.3 使用注解控制序列化

3.2.4 处理复杂嵌套对象

4. Jackson 使用技巧

4.1 基础用法

4.1.1 Maven 依赖

4.1.2 基本序列化与反序列化

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

4.2 高级特性

4.2.1 ObjectMapper 配置

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

4.2.3 使用注解控制序列化

4.2.4 处理复杂 JSON 结构

4.2.5 使用树模型

5. Fastjson 使用技巧

5.1 基础用法

5.1.1 Maven 依赖

5.1.2 基本序列化与反序列化

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

5.2 高级特性

5.2.1 SerializerFeature 配置

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

5.2.3 使用注解控制序列化

5.2.4 使用 JSONObject 和 JSONArray

5.2.5 安全配置

6. 性能优化技巧

6.1 通用优化原则

6.2 Gson 性能优化

6.3 Jackson 性能优化

6.4 Fastjson 性能优化

7. 最佳实践

7.1 选择合适的框架

7.2 代码组织最佳实践

7.3 错误处理和异常管理

7.4 安全处理

7.5 处理日期时间

8. 常见问题与解决方案

8.1 字段名不匹配

8.2 处理 null 值

8.3 循环引用问题

8.4 处理复杂嵌套结构

8.5 性能问题

9. 总结与建议

选择建议

重要提示

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具