Performance Benchmark of Common Java JSON Libraries Using JMH

This article uses JMH to benchmark the performance of several common Java JSON parsing libraries. While many online claims praise certain libraries, the author conducts hands‑on tests to provide reliable data.

JSON is a ubiquitous data‑exchange format in both web and server development. Performance concerns arise mainly in high‑throughput systems.

The four libraries evaluated are Gson, Fastjson, Jackson, and Json‑lib.

Brief introduction of each library

Gson – developed by Google, no external dependencies, provides toJson/fromJson.

Fastjson – Alibaba's high‑performance JSON processor, also dependency‑free, but has some issues with complex bean conversion.

Jackson – widely used, default JSON mapper in Spring MVC, modular architecture (core, annotations, databind).

Json‑lib – older library with many third‑party dependencies and limited support for complex types.

Maven dependencies

<!-- Json libs-->
<dependency>
    <groupId>net.sf.json-lib</groupId>
    <artifactId>json-lib</artifactId>
    <version>2.4</version>
    <classifier>jdk15</classifier>
</dependency>
<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.2</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.46</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.4</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.4</version>
</dependency>

Utility classes for each library

public class FastJsonUtil {
    public static String bean2Json(Object obj) {
        return JSON.toJSONString(obj);
    }
    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
        return JSON.parseObject(jsonStr, objClass);
    }
}

public class GsonUtil {
    private static Gson gson = new GsonBuilder().create();
    public static String bean2Json(Object obj) {
        return gson.toJson(obj);
    }
    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
        return gson.fromJson(jsonStr, objClass);
    }
    public static String jsonFormatter(String uglyJsonStr) {
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        JsonParser jp = new JsonParser();
        JsonElement je = jp.parse(uglyJsonStr);
        return gson.toJson(je);
    }
}

public class JacksonUtil {
    private static ObjectMapper mapper = new ObjectMapper();
    public static String bean2Json(Object obj) {
        try {
            return mapper.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
            return null;
        }
    }
    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
        try {
            return mapper.readValue(jsonStr, objClass);
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        }
    }
}

public class JsonLibUtil {
    public static String bean2Json(Object obj) {
        JSONObject jsonObject = JSONObject.fromObject(obj);
        return jsonObject.toString();
    }
    @SuppressWarnings("unchecked")
    public static <T> T json2Bean(String jsonStr, Class<T> objClass) {
        return (T) JSONObject.toBean(JSONObject.fromObject(jsonStr), objClass);
    }
}

Model classes used in the benchmark

public class Person {
    private String name;
    private FullName fullName;
    private int age;
    private Date birthday;
    private List<String> hobbies;
    private Map<String, String> clothes;
    private List<Person> friends;
    // getters/setters omitted
    @Override
    public String toString() { /* ... */ }
}

public class FullName {
    private String firstName;
    private String middleName;
    private String lastName;
    // constructors, getters/setters, toString omitted
}

Serialization benchmark

@BenchmarkMode(Mode.SingleShotTime)
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Benchmark)
public class JsonSerializeBenchmark {
    @Param({"1000","10000","100000"})
    private int count;
    private Person p;
    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
                .include(JsonSerializeBenchmark.class.getSimpleName())
                .forks(1)
                .warmupIterations(0)
                .build();
        Collection<RunResult> results = new Runner(opt).run();
        ResultExporter.exportResult("JSON序列化性能", results, "count", "秒");
    }
    @Benchmark public void JsonLib() { for (int i = 0; i < count; i++) JsonLibUtil.bean2Json(p); }
    @Benchmark public void Gson() { for (int i = 0; i < count; i++) GsonUtil.bean2Json(p); }
    @Benchmark public void FastJson() { for (int i = 0; i < count; i++) FastJsonUtil.bean2Json(p); }
    @Benchmark public void Jackson() { for (int i = 0; i < count; i++) JacksonUtil.bean2Json(p); }
    @Setup public void prepare() { /* create Person instance with friends */ }
    @TearDown public void shutdown() {}
}

The results show that for a small number of serializations Gson is fastest, but as the count grows to 100 000 Fastjson overtakes Gson, while Jackson consistently performs well. Json‑lib is dramatically slower.

Deserialization benchmark

@BenchmarkMode(Mode.SingleShotTime)
@OutputTimeUnit(TimeUnit.SECONDS)
@State(Scope.Benchmark)
public class JsonDeserializeBenchmark {
    @Param({"1000","10000","100000"})
    private int count;
    private String jsonStr;
    public static void main(String[] args) throws Exception {
        Options opt = new OptionsBuilder()
                .include(JsonDeserializeBenchmark.class.getSimpleName())
                .forks(1)
                .warmupIterations(0)
                .build();
        Collection<RunResult> results = new Runner(opt).run();
        ResultExporter.exportResult("JSON反序列化性能", results, "count", "秒");
    }
    @Benchmark public void JsonLib() { for (int i = 0; i < count; i++) JsonLibUtil.json2Bean(jsonStr, Person.class); }
    @Benchmark public void Gson() { for (int i = 0; i < count; i++) GsonUtil.json2Bean(jsonStr, Person.class); }
    @Benchmark public void FastJson() { for (int i = 0; i < count; i++) FastJsonUtil.json2Bean(jsonStr, Person.class); }
    @Benchmark public void Jackson() { for (int i = 0; i < count; i++) JacksonUtil.json2Bean(jsonStr, Person.class); }
    @Setup public void prepare() { jsonStr = "{\"name\":\"...\"}"; }
    @TearDown public void shutdown() {}
}

Deserialization results indicate that Gson, Jackson and Fastjson have comparable performance and are all suitable for high‑throughput scenarios, whereas Json‑lib remains far behind.

Conclusion

The benchmark provides concrete data to help developers choose the most appropriate JSON library based on their specific performance requirements.