Un guide de FastJson

1. Vue d'ensemble

FastJson est une bibliothèque Java légère utilisée pour convertir efficacement des chaînes JSON en objets Java et vice versa.

Dans cet article, nous allons nous plonger dans plusieurs applications concrètes et pratiques de la bibliothèque FastJson.

2. Configuration Maven

Pour commencer à travailler avec FastJson, nous devons d'abord l'ajouter à notre pom.xml :

 com.alibaba fastjson 1.2.13  

Et en guise de note rapide, voici la version la plus récente de la bibliothèque sur Maven Central.

3. Convertir les objets Java au format JSON

Définissons le bean Java Person suivant :

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 }

Nous pouvons utiliser JSON.toJSONString () pour convertir un objet Java en une chaîne JSON:

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

Et voici le résultat:

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

Nous pouvons également aller plus loin et commencer à personnaliser la sortie et contrôler des éléments tels que la commande , le formatage de la date ou les indicateurs de sérialisation .

Par exemple - mettons à jour le bean et ajoutons quelques champs supplémentaires:

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

Voici une liste des paramètres les plus basiques que nous pouvons utiliser avec l' annotation @JSONField , afin de personnaliser le processus de conversion:

  • Le format du paramètre est utilisé pour formater correctement l' attribut de date
  • Par défaut, la bibliothèque FastJson sérialise entièrement le bean Java, mais nous pouvons utiliser le paramètre serialize pour ignorer la sérialisation pour des champs spécifiques
  • Le paramètre ordinal est utilisé pour spécifier l'ordre des champs

Et voici la nouvelle sortie:

[ { "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 prend également en charge une fonctionnalité de sérialisation BeanToArray très intéressante :

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

Voici à quoi ressemblera la sortie dans ce cas:

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

4. Créer des objets JSON

Comme d'autres bibliothèques JSON, créer un objet JSON à partir de zéro est assez simple, il ne s'agit que de combiner des objets JSONObject et JSONArray :

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

Et voici à quoi ressemblera la sortie ici:

[ { "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. Analyser les chaînes JSON en objets Java

Maintenant que nous savons comment créer un objet JSON à partir de zéro et comment convertir des objets Java en leurs représentations JSON, mettons l'accent sur la façon d'analyser une représentation 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()); }

Nous pouvons utiliser JSON.parseObject () pour obtenir un objet Java à partir d'une chaîne JSON.

Notez que vous devez définir un constructeur no-args ou par défaut si vous avez déjà déclaré votre propre constructeur paramétré, sinon une exception com.alibaba.fastjson.JSONException sera lancée.

Voici le résultat de ce test simple:

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

En utilisant l'option désérialiser dans l' annotation @JSONField , nous pouvons ignorer la désérialisation pour un champ spécifique, dans ce cas, la valeur par défaut s'appliquera automatiquement au champ ignoré:

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

Et voici l'objet nouvellement créé:

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

6. Configurer la conversion JSON à l'aide de ContextValueFilter

Dans certains scénarios, nous pouvons avoir besoin d'avoir plus de contrôle sur le processus de conversion des objets Java au format JSON.

Dans ce cas, nous pouvons utiliser l' objet ContextValueFilter pour appliquer un filtrage supplémentaire et un traitement personnalisé au flux de conversion:

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

Dans cet exemple, nous avons masqué le champ DATE DE NAISSANCE , en forçant une valeur constante, nous avons également ignoré tous les champs qui ne sont pas John ou Doe:

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

Comme vous pouvez le voir, il s'agit d'un exemple assez basique, mais vous pouvez bien sûr utiliser les mêmes concepts pour des scénarios plus complexes, en combinant ces outils puissants et légers proposés par FastJson dans un projet réel.

7. Utilisation de NameFilter et SerializeConfig

FastJson propose un ensemble d'outils pour personnaliser vos opérations JSON lorsque vous traitez avec des objets arbitraires - des objets dont nous n'avons pas le code source.

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.