Java 项目-jckson序列化工具

一、基本解析

[二、封装 ObjectMapper，全局单例](#二、封装 ObjectMapper，全局单例)

[三、ObjectMapper 核心底层原理](#三、ObjectMapper 核心底层原理)

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

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

[四、为什么使用单例的 ObjectMapper](#四、为什么使用单例的 ObjectMapper)

[1.Object Mapper 创建成本极高](#1.Object Mapper 创建成本极高)

2.线程安全

[五、统一异常处理，屏蔽底层的 Jackson 异常](#五、统一异常处理，屏蔽底层的 Jackson 异常)

一、基本解析

这是基于 jackson 封装的 JSON 序列化/反序列化的工具，适用于项目内部的统一处理JSON，把对象转JSON字符串、JSON字符串转回Java对象、JSON转List集合的工具类。

二、封装 ObjectMapper，全局单例

ObjectMapper 是 Jackson 库的核心工具类，也是 SpringBoot 默认集成的JSON 解析器。

核心功能：

序列化：Java 对象 -> JSON 字符串
反序列化：JSON 字符串 -> Java对象

java 复制代码

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

java 复制代码

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