Après avoir comparé les trois, j'ai trouvé que cette bibliothèque JSON est la meilleure à utiliser.

Cet article utilise JMH pour tester les performances de plusieurs bibliothèques d'analyse JSON courantes en Java. Chaque fois que je vois d'autres sur Internet dire à quel point les performances d'une certaine bibliothèque sont bonnes, écrasant d'autres bibliothèques. Mais mieux vaut voir qu’entendre. Seul ce que vous avez testé vous-même est le plus fiable.

JSON est un format de transmission de données très courant à la fois dans le développement Web et dans le développement de serveurs. De manière générale, nous n'avons pas besoin de trop nous soucier des performances d'analyse et de construction de JSON, à moins qu'il ne s'agisse d'un système avec des performances relativement élevées. exigences de performances.

Il existe actuellement de nombreuses bibliothèques de classes

JSON open source pour Java. Ci-dessous, nous prenons 4 bibliothèques JSON couramment utilisées pour les tests et la comparaison des performances. En même temps, sur la base des résultats des tests, nous analysons comment choisir la plus. bibliothèque JSON appropriée en fonction du scénario d'application réel.

Les quatre bibliothèques JSON sont :

Gson, FastJson, Jackson, Json-lib.

Une brève introduction

Choisissez une bibliothèque JSON appropriée à considérer sous de nombreux aspects :

• Analyse de chaînes dans les performances JSON

• Analyse de chaînes dans les performances JavaBean

• Construction JavaBean Performances JSON

• Construction de collections Performances JSON

• facilité d'utilisation

Tout d’abord, présentons brièvement le contexte identitaire des quatre bibliothèques de classe.

Gson

Adresse du projet : https://github.com/google/gson

Gson est actuellement l'artefact d'analyse Json le plus polyvalent. Gson a été initialement développé pour répondre aux besoins internes de Google. Il a été développé par Google lui-même, mais a été utilisé par de nombreuses entreprises ou utilisateurs depuis la publication de la première version en mai 2008.

L'application de Gson se compose principalement de deux fonctions de conversion : toJson et fromJson. Elle n'a aucune dépendance et ne nécessite aucun jar supplémentaire. Elle peut s'exécuter directement sur le JDK.

Avant d'utiliser ce type de conversion d'objet, vous devez créer le type d'objet et ses membres avant de pouvoir convertir avec succès la chaîne JSON en objet correspondant. Tant qu'il y a des méthodes get et set dans la classe, Gson peut convertir complètement des types complexes de json en bean ou de bean en json. C'est un artefact de l'analyse JSON.

FastJson

Adresse du projet : https://github.com/alibaba/fastjson

Fastjson est un processeur JSON hautes performances écrit en langage Java, développé par Alibaba. Aucune dépendance, pas besoin de fichiers jar supplémentaires et peut s'exécuter directement sur le JDK.

FastJson aura quelques problèmes lors de la conversion de types complexes de beans en Json. Des types de référence peuvent apparaître, provoquant des erreurs de conversion Json, et les références doivent être spécifiées. FastJson utilise un algorithme original pour augmenter la vitesse d'analyse à l'extrême, surpassant toutes les bibliothèques json.

Jackson

Adresse du projet : https://github.com/FasterXML/jackson

Jackson est actuellement un framework open source Java largement utilisé pour sérialiser et désérialiser json.

La communauté Jackson est relativement active et la vitesse de mise à jour est relativement rapide. Selon les statistiques de Github, Jackson est l'un des analyseurs json les plus populaires. L'analyseur json par défaut de Spring MVC est Jackson.

Jackson présente de nombreux avantages :

• Jackson s'appuie sur moins d'emballages de pots et est simple et facile à utiliser.

• Comparé à d'autres frameworks Java json tels que Gson, Jackson analyse les gros fichiers json plus rapidement.

• Jackson prend moins de mémoire lors de l'exécution et offre de meilleures performances

• Jackson dispose d'une API flexible qui peut être facilement étendue et personnalisée.

La dernière version est la 2.9.4. Le module principal de Jackson se compose de trois parties :

• le package principal jackson-core, qui fournit des API associées basées sur l'analyse "mode flux", qui inclut JsonPaser et JsonGenerator. L'implémentation interne de Jackson génère et analyse Json via JsonGenerator et JsonParser de l'API de streaming haute performance.

• package d'annotations jackson-annotations, fournissant des fonctions d'annotation standard ;

• paquet de liaison de données jackson-databind, fournissant une API associée (ObjectMapper) et un "modèle d'arbre" basé sur l'analyse de la "liaison d'objet" Parsing- les API associées (JsonNode) ; les API basées sur l'analyse de « liaison d'objet » et l'analyse de « modèle d'arbre » s'appuient sur des API basées sur l'analyse en « mode flux ».

Json-lib

Adresse du projet : http://json-lib.sourceforge.net/index.html

json-lib est l'outil d'analyse json le plus ancien et le plus largement utilisé. L'inconvénient de json-lib est en effet qu'il s'appuie sur de nombreux packages tiers. Pour la conversion de types complexes, json-lib présente des défauts dans la conversion de json en beans. Par exemple, dans une classe, il y aura une liste ou une collection de cartes. d'une autre classe, json -lib posera des problèmes lors de la conversion de json en bean. json-lib ne peut pas répondre aux besoins actuels d'Internet en termes de fonctionnalités et de performances.

Écrire des tests de performances

Ensuite, commencez à écrire le code de test de performances pour ces quatre bibliothèques.

Ajouter des dépendances maven

Bien sûr, la première étape consiste à ajouter les dépendances maven des quatre bibliothèques. Pour être honnête, j'utilise toutes leurs dernières versions :

<!-- 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>

Les classes d'outils du. quatre bibliothèques

FastJsonUtil .java

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

GsonUtil.java

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

JacksonUtil.java

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

JsonLibUtil.java

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类

这里我写一个简单的Person类，同时属性有Date、List、Map和自定义的类FullName，最大程度模拟真实场景。

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;
    // getter/setter省略
    @Override
    public String toString() {
        StringBuilder str = new StringBuilder("Person [name=" + name + ", fullName=" + fullName + ", age="
                + age + ", birthday=" + birthday + ", hobbies=" + hobbies
                + ", clothes=" + clothes + "]
");
        if (friends != null) {
            str.append("Friends:
");
            for (Person f : friends) {
                str.append("	").append(f);
            }
        }
        return str.toString();
    }

}

---

public class FullName {
    private String firstName;
    private String middleName;
    private String lastName;

    public FullName() {
    }
    public FullName(String firstName, String middleName, String lastName) {
        this.firstName = firstName;
        this.middleName = middleName;
        this.lastName = lastName;
    }
    // 省略getter和setter
    @Override
    public String toString() {
        return "[firstName=" + firstName + ", middleName="
                + middleName + ", lastName=" + lastName + "]";
    }
}

JSON序列化性能基准测试

@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() {
        List<Person> friends=new ArrayList<Person>();
        friends.add(createAPerson("小明",null));
        friends.add(createAPerson("Tony",null));
        friends.add(createAPerson("陈小二",null));
        p=createAPerson("邵同学",friends);
    }

    @TearDown
    public void shutdown() {
    }

    private Person createAPerson(String name,List<Person> friends) {
        Person newPerson=new Person();
        newPerson.setName(name);
        newPerson.setFullName(new FullName("zjj_first", "zjj_middle", "zjj_last"));
        newPerson.setAge(24);
        List<String> hobbies=new ArrayList<String>();
        hobbies.add("篮球");
        hobbies.add("游泳");
        hobbies.add("coding");
        newPerson.setHobbies(hobbies);
        Map<String,String> clothes=new HashMap<String, String>();
        clothes.put("coat", "Nike");
        clothes.put("trousers", "adidas");
        clothes.put("shoes", "安踏");
        newPerson.setClothes(clothes);
        newPerson.setFriends(friends);
        return newPerson;
    }
}

说明一下，上面的代码中

ResultExporter.exportResult("JSON序列化性能", results, "count", "秒");

这个是我自己编写的将性能测试报告数据填充至Echarts图，然后导出png图片的方法。

执行后的结果图：

从上面的测试结果可以看出，序列化次数比较小的时候，Gson性能最好，当不断增加的时候到了100000，Gson明细弱于Jackson和FastJson， 这时候FastJson性能是真的牛，另外还可以看到不管数量少还是多，Jackson一直表现优异。而那个Json-lib简直就是来搞笑的。^_^

JSON反序列化性能基准测试

@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":"邵同学","fullName":{"firstName":"zjj_first","middleName":"zjj_middle","lastName":"zjj_last"},"age":24,"birthday":null,"hobbies":["篮球","游泳","coding"],"clothes":{"shoes":"安踏","trousers":"adidas","coat":"Nike"},"friends":[{"name":"小明","fullName":{"firstName":"xxx_first","middleName":"xxx_middle","lastName":"xxx_last"},"age":24,"birthday":null,"hobbies":["篮球","游泳","coding"],"clothes":{"shoes":"安踏","trousers":"adidas","coat":"Nike"},"friends":null},{"name":"Tony","fullName":{"firstName":"xxx_first","middleName":"xxx_middle","lastName":"xxx_last"},"age":24,"birthday":null,"hobbies":["篮球","游泳","coding"],"clothes":{"shoes":"安踏","trousers":"adidas","coat":"Nike"},"friends":null},{"name":"陈小二","fullName":{"firstName":"xxx_first","middleName":"xxx_middle","lastName":"xxx_last"},"age":24,"birthday":null,"hobbies":["篮球","游泳","coding"],"clothes":{"shoes":"安踏","trousers":"adidas","coat":"Nike"},"friends":null}]}";
    }

    @TearDown
    public void shutdown() {
    }
}

执行后的结果图：

从上面的测试结果可以看出，反序列化的时候，Gson、Jackson和FastJson区别不大，性能都很优异，而那个Json-lib还是来继续搞笑的。

以上就是几种几种主流JSON库的基本介绍，希望能对你有所帮助！

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!