基于 Jackson 的 JSON 工具类实现解析与设计模式应用

一、项目背景与功能概览

在企业级开发中，JSON 序列化/反序列化是高频操作。本方案基于 Jackson 实现了一个双模式兼容（独立使用 + Spring 整合）、安全可靠的 JSON 工具类，主要提供以下能力：

• ✅ 常用 JSON 转换方法
• ✅ 多态类型安全解析
• ✅ 大数值前端兼容处理
• ✅ 统一时间格式处理
• ✅ Spring 环境无缝整合

二、核心类解析

1. JsonUtils.java（核心工具类）

定位：提供静态方法调用的 JSON 工具门面。

public class JsonUtils {private static ObjectMapper objectMapper = new ObjectMapper();static {objectMapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);// 允许空对象objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false); // 忽略未知字段objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL); // 忽略 null 值objectMapper.registerModules(new JavaTimeModule()); // 解决 LocalDateTime 的序列化}/*** 初始化 objectMapper 属性* <p>* 通过这样的方式，使用 Spring 创建的 ObjectMapper Bean** @param objectMapper ObjectMapper 对象*/public static void init(ObjectMapper objectMapper) {JsonUtils.objectMapper = objectMapper;}@SneakyThrowspublic static String toJsonString(Object object) {return objectMapper.writeValueAsString(object);}@SneakyThrowspublic static byte[] toJsonByte(Object object) {return objectMapper.writeValueAsBytes(object);}@SneakyThrowspublic static String toJsonPrettyString(Object object) {return objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(object);}public static <T> T parseObject(String text, Class<T> clazz) {if (StrUtil.isEmpty(text)) {return null;}try {return objectMapper.readValue(text, clazz);} catch (IOException e) {log.error("json parse err,json:{}", text, e);throw new RuntimeException(e);}}public static <T> T parseObject(String text, String path, Class<T> clazz) {if (StrUtil.isEmpty(text)) {return null;}try {JsonNode treeNode = objectMapper.readTree(text);JsonNode pathNode = treeNode.path(path);return objectMapper.readValue(pathNode.toString(), clazz);} catch (IOException e) {log.error("json parse err,json:{}", text, e);throw new RuntimeException(e);}}public static <T> T parseObject(String text, Type type) {if (StrUtil.isEmpty(text)) {return null;}try {return objectMapper.readValue(text, objectMapper.getTypeFactory().constructType(type));} catch (IOException e) {log.error("json parse err,json:{}", text, e);throw new RuntimeException(e);}}/*** 将字符串解析成指定类型的对象* 使用 {@link #parseObject(String, Class)} 时，在@JsonTypeInfo(use = JsonTypeInfo.Id.CLASS) 的场景下，* 如果 text 没有 class 属性，则会报错。此时，使用这个方法，可以解决。** @param text 字符串* @param clazz 类型* @return 对象*/public static <T> T parseObject2(String text, Class<T> clazz) {if (StrUtil.isEmpty(text)) {return null;}return JSONUtil.toBean(text, clazz);}public static <T> T parseObject(byte[] bytes, Class<T> clazz) {if (ArrayUtil.isEmpty(bytes)) {return null;}try {return objectMapper.readValue(bytes, clazz);} catch (IOException e) {log.error("json parse err,json:{}", bytes, e);throw new RuntimeException(e);}}public static <T> T parseObject(String text, TypeReference<T> typeReference) {try {return objectMapper.readValue(text, typeReference);} catch (IOException e) {log.error("json parse err,json:{}", text, e);throw new RuntimeException(e);}}/*** 解析 JSON 字符串成指定类型的对象，如果解析失败，则返回 null** @param text 字符串* @param typeReference 类型引用* @return 指定类型的对象*/public static <T> T parseObjectQuietly(String text, TypeReference<T> typeReference) {try {return objectMapper.readValue(text, typeReference);} catch (IOException e) {return null;}}public static <T> List<T> parseArray(String text, Class<T> clazz) {if (StrUtil.isEmpty(text)) {return new ArrayList<>();}try {return objectMapper.readValue(text, objectMapper.getTypeFactory().constructCollectionType(List.class, clazz));} catch (IOException e) {log.error("json parse err,json:{}", text, e);throw new RuntimeException(e);}}public static <T> List<T> parseArray(String text, String path, Class<T> clazz) {if (StrUtil.isEmpty(text)) {return null;}try {JsonNode treeNode = objectMapper.readTree(text);JsonNode pathNode = treeNode.path(path);return objectMapper.readValue(pathNode.toString(), objectMapper.getTypeFactory().constructCollectionType(List.class, clazz));} catch (IOException e) {log.error("json parse err,json:{}", text, e);throw new RuntimeException(e);}}public static JsonNode parseTree(String text) {try {return objectMapper.readTree(text);} catch (IOException e) {log.error("json parse err,json:{}", text, e);throw new RuntimeException(e);}}public static JsonNode parseTree(byte[] text) {try {return objectMapper.readTree(text);} catch (IOException e) {log.error("json parse err,json:{}", text, e);throw new RuntimeException(e);}}public static boolean isJson(String text) {return JSONUtil.isTypeJSON(text);}/*** 判断字符串是否为 JSON 类型的字符串* @param str 字符串*/public static boolean isJsonObject(String str) {return JSONUtil.isTypeJSONObject(str);}}

特性：

• 防御性校验：使用 StrUtil.isEmpty 防御空指针
• 异常统一处理：捕获 IOException 后记录完整日志并抛出运行时异常
• 多解析策略：支持路径解析（parseObject(text, path, clazz)）、静默解析（parseObjectQuietly）

2. DyhJacksonAutoConfiguration.java（Spring 集成）

定位：Spring Boot 自动配置类，实现 ObjectMapper 的自定义配置。

@AutoConfiguration
@Slf4j
public class DyhJacksonAutoConfiguration {@Bean@SuppressWarnings("InstantiationOfUtilityClass")public JsonUtils jsonUtils(List<ObjectMapper> objectMappers) {// 1.1 创建 SimpleModule 对象SimpleModule simpleModule = new SimpleModule();simpleModule// 新增 Long 类型序列化规则，数值超过 2^53-1，在 JS 会出现精度丢失问题，因此 Long 自动序列化为字符串类型.addSerializer(Long.class, NumberSerializer.INSTANCE).addSerializer(Long.TYPE, NumberSerializer.INSTANCE).addSerializer(LocalDate.class, LocalDateSerializer.INSTANCE).addDeserializer(LocalDate.class, LocalDateDeserializer.INSTANCE).addSerializer(LocalTime.class, LocalTimeSerializer.INSTANCE).addDeserializer(LocalTime.class, LocalTimeDeserializer.INSTANCE)// 新增 LocalDateTime 序列化、反序列化规则，使用 Long 时间戳.addSerializer(LocalDateTime.class, TimestampLocalDateTimeSerializer.INSTANCE).addDeserializer(LocalDateTime.class, TimestampLocalDateTimeDeserializer.INSTANCE);// 1.2 注册到 objectMapperobjectMappers.forEach(objectMapper -> objectMapper.registerModule(simpleModule));// 2. 设置 objectMapper 到 JsonUtilsJsonUtils.init(CollUtil.getFirst(objectMappers));log.info("[init][初始化 JsonUtils 成功]");return new JsonUtils();}}

关键点：

• 自动收集机制：通过 List 参数获取 Spring 容器中所有 ObjectMapper 实例
• 模块化配置：使用 SimpleModule 统一管理自定义序列化规则

3. 自定义序列化器

(1) NumberSerializer.java

解决的问题：JavaScript 的 Number 类型精度限制（2^53-1）。

/*** Long 序列化规则** 会将超长 long 值转换为 string，解决前端 JavaScript 最大安全整数是 2^53-1 的问题** @author dyh*/
@JacksonStdImpl
public class NumberSerializer extends com.fasterxml.jackson.databind.ser.std.NumberSerializer {private static final long MAX_SAFE_INTEGER = 9007199254740991L;private static final long MIN_SAFE_INTEGER = -9007199254740991L;public static final NumberSerializer INSTANCE = new NumberSerializer(Number.class);public NumberSerializer(Class<? extends Number> rawType) {super(rawType);}@Overridepublic void serialize(Number value, JsonGenerator gen, SerializerProvider serializers) throws IOException {// 超出范围 序列化位字符串if (value.longValue() > MIN_SAFE_INTEGER && value.longValue() < MAX_SAFE_INTEGER) {super.serialize(value, gen, serializers);} else {gen.writeString(value.toString());}}
}

(2) TimestampLocalDateTimeSerializer.java

/*** 基于时间戳的 LocalDateTime 序列化器** @author dyh*/
public class TimestampLocalDateTimeSerializer extends JsonSerializer<LocalDateTime> {public static final TimestampLocalDateTimeSerializer INSTANCE = new TimestampLocalDateTimeSerializer();@Overridepublic void serialize(LocalDateTime value, JsonGenerator gen, SerializerProvider serializers) throws IOException {// 将 LocalDateTime 对象，转换为 Long 时间戳gen.writeNumber(value.atZone(ZoneId.systemDefault()).toInstant().toEpochMilli());}}

三、设计模式应用

1. 单例模式 (Singleton)

• 应用场景：自定义序列化器实例共享

• 代码示例：

  public class NumberSerializer extends com.fasterxml.jackson.databind.ser.std.NumberSerializer {public static final NumberSerializer INSTANCE = new NumberSerializer(Number.class);
  }
  

2. 工厂方法模式 (Factory Method)

• 应用场景：ObjectMapper 的创建与配置
• 体现形式：
  • JsonUtils 静态初始化块中创建基础配置的 ObjectMapper
  • Spring 通过 @Bean 工厂方法创建并配置 ObjectMapper

3. 模板方法模式 (Template Method)

• 应用场景：JSON 解析的统一异常处理流程

• 代码体现：

    
  public static <T> T parseObject(String text, Class<T> clazz) {  try {  return objectMapper.readValue(...);  } catch (IOException e) {  log.error(...); // 统一日志记录  throw new RuntimeException(e); // 统一异常转换  }  
  }  

四、使用示例

1. 基础序列化

  
User user = new User(1L, "yudaoyuanma", LocalDateTime.now());  
String json = JsonUtils.toJsonString(user);  
// 输出：{"id":"1","name":"yudaoyuanma","createTime":1672502400000}  

2. 复杂解析

  
// 解析嵌套 JSON  
String json = "{\"data\":{\"user\":{\"name\":\"test\"}}}";  
User user = JsonUtils.parseObject(json, "data.user", User.class);  // 静默解析（不抛异常）  
TypeReference<ResultDTO<User>> typeRef = new TypeReference<>() {};  
ResultDTO<User> result = JsonUtils.parseObjectQuietly(json, typeRef);