Nach dem Vergleich der drei habe ich festgestellt, dass diese JSON-Bibliothek am besten zu verwenden ist.

Dieser Artikel verwendet JMH, um die Leistung mehrerer gängiger JSON-Parsing-Bibliotheken in Java zu testen. Jedes Mal, wenn ich andere im Internet sehe, die sagen, wie gut die Leistung einer bestimmten Bibliothek ist, vernichten sie andere Bibliotheken. Aber Sehen ist besser als Hören. Am vertrauenswürdigsten ist nur, was man selbst getestet hat.

JSON ist ein sehr verbreitetes Datenübertragungsformat sowohl in der Webentwicklung als auch in der Serverentwicklung. Im Allgemeinen müssen wir uns nicht allzu sehr um die Leistung der JSON-Analyse und -Konstruktion kümmern, es sei denn, es handelt sich um ein System mit relativ hoher Leistung Leistungsanforderungen.

Es gibt derzeit viele Open-Source-JSON-Klassenbibliotheken für Java. Im Folgenden analysieren wir die vier am häufigsten verwendeten JSON-Bibliotheken für Leistungstests und Vergleiche entsprechende JSON-Bibliothek entsprechend dem tatsächlichen Anwendungsszenario.

Die vier JSON-Bibliotheken sind: Gson

, FastJson, Jackson, Json-lib.

Eine kurze Einführung

Wählen Sie eine geeignete JSON-Bibliothek aus, die Sie unter vielen Aspekten berücksichtigen möchten:

• String-Parsing in JSON-Leistung

• String-Parsing in JavaBean. Leistung

• JavaBean-Konstruktion JSON-Leistung

• Sammlungsaufbau JSON-Leistung

• Benutzerfreundlichkeit

Lassen Sie uns zunächst kurz den Identitätshintergrund der vier Klassenbibliotheken vorstellen.

Gson

Projektadresse: https://github.com/google/gson

Gson ist derzeit das vielseitigste Json-Parsing-Artefakt. Gson wurde ursprünglich entwickelt, um die internen Anforderungen von Google zu erfüllen Es wurde von Google selbst entwickelt, wird aber seit der Veröffentlichung der ersten Version im Mai 2008 von vielen Unternehmen oder Nutzern verwendet.

Die Anwendung von Gson besteht hauptsächlich aus zwei Konvertierungsfunktionen: toJson und fromJson. Sie weist keine Abhängigkeiten auf und erfordert keine zusätzlichen Jars. Sie kann direkt auf dem JDK ausgeführt werden.

Bevor Sie diese Art der Objektkonvertierung verwenden, müssen Sie den Objekttyp und seine Mitglieder erstellen, bevor Sie den JSON-String erfolgreich in das entsprechende Objekt konvertieren können. Solange die Klasse Get- und Set-Methoden enthält, kann Gson komplexe JSON-Typen vollständig in Beans oder Beans in JSONs konvertieren. Dies ist ein Artefakt der JSON-Analyse.

FastJson

Projektadresse: https://github.com/alibaba/fastjson

Fastjson ist ein in Java geschriebener Hochleistungs-JSON-Prozessor, der von Alibaba entwickelt wurde. Keine Abhängigkeiten, kein Bedarf an zusätzlichen JAR-Dateien und kann direkt auf dem JDK ausgeführt werden.

Bei der Konvertierung komplexer Bean-Typen in Json treten möglicherweise einige Probleme auf. Referenztypen können zu Json-Konvertierungsfehlern führen und Referenzen müssen angegeben werden. FastJson verwendet einen Originalalgorithmus, um die Analysegeschwindigkeit auf das Äußerste zu erhöhen und übertrifft damit alle JSON-Bibliotheken.

Jackson

Projektadresse: https://github.com/FasterXML/jackson

Jackson ist derzeit ein weit verbreitetes Java-Open-Source-Framework zum Serialisieren und Deserialisieren von JSON.

Die Jackson-Community ist relativ aktiv und die Aktualisierungsgeschwindigkeit ist relativ hoch. Laut den Statistiken in Github ist Jackson einer der beliebtesten JSON-Parser. Der Standard-JSON-Parser von Spring MVC ist Jackson.

Jackson hat viele Vorteile:

• Jackson benötigt weniger Glaspackungen und ist einfach und leicht zu verwenden.

• Im Vergleich zu anderen Java-JSON-Frameworks wie Gson analysiert Jackson große JSON-Dateien schneller.

• Jackson benötigt beim Ausführen weniger Speicher und hat eine bessere Leistung

• Jackson verfügt über eine flexible API, die einfach erweitert und angepasst werden kann.

Die neueste Version ist 2.9.4. Jacksons Kernmodul besteht aus drei Teilen:

• Jackson-Core-Kernpaket, das verwandte APIs basierend auf der Analyse im „Stream-Modus“ bereitstellt, einschließlich JsonPaser und JsonGenerator. Jacksons interne Implementierung verwendet JsonGenerator und JsonParser der Hochleistungs-Streaming-API, um JSON zu generieren und zu analysieren.

• jackson-annotations-Annotationspaket, das Standard-Annotationsfunktionen bereitstellt;

• jackson-databind-Datenbindungspaket, das eine zugehörige API (ObjectMapper) und ein „Baummodell“ basierend auf der „Objektbindung“-Analyse bereitstellt. verwandte APIs (JsonNode); APIs, die auf der Analyse von „Objektbindungen“ und „Baummodell“ basieren. APIs basieren auf APIs, die auf der Analyse von „Stream-Modus“ basieren.

Json-lib

Projektadresse: http://json-lib.sourceforge.net/index.html

json-lib ist das früheste und am weitesten verbreitete JSON-Parsing-Tool Der Nachteil von json-lib besteht in der Tat darin, dass es bei der Konvertierung komplexer Typen auf viele Pakete von Drittanbietern angewiesen ist. Json-lib weist beispielsweise Mängel bei der Konvertierung von JSON in Beans auf einer anderen Klasse, json -lib, verursacht Probleme bei der Konvertierung von JSON in Bean. json-lib kann die aktuellen Internetanforderungen hinsichtlich Funktionalität und Leistung nicht erfüllen.

Leistungstests schreiben

Beginnen Sie als Nächstes mit dem Schreiben des Leistungstestcodes für diese vier Bibliotheken.

Maven-Abhängigkeiten hinzufügen

Natürlich besteht der erste Schritt darin, die Maven-Abhängigkeiten der vier Bibliotheken hinzuzufügen. Um fair zu sein, verwende ich alle ihre neuesten Versionen:

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

Die Toolklassen der vier Bibliotheken

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库的基本介绍，希望能对你有所帮助！

Das obige ist der detaillierte Inhalt vonNach dem Vergleich der drei habe ich festgestellt, dass diese JSON-Bibliothek am besten zu verwenden ist.. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!