Selepas membandingkan ketiga-tiga, saya mendapati bahawa perpustakaan JSON ini adalah yang terbaik untuk digunakan.

Artikel ini menggunakan JMH untuk menguji prestasi beberapa pustaka penghuraian JSON biasa di Jawa. Setiap kali saya melihat orang lain di Internet mengatakan betapa baiknya prestasi perpustakaan tertentu, menghancurkan perpustakaan lain. Tetapi melihat adalah lebih baik daripada mendengar Hanya apa yang telah anda uji sendiri adalah yang paling boleh dipercayai. JSON ialah format penghantaran data yang sangat biasa dalam pembangunan web dan pembangunan pelayan Secara umumnya, kami tidak perlu terlalu mengambil berat tentang prestasi pembinaan penghuraian JSON, melainkan ia adalah sistem yang mempunyai prestasi yang agak tinggi. keperluan.

Pada masa ini terdapat banyak perpustakaan kelas

JSON

untuk Java Di bawah kami mengambil 4 perpustakaan JSON yang biasa digunakan untuk ujian dan perbandingan pada masa yang sama, berdasarkan keputusan ujian, kami menganalisis cara memilih yang paling banyak perpustakaan JSON yang sesuai mengikut senario aplikasi sebenar. Empat perpustakaan JSON ialah:

Gson

, FastJson, Jackson, Json-lib.

Pengenalan ringkas

Pilih perpustakaan JSON yang sesuai untuk dipertimbangkan dari banyak aspek:

• Penghuraian rentetan ke dalam prestasi JSON

• penghuraian dalam prestasi Java

• Pembinaan JavaBean Prestasi JSON

• Pembinaan koleksi Prestasi JSON

• kemudahan penggunaan

Pertama, mari kita perkenalkan secara ringkas latar belakang identiti empat perpustakaan kelas.

Gson

Alamat projek: https://github.com/google/gson

Gson ialah artifak penghuraian Json yang paling serba boleh untuk memenuhi keperluan dalaman Google pada asalnya . Ia dibangunkan oleh Google sendiri, tetapi telah digunakan oleh banyak syarikat atau pengguna sejak versi pertama dikeluarkan secara terbuka pada Mei 2008.

Aplikasi Gson terutamanya merangkumi dua fungsi penukaran: toJson dan fromJson Ia tidak mempunyai kebergantungan, tidak memerlukan balang tambahan dan boleh dijalankan terus pada JDK.

Sebelum menggunakan penukaran objek jenis ini, anda perlu mencipta jenis objek dan ahlinya sebelum anda berjaya menukar rentetan JSON kepada objek yang sepadan. Selagi terdapat kaedah get dan set dalam kelas, Gson boleh menukar sepenuhnya jenis json yang kompleks kepada bean atau bean kepada json Ia adalah artifak penghuraian JSON.

FastJson

Alamat projek: https://github.com/alibaba/fastjson

Fastjson ialah pemproses JSON berprestasi tinggi yang dibangunkan dalam bahasa Java. Tiada kebergantungan, tidak perlu balang tambahan, dan boleh dijalankan terus pada JDK.

FastJson akan menghadapi beberapa masalah apabila menukar jenis kacang kompleks kepada Json mungkin muncul, menyebabkan ralat penukaran Json dan rujukan perlu dinyatakan. FastJson menggunakan algoritma asal untuk meningkatkan kelajuan parse ke tahap yang melampau, mengatasi semua perpustakaan json.

Jackson

Alamat projek: https://github.com/FasterXML/jackson

Jackson kini merupakan rangka kerja sumber terbuka Java yang digunakan secara meluas untuk mensiri dan menyahsiri json.

Komuniti Jackson agak aktif dan kelajuan kemas kini agak pantas Menurut statistik dalam Github, Jackson ialah salah satu penghurai json yang paling popular.

Jackson mempunyai banyak kelebihan:

• Jackson bergantung pada pakej balang yang lebih sedikit dan ringkas dan mudah digunakan.

• Berbanding dengan rangka kerja Java json yang lain seperti Gson, Jackson menghuraikan fail json yang besar dengan lebih pantas.

• Jackson menggunakan lebih sedikit memori semasa berlari dan mempunyai prestasi yang lebih baik

• Jackson mempunyai API fleksibel yang boleh dipanjangkan dan disesuaikan dengan mudah. . JsonGenerator. Pelaksanaan dalaman Jackson menggunakan JsonGenerator API penstriman berprestasi tinggi dan JsonParser untuk menjana dan menghuraikan json. Pakej anotasi anotasi jackson-jackson, menyediakan fungsi anotasi standard; API berkaitan (JsonNode); API berdasarkan penghuraian "pengikatan objek" dan penghuraian "model pokok" bergantung pada API berdasarkan penghuraian "mod strim".

Json-lib

Alamat projek: http://json-lib.sourceforge.net/index.html

json-lib ialah alat parsing yang paling awal dan paling meluas digunakan kelemahan json-lib sememangnya ia bergantung pada banyak pakej pihak ketiga Untuk penukaran jenis kompleks, json-lib masih mempunyai kecacatan dalam menukar json menjadi kacang Sebagai contoh, dalam satu kelas, akan ada senarai atau peta koleksi kelas lain, json -lib akan menyebabkan masalah apabila menukar dari json ke kacang. json-lib tidak dapat memenuhi keperluan Internet semasa dari segi fungsi dan prestasi.

Menulis ujian prestasi

Seterusnya, mula menulis kod ujian prestasi untuk empat perpustakaan ini.

Tambah kebergantungan maven

Sudah tentu, langkah pertama ialah menambah kebergantungan maven bagi empat perpustakaan Untuk bersikap adil, saya menggunakan semua versi terbaharu mereka:

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

kelas alat. empat perpustakaan

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

Atas ialah kandungan terperinci Selepas membandingkan ketiga-tiga, saya mendapati bahawa perpustakaan JSON ini adalah yang terbaik untuk digunakan.. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!