Why Creating a New ObjectMapper Slows Your SpringBoot App – Up to 300× Faster with a Singleton

In a SpringBoot project, converting between objects and JSON strings often involves creating a new ObjectMapper instance for each operation, which looks harmless but can severely degrade performance.

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

Although functional, this pattern is considered a performance anti‑pattern by developers focused on efficiency.

A benchmark is a scientific method for measuring performance; JMH is a tool for building, running, and analyzing nanosecond‑level benchmarks for Java and JVM languages.

@BenchmarkMode(Mode.Throughput)
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Thread)
@Fork(1)
@Warmup(iterations = 5, time = 1)
@Measurement(iterations = 3, time = 1)
public class JsonJMHTest {
    String json = "{\"id\":122345667,\"email\":\"[email protected]\",\"price\":12.25}";
    UserEntity userEntity = new UserEntity(13345L, "[email protected]", BigDecimal.valueOf(12.25));

    @Benchmark
    public UserEntity objectMapper2ObjTest() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.readValue(json, UserEntity.class);
    }

    @Benchmark
    public String objectMapper2StringTest() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.writeValueAsString(userEntity);
    }

    public static void main(String[] args) throws RunnerException {
        Options opt = new OptionsBuilder()
                .include(JsonJMHTest.class.getSimpleName())
                .build();
        new Runner(opt).run();
    }
}

Test environment:

# JMH version: 1.36
# VM version: JDK 17.0.3, OpenJDK 64‑Bit Server VM, 17.0.3+7‑LTS
# Mac AppleM1/16GB

Results show that creating a new ObjectMapper yields about 230 000 reads per second and only 27 000 writes per second.

To improve performance, a singleton pattern is introduced.

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

@Benchmark
public UserEntity singleten2ObjTest() throws JsonProcessingException {
    ObjectMapper objectMapper = ObjectMapperInstance.INSTANCE.getObjectMapper();
    return objectMapper.readValue(json, UserEntity.class);
}

@Benchmark
public String singleten2StringTest() throws JsonProcessingException {
    ObjectMapper objectMapper = ObjectMapperInstance.INSTANCE.getObjectMapper();
    return objectMapper.writeValueAsString(userEntity);
}

Benchmarking the singleton version shows roughly 4.2 million reads per second (18× faster) and 8.3 million writes per second (about 300× faster).

Further, custom serialization can be added to the singleton to handle Long and BigDecimal as strings, preventing precision loss on the front end.

@Getter
public enum ObjectMapperInstance {
    INSTANCE;
    private final ObjectMapper objectMapper;
    ObjectMapperInstance() {
        objectMapper = new ObjectMapper();
        initialize();
    }
    private void initialize() {
        CustomJsonModule customJsonModule = new CustomJsonModule();
        objectMapper.registerModule(customJsonModule);
    }
}

A subsequent JMH test indicates that registering custom converters adds a modest overhead, which is negligible for most business scenarios.

Conclusion: Using a singleton ObjectMapper in SpringBoot dramatically improves JSON conversion performance—up to 18× faster for deserialization and up to 300× faster for serialization—while still allowing custom configuration when needed.