Guide de FastJson

Un guide pour 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 ajouter cela à nospom.xml:


    com.alibaba
    fastjson
    1.2.13

Et en bref -here’s the most updated version de la bibliothèque sur Maven Central.

3. Convertir des objets Java au format JSON

Définissons le bean JavaPerson 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 utiliserJSON.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 les indicateursordering, dateformatting ouserialization.

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 paramètreformat est utilisé pour formater correctement l'attributdate
Par défaut, la bibliothèque FastJson sérialise entièrement le bean Java, mais nous pouvons utiliser le paramètreserialize pour ignorer la sérialisation pour des champs spécifiques
Le paramètreordinal 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éBeanToArray serialization 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

Commeother JSON libraries, créer un objet JSON à partir de zéro est assez simple, il suffit de combiner les objetsJSONObject etJSONArray:

@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 le résultat 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 utiliserJSON.parseObject() pour obtenir un objet Java à partir d'une chaîne JSON.

Notez que vous devez définir unno-args or default constructor si vous avez déjà déclaré votre propre paramétré, sinon uncom.alibaba.fastjson.JSONException sera lancé.

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'optiondeserialize 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 deContextValueFilter

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

Dans ce cas, nous pouvons utiliser l'objetContextValueFilter 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 champDATE OF BIRTH, en forçant une valeur constante, nous avons également ignoré tous les champs qui ne sont pasJohn ouDoe:

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

Comme vous pouvez le constater, 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: vous pouvez combiner ces outils puissants et légers proposés par FastJson dans un projet réel.

7. Utilisation deNameFilter etSerializeConfig

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.

Imaginons que nous ayons une version compilée du bean JavaPerson, initialement déclaré dans cet article, et nous devons apporter des améliorations sur la dénomination des champs et le formatage de base:

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

Nous avons déclaré le filtreformatName en utilisant la classe anonymeNameFilter pour traiter les noms de champs. Le filtre nouvellement créé est associé à la classePerson, puis ajouté à une instance globale - qui est essentiellement un attribut statique dans la classeSerializeConfig.

Nous pouvons maintenant convertir facilement notre objet au format JSON, comme indiqué plus haut dans cet article.

Notez que nous avons utilisétoJSONStringWithDateFormat() au lieu detoJSONString() pour appliquer rapidement la même règle de mise en forme aux champs de date.

Et voici le résultat:

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

Comme vous pouvez le voir -the fields names got changed, et la valeur de la date a été correctement formatée.

La combinaison deSerializeFilter avecContextValueFilter peut donner un contrôle total sur le processus de conversion pour les objets Java arbitraires et complexes.

8. Conclusion

Dans cet article, nous avons montré comment utiliser FastJson pour convertir des beans Java en chaînes JSON et comment inverser la procédure. Nous avons également montré comment utiliser certains descore features of FastJson afin de personnaliser la sortie JSON.

Comme vous pouvez le voir,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.

Vous pouvez consulter les exemples fournis dans cet article dans lelinked GitHub project.

TOC