SpringBoot中这样用ObjectMapper，才够优雅！

背景

借助ObjectMapper实现map转对象太慢了，如何解决？

步骤

在SpringBoot项目中要实现对象与Json字符串的互转，每次都需要像如下一样new 一个ObjectMapper对象：

public UserEntity string2Obj(String json) throws JsonProcessingException {
 ObjectMapper objectMapper = new ObjectMapper();
 return objectMapper.readValue(json, UserEntity.class);
}

public String obj2String(UserEntity userEntity) throws JsonProcessingException {
 ObjectMapper objectMapper = new ObjectMapper();
 return objectMapper.writeValueAsString(car)
}

这样的代码到处可见，有问题吗？

你要说他有问题吧，确实能正常执行；可你要说没问题吧，在追求性能的同学眼里，这属实算是十恶不赦的代码了。

首先，让我们用JMH对这段代码做一个基准测试，让大家对其性能有个大概的了解。

我们要使用jmh测试几种方式的区别：

1、引入jar包

        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-core</artifactId>
            <version>1.23</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-generator-annprocess  -->
        <dependency>
            <groupId>org.openjdk.jmh</groupId>
            <artifactId>jmh-generator-annprocess</artifactId>
            <version>1.23</version>
        </dependency>

2、

@BenchmarkMode({Mode.Throughput})
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Thread)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)
@Fork(1)
@Threads(10)
public class ObjectMapperTest {
    String json = "{ \"color\" : \"Black\", \"type\" : \"BMW\" }";

    @State(Scope.Benchmark)
    public static class BenchmarkState {
        ObjectMapper GLOBAL_MAP = new ObjectMapper();
        ThreadLocal<ObjectMapper> GLOBAL_MAP_THREAD = new ThreadLocal<>();
    }

    @Benchmark
    public Map globalTest(BenchmarkState state) throws Exception{
        Map map = state.GLOBAL_MAP.readValue(json, Map.class);
        return map;
    }


    @Benchmark
    public Map globalTestThreadLocal(BenchmarkState state) throws Exception{
        if(null == state.GLOBAL_MAP_THREAD.get()){
            state.GLOBAL_MAP_THREAD.set(new ObjectMapper());
        }
        Map map = state.GLOBAL_MAP_THREAD.get().readValue(json, Map.class);
        return map;
    }

    @Benchmark
    public Map localTest() throws Exception{
        ObjectMapper objectMapper = new ObjectMapper();
        Map map = objectMapper.readValue(json, Map.class);
        return map;
    }

    public static void main(String[] args) throws Exception {
        Options opts = new OptionsBuilder()
                .include(ObjectMapperTest.class.getSimpleName())
                .resultFormat(ResultFormatType.CSV)
                .build();

        new Runner(opts).run();
    }
}

结果：

这是一个性能测试的结果，具体是使用JMH（Java Microbenchmark Harness）或其他类似的性能测试工具进行JSON解析（很可能是使用Jackson库的ObjectMapper）的性能测试。以下是每一列的解释：

Benchmark：测试的名称或描述。这里有三个测试：
ObjectMapperTest.globalTest：可能是一个全局的ObjectMapper实例的解析性能测试。
ObjectMapperTest.globalTestThreadLocal：可能是使用ThreadLocal存储的ObjectMapper实例的解析性能测试，这样每个线程都有自己的实例，避免了线程间的竞争。
ObjectMapperTest.localTest：可能是每次解析时都创建新的ObjectMapper实例的性能测试。
Mode：测试的模式。在这里，thrpt代表吞吐量（throughput），即单位时间内完成的操作数。
Cnt：运行的次数或迭代的次数。在这里，每个测试都运行了5次。
Score：测试的平均得分。对于吞吐量测试，这通常表示每秒完成的操作数（ops/s）。
ObjectMapperTest.globalTest的平均得分是6148814.405 ops/s。
ObjectMapperTest.globalTestThreadLocal的平均得分是6584146.770 ops/s。
ObjectMapperTest.localTest的平均得分是447976.202 ops/s。
Error：测试得分的误差范围。这通常表示测试结果的波动或不确定性。
从这些结果中，我们可以得出以下结论：

使用ThreadLocal存储的ObjectMapper实例（globalTestThreadLocal）在性能上稍优于全局的ObjectMapper实例（globalTest）。
每次解析时都创建新的ObjectMapper实例（localTest）的性能远低于前两者。

所以在我们真正使用的时候不要在方法中去new ObjectMapper了，使用单例模式实现上述功能。

在创建工具类时要将工具类设置成单例的，这样不仅可以保证线程安全，也可以保证在系统全局只能创建一个对象，避免频繁创建对象的成本。

所以，我们可以在项目中构建一个ObjectMapper的单例类。

@Getter
public enum ObjectMapperInstance {
    
    INSTANCE;
    
    private final ObjectMapper objectMapper = new ObjectMapper();
    
    ObjectMapperInstance() {
        
    }
}

使用方式：
        ObjectMapper objectMapper = ObjectMapperInstance.INSTANCE.getObjectMapper();
然后进行调用

总结

通过上面的测试，结论已经很清晰了。所以在Spring中如何正确的使用ObjectMapper不用我再说了吧~