public class JacksonUtil {

    private JacksonUtil() {}

    private static final ObjectMapper OBJECT_MAPPER;
    static {
        OBJECT_MAPPER = new ObjectMapper();
    }
}

三、ObjectMapper 核心底层原理

3.1 序列化原理(writerValueAsString)
方法执行流程：

ObjectMapper 拿到 Java 对象
通过反射读取对象所有字段、getter 方法
根据字段类型，转换为对应的 JSON 数据类型 (字符串、数字、布尔、数组、对象)
拼接成标准的 JSON 字符串返回
完全基于反射实现

3.2 反序列化原理(readValue)
方法执行流程：

解析 JSON 字符串，构建语法树
通过反射创建目标 Java 对象实例
遍历 JSON 字段，通过 set 方法为对象赋值
返回完整 Java 对象

四、为什么使用单例的 ObjectMapper

1.Object Mapper 创建成本极高

Object Mapper 内部包含大量：序列化器缓存、反序列化缓存、类型工厂、注解解析器、配置信息
每次 new ObjectMapper() 都会重新加载所有配置、初始化缓存，非常消耗性能。

2.线程安全

ObjectMapper 是线程安全的，全局只创建一个实例，多线程并发调用序列化、反序列化完全安全，所以项目中必须单例复用

五、统一异常处理，屏蔽底层的 Jackson 异常

捕获 Jackson 原生 JacksonException，包装成 Spring 的 JsonParseException 向外抛出
非 JSON 解析异常包装为 IllegalStateException

package com.example.lotterysystem.common.utils;

import org.springframework.boot.json.JsonParseException;
import org.springframework.util.ReflectionUtils;
import tools.jackson.core.JacksonException;
import tools.jackson.databind.JavaType;
import tools.jackson.databind.ObjectMapper;

import java.util.List;
import java.util.concurrent.Callable;

public class JacksonUtil {
    private JacksonUtil() {}
    private static final ObjectMapper OBJECT_MAPPER;
    static {
        OBJECT_MAPPER = new ObjectMapper();
    }

    private static ObjectMapper getObjectMapper() {
        return OBJECT_MAPPER;
    }


    private static  <T> T tryParse(Callable<T> parser) {
        return tryParse(parser, JacksonException.class);
    }

    private static  <T> T tryParse(Callable<T> parser, Class<? extends Exception> check) {
        try {
            return parser.call();
        }
        catch (Exception ex) {
            if (check.isAssignableFrom(ex.getClass())) {
                throw new JsonParseException(ex);
            }
            throw new IllegalStateException(ex);
        }
    }

    /**
     * 序列化方法
     * @param object
     * @return
     */
    public static String writerValueAsString(Object object) {
        return JacksonUtil.tryParse(() -> {
            return JacksonUtil.getObjectMapper().writeValueAsString(object);
        });
    }

    /**
     * 反序列化方法
     * @param str
     * @param type
     * @return
     * @param <T>
     */
    public static <T> T readValue(String str, Class<T> type) {
        return JacksonUtil.tryParse(() -> {
            return JacksonUtil.getObjectMapper().readValue(str, type);
        });
    }

    /**
     * 反序列化List
     */
    public static <T> T readListValue(String context, Class<?> paramClasses) {
        JavaType javaType = JacksonUtil.getObjectMapper().getTypeFactory()
                .constructParametricType(List.class, paramClasses);
        return JacksonUtil.tryParse(() -> {
            return JacksonUtil.getObjectMapper().readValue(context, javaType);
        });
    }
}

标签

#java #开发语言