Ein Leitfaden für FastJson

1. Übersicht

FastJson ist eine kompakte Java-Bibliothek, mit der JSON-Zeichenfolgen effektiv in Java-Objekte konvertiert werden und umgekehrt.

In diesem Artikel werden wir uns mit mehreren konkreten und praktischen Anwendungen der FastJson-Bibliothek befassen.

2. Maven-Konfiguration

Um mit FastJson arbeiten zu können, müssen wir dies zunächst zu unserer pom.xml hinzufügen :

 com.alibaba fastjson 1.2.13  

Und als kurze Anmerkung: Hier ist die aktuellste Version der Bibliothek in Maven Central.

3. Konvertieren Sie Java-Objekte in das JSON-Format

Definieren wir die folgende Person Java Bean:

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 }

Wir können JSON.toJSONString () verwenden , um ein Java-Objekt in einen JSON-String zu konvertieren:

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

Und hier ist das Ergebnis:

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

Wir können auch weiter gehen und beginnen , die Ausgabe und Kontrolle Dinge wie Customizing - Bestellung , Datum der Formatierung oder Serialisierung Flags.

Zum Beispiel - aktualisieren wir die Bean und fügen ein paar weitere Felder hinzu:

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

Hier ist eine Liste der grundlegendsten Parameter, die wir zusammen mit der Annotation @JSONField verwenden können , um den Konvertierungsprozess anzupassen:

  • Das Parameter - Format wird verwendet , um das richtig zu formatieren Datum Attribut
  • Standardmäßig serialisiert die FastJson-Bibliothek die Java-Bean vollständig, aber wir können den Parameter serialize verwenden, um die Serialisierung für bestimmte Felder zu ignorieren
  • Die Parameter- Ordnungszahl wird verwendet, um die Feldreihenfolge anzugeben

Und hier ist die neue Ausgabe:

[ { "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 unterstützt auch eine sehr interessante BeanToArray- Serialisierungsfunktion :

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

So sieht die Ausgabe in diesem Fall aus:

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

4. Erstellen Sie JSON-Objekte

Wie bei anderen JSON-Bibliotheken ist das Erstellen eines JSON-Objekts von Grund auf recht einfach. Es geht nur darum, JSONObject- und JSONArray- Objekte zu kombinieren :

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

Und so sieht die Ausgabe hier aus:

[ { "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. Analysieren Sie JSON-Strings in Java-Objekte

Nachdem wir nun wissen, wie ein JSON-Objekt von Grund auf neu erstellt und Java-Objekte in ihre JSON-Darstellungen konvertiert werden, konzentrieren wir uns darauf, wie eine JSON-Darstellung analysiert wird:

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

Wir können JSON.parseObject () verwenden , um ein Java-Objekt aus einem JSON-String abzurufen .

Beachten Sie, dass Sie einen No-Args- oder Standardkonstruktor definieren müssen, wenn Sie bereits einen eigenen parametrisierten deklariert haben. Andernfalls wird eine com.alibaba.fastjson.JSONException ausgelöst.

Hier ist die Ausgabe dieses einfachen Tests:

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

Mit der Option deserialize in der Annotation @JSONField können wir die Deserialisierung für ein bestimmtes Feld ignorieren. In diesem Fall wird der Standardwert automatisch auf das ignorierte Feld angewendet:

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

Und hier ist das neu erstellte Objekt:

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

6. Konfigurieren Sie die JSON-Konvertierung mit ContextValueFilter

In einigen Szenarien müssen wir möglicherweise mehr Kontrolle über den Konvertierungsprozess von Java-Objekten in das JSON-Format haben.

In diesem Fall können wir das ContextValueFilter- Objekt verwenden, um zusätzliche Filterung und benutzerdefinierte Verarbeitung auf den Konvertierungsfluss anzuwenden:

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

In diesem Beispiel haben wir das Feld DATE OF BIRTH ausgeblendet , indem wir einen konstanten Wert erzwungen haben. Außerdem haben wir alle Felder ignoriert, die nicht John oder Doe sind:

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

Wie Sie sehen, ist dies ein ziemlich einfaches Beispiel, aber Sie können dieselben Konzepte natürlich auch für komplexere Szenarien verwenden - indem Sie diese leistungsstarken und leichten Tools von FastJson in einem realen Projekt kombinieren.

7. Verwenden von NameFilter und SerializeConfig

FastJson bietet eine Reihe von Tools, mit denen Sie Ihre JSON-Operationen anpassen können, wenn Sie mit beliebigen Objekten arbeiten - Objekten, deren Quellcode wir nicht haben.

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.