Panduan untuk FastJson

1. Gambaran keseluruhan

FastJson adalah perpustakaan Java ringan yang digunakan untuk menukar rentetan JSON dengan berkesan ke objek Java dan sebaliknya.

Dalam artikel ini kita akan menyelami beberapa aplikasi konkrit dan praktikal dari perpustakaan FastJson.

2. Konfigurasi Maven

Untuk mula bekerja dengan FastJson, pertama kami perlu menambahkannya ke pom.xml kami :

 com.alibaba fastjson 1.2.13  

Dan sebagai catatan ringkas - inilah versi perpustakaan yang paling terkini di Maven Central.

3. Tukarkan Objek Java ke Format JSON

Mari kita tentukan kacang Java Orang berikut :

public class Person { @JSONField(name = "AGE") private int age; @JSONField(name = "FULL NAME") private String fullName; @JSONField(name = "DATE OF BIRTH") private Date dateOfBirth; public Person(int age, String fullName, Date dateOfBirth) { super(); this.age = age; this.fullName= fullName; this.dateOfBirth = dateOfBirth; } // standard getters & setters }

Kita dapat menggunakan JSON.toJSONString () untuk menukar objek Java ke JSON String:

private List listOfPersons = new ArrayList(); @Before public void setUp() { listOfPersons.add(new Person(15, "John Doe", new Date())); listOfPersons.add(new Person(20, "Janette Doe", new Date())); } @Test public void whenJavaList_thanConvertToJsonCorrect() { String jsonOutput= JSON.toJSONString(listOfPersons); }

Dan inilah hasilnya:

[ { "AGE":15, "DATE OF BIRTH":1468962431394, "FULL NAME":"John Doe" }, { "AGE":20, "DATE OF BIRTH":1468962431394, "FULL NAME":"Janette Doe" } ]

Kami juga dapat melangkah lebih jauh dan mula menyesuaikan output dan mengawal perkara seperti pesanan , pemformatan tarikh , atau bendera siri .

Contohnya - mari kita kemas kini kacang dan tambahkan beberapa bidang lagi:

@JSONField(name="AGE", serialize=false) private int age; @JSONField(name="LAST NAME", ordinal = 2) private String lastName; @JSONField(name="FIRST NAME", ordinal = 1) private String firstName; @JSONField(name="DATE OF BIRTH", format="dd/MM/yyyy", ordinal = 3) private Date dateOfBirth;

Berikut adalah senarai parameter paling asas yang dapat kami gunakan bersama anotasi @JSONField , untuk menyesuaikan proses penukaran:

  • Format parameter digunakan untuk memformat atribut tarikh dengan betul
  • Secara lalai, perpustakaan FastJson membuat siri Java bean sepenuhnya, tetapi kita dapat menggunakan parameter serialize untuk mengabaikan serialisasi untuk bidang tertentu
  • Parameter ordinal digunakan untuk menentukan perintah medan yang

Dan inilah keluaran baru:

[ { "FIRST NAME":"Doe", "LAST NAME":"Jhon", "DATE OF BIRTH":"19/07/2016" }, { "FIRST NAME":"Doe", "LAST NAME":"Janette", "DATE OF BIRTH":"19/07/2016" } ]

FastJson juga menyokong ciri bersiri BeanToArray yang sangat menarik :

String jsonOutput= JSON.toJSONString(listOfPersons, SerializerFeature.BeanToArray);

Inilah outputnya dalam kes ini:

[ [ 15, 1469003271063, "John Doe" ], [ 20, 1469003271063, "Janette Doe" ] ]

4. Buat Objek JSON

Seperti perpustakaan JSON lain, mewujudkan objek JSON dari awal adalah mudah cukup, ia hanya suatu perkara yang menggabungkan JSONObject dan JSONArray objek:

@Test public void whenGenerateJson_thanGenerationCorrect() throws ParseException { JSONArray jsonArray = new JSONArray(); for (int i = 0; i < 2; i++) { JSONObject jsonObject = new JSONObject(); jsonObject.put("AGE", 10); jsonObject.put("FULL NAME", "Doe " + i); jsonObject.put("DATE OF BIRTH", "2016/12/12 12:12:12"); jsonArray.add(jsonObject); } String jsonOutput = jsonArray.toJSONString(); }

Dan inilah hasilnya seperti di sini:

[ { "AGE":"10", "DATE OF BIRTH":"2016/12/12 12:12:12", "FULL NAME":"Doe 0" }, { "AGE":"10", "DATE OF BIRTH":"2016/12/12 12:12:12", "FULL NAME":"Doe 1" } ]

5. Huraikan JSON Rentetan ke Objek Java

Sekarang kita tahu bagaimana membuat objek JSON dari awal, dan bagaimana mengubah objek Java ke representasi JSON mereka, mari kita fokuskan pada bagaimana menguraikan representasi JSON:

@Test public void whenJson_thanConvertToObjectCorrect() { Person person = new Person(20, "John", "Doe", new Date()); String jsonObject = JSON.toJSONString(person); Person newPerson = JSON.parseObject(jsonObject, Person.class); assertEquals(newPerson.getAge(), 0); // if we set serialize to false assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName()); }

Kita dapat menggunakan JSON.parseObject () untuk mendapatkan objek Java dari JSON String.

Perhatikan bahawa anda harus menentukan konstruktor tanpa argumen atau lalai jika anda sudah menyatakannya sebagai parametrized anda sendiri, jika tidak, com.alibaba.fastjson.JSONException akan dilemparkan

Inilah hasil ujian mudah ini:

Person [age=20, fullName=John Doe, dateOfBirth=Wed Jul 20 08:51:12 WEST 2016]

Dengan menggunakan pilihan deserialize di dalam anotasi @JSONField , kita dapat mengabaikan deserialisasi untuk bidang tertentu, dalam hal ini, nilai lalai akan berlaku secara automatik pada bidang yang diabaikan:

@JSONField(name = "DATE OF BIRTH", deserialize=false) private Date dateOfBirth;

Dan inilah objek yang baru dibuat:

Person [age=20, fullName=John Doe, dateOfBirth=null]

6. Konfigurasikan Penukaran JSON Menggunakan ContextValueFilter

Dalam beberapa senario, kita mungkin perlu mempunyai lebih banyak kawalan terhadap proses penukaran dari objek Java ke format JSON.

Dalam kes ini kita dapat menggunakan objek ContextValueFilter untuk menerapkan penapisan tambahan dan pemprosesan tersuai pada aliran penukaran:

@Test public void givenContextFilter_whenJavaObject_thanJsonCorrect() { ContextValueFilter valueFilter = new ContextValueFilter () { public Object process( BeanContext context, Object object, String name, Object value) { if (name.equals("DATE OF BIRTH")) { return "NOT TO DISCLOSE"; } if (value.equals("John")) { return ((String) value).toUpperCase(); } else { return null; } } }; String jsonOutput = JSON.toJSONString(listOfPersons, valueFilter); }

Dalam contoh ini, kami menyembunyikan medan DATE OF BIRTH , dengan memaksa nilai tetap, kami juga mengabaikan semua medan yang bukan John atau Doe:

[ { "FULL NAME":"JOHN DOE", "DATE OF BIRTH":"NOT TO DISCLOSE" } ]

Seperti yang anda lihat, ini adalah contoh yang cukup asas, tetapi anda tentu dapat menggunakan konsep yang sama untuk senario yang lebih kompleks juga - menggabungkan sekumpulan alat yang kuat dan ringan ini yang ditawarkan oleh FastJson dalam projek dunia nyata.

7. Menggunakan NameFilter dan SerializeConfig

FastJson menawarkan sekumpulan alat untuk menyesuaikan operasi JSON anda ketika berhadapan dengan objek sewenang-wenang - objek yang tidak memiliki kod sumber.

Let's imagine we have a compiled version of the Person Java bean, initially declared in this article, and we need to make some enhancement on fields naming and basic formatting:

@Test public void givenSerializeConfig_whenJavaObject_thanJsonCorrect() { NameFilter formatName = new NameFilter() { public String process(Object object, String name, Object value) { return name.toLowerCase().replace(" ", "_"); } }; SerializeConfig.getGlobalInstance().addFilter(Person.class, formatName); String jsonOutput = JSON.toJSONStringWithDateFormat(listOfPersons, "yyyy-MM-dd"); }

We've declared the formatName filter using the NameFilteranonymous class to process fields names. The newly created filter is associated to the Person class, and then added to a global instance – which is basically a static attribute in the SerializeConfig class.

Now we can comfortably convert our object to JSON format as shown earlier in this article.

Note that we've used toJSONStringWithDateFormat() instead of toJSONString() to quickly apply the same formatting rule on date fields.

And here's the output:

[ { "full_name":"John Doe", "date_of_birth":"2016-07-21" }, { "full_name":"Janette Doe", "date_of_birth":"2016-07-21" } ]

As you can see – the fields names got changed, and the date value did got properly formatted.

Combining SerializeFilter with ContextValueFiltercan give full control over the conversion process for arbitrary and complex Java objects.

8. Conclusion

In this article we showed how to use FastJson to convert Java beans to JSON strings and how to go the other way around. We also showed how to use some of the core features of FastJson in order to customize the JSON output.

As you can see, the library offers a relatively simple to use but still very powerful API. JSON.toJSONString and JSON.parseObject are all you need to use in order to meet most of your needs – if not all.

You can checkout the examples provided in this article in the linked GitHub project.