Introduction à Fastjson

Fastjson est une bibliothèque Java qui peut convertir des objets Java au format JSON et, bien sûr, peut également convertir des chaînes JSON en objets Java.

Fastjson peut traiter n'importe quel objet Java, même des objets préexistants sans code source.

Adresse du code source de Fastjson :https://github.com/alibaba/fastjson

Wiki chinois de Fastjson :https://github.com/alibaba/fastjson/wiki/Quick-Start-CN

Fonctionnalités de Fastjson

  • Fournit des outils de parsing pour les clients côté serveur et les clients Android, avec de bonnes performances.
  • Fournit les méthodes toJSONString() et parseObject() pour convertir entre les objets Java et JSON. L'appel de la méthode toJSONString convertit un objet en une chaîne JSON, tandis que la méthode parseObject fait l'inverse, en convertissant une chaîne JSON en objet.
  • Permet la conversion d'objets immuables préexistants (uniquement la classe, sans code source).
  • Prise en charge étendue des génériques Java.
  • Permet une représentation personnalisée des objets et des classes de sérialisation personnalisées.
  • Prend en charge des objets arbitrairement complexes (avec des hiérarchies d'héritage profondes et un usage intensif des types génériques).

Téléchargement et utilisation

Vous pouvez le télécharger directement depuis le dépôt central Maven :

https://repo1.maven.org/maven2/com/alibaba/fastjson/

Ou configurez la dépendance Maven :

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>x.x.x</version>
</dependency>

oùx.x.xest le numéro de version. Utilisez une version spécifique selon vos besoins, et la dernière version est recommandée.

Convertir des objets Java au format JSON

Définissez le JavaBean Person suivant :

Exemple

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;
    }
 
    // getters et setters standard
}

Vous pouvez utiliser JSON.toJSONString() pour convertir un objet Java en objet JSON :

private List<Person> listOfPersons = new ArrayList<Person>();
 
@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);
}

La sortie est :

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

Nous pouvons également personnaliser la sortie et contrôler l'ordre des champs, le format d'affichage des dates, les indicateurs de sérialisation, etc.

Ensuite, mettons à jour le bean et ajoutons quelques champs :

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

Dans le code ci-dessus, nous avons listé les catégories de paramètres de base et utilisé l'annotation @JSONField pour implémenter une conversion personnalisée :

  • format Le paramètre est utilisé pour formaterdatela propriété.
  • Par défaut, la bibliothèque FastJson peut sérialiser des entités Java bean, mais nous pouvons utiliserserialize pour spécifier les champs à ne pas sérialiser.
  • Utilisez le paramètreordinal pour spécifier l'ordre des champs.

Ainsi, la sortie ci-dessus devient :

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

@JSONField

Les objets cibles de @JSONField :

  • 1. Champ
  • 2. Méthodes Setter et Getter

Remarque :Lorsque FastJson effectue des opérations, il le fait en fonction des méthodes getter et setter, et non en fonction des champs.

Remarque :Si une propriété est privée, elle doit avoir une méthode set ; sinon, la désérialisation est impossible.

span style="color: #000000; font-weight: bold;">package com.alibaba.fastjson.annotation;

public @interface JSONField {
    // Configurer l'ordre de sérialisation et de désérialisation ; pris en charge uniquement à partir de la version 1.1.42
    int ordinal() default 0;

     // Spécifier le nom du champ
    String name() default "";

    // Spécifier le format du champ ; utile pour les formats de date
    String format() default "";

    // Indique s'il faut sérialiser
    boolean serialize() default true;

    // Indique s'il faut désérialiser
    boolean deserialize() default true;
}

2. Méthodes de configuration de JSONField

FieldInfo peut être configuré sur les méthodes getter/setter ou les champs. Par exemple :

2.1 Configuré sur getter/setter

public class A {
      private int id;
 
      @JSONField(name="ID")
      public int getId() {return id;}
      @JSONField(name="ID")
      public void setId(int value) {this.id = id;}
}

2.2 Configuré sur le champ

 public class A {
      @JSONField(name="ID")
      private int id;
 
      public int getId() {return id;}
      public void setId(int value) {this.id = id;}
 }

3. Utilisation de format pour configurer le formatage des dates

span style="color: #000000; font-weight: bold;">public class A {
      // Configurer la sérialisation et la désérialisation des dates pour utiliser le format de date yyyyMMdd
      @JSONField(format="yyyyMMdd")
      public Date date;
 }

4. Utilisation de serialize/deserialize pour spécifier la non-sérialisation des champs

span style="color: #000000; font-weight: bold;">public class A {
      @JSONField(serialize=false)
      public Date date;
 }

 public class A {
      @JSONField(deserialize=false)
      public Date date;
 }

5. Utilisation de ordinal pour spécifier l'ordre des champs

Par défaut, fastjson sérialise un bean Java en fonction de l'ordre alphabétique de fieldName. Vous pouvez spécifier l'ordre des champs avec ordinal. Cette fonctionnalité nécessite la version 1.1.42 ou supérieure.

span style="color: #000000; font-weight: bold;">public static class VO {
    @JSONField(ordinal = 3)
    private int f0;

    @JSONField(ordinal = 2)
    private int f1;

    @JSONField(ordinal = 1)
    private int f2;
}

FastJson prend également en charge la sérialisation BeanToArray :

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

La sortie est :

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

Création d'objets JSON

La création d'objets JSON est très simple. Utilisez simplement JSONObject (l'objet JSON fourni par fastJson) et JSONArray (l'objet tableau JSON fourni par fastJson).

Nous pouvons considérer JSONObject comme une Map<String,Object>, sauf que JSONObject fournit des méthodes plus riches et plus pratiques pour manipuler les propriétés d'un objet. Jetons un coup d'œil au code source.

De même, nous pouvons traiter JSONArray comme une List<Object>, et pouvons considérer JSONArray comme une collection d'objets JSONObject.

De plus, comme JSONObject et JSONArray héritent de JSON, tous deux peuvent également être utilisés directement pour convertir entre des chaînes au format JSON et des objets JSON ou des JavaBeans. Cependant, pour éviter toute confusion, nous utilisons toujours JSON.

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

La sortie est :

[
   {
      "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"
   }
]

Conversion de chaînes JSON en objets Java

Maintenant que nous avons appris à créer des objets JSON et à convertir des objets Java en chaînes JSON, nous devons comprendre comment analyser du 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); // Si nous définissons la sérialisation sur false
    assertEquals(newPerson.getFullName(), listOfPersons.get(0).getFullName());
}

Nous pouvons utiliser JSON.parseObject() pour convertir des chaînes JSON en objets Java.

Remarque : lors de la désérialisation en un objet, un constructeur par défaut sans argument doit être présent ; sinon, une exception sera levée :

com.alibaba.fastjson.JSONException: default constructor not found.

Voici un exemple de test simple :

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

@JSONField deserializeDes paramètres optionnels peuvent spécifier les champs à ne pas désérialiser.

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

La sortie est :

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

Utilisation de ContextValueFilter pour configurer la conversion JSON

Dans certains scénarios, lors du filtrage de valeurs, vous devez obtenir des informations sur le JavaBean propriétaire, y compris son type, ses champs, ses méthodes, etc. Dans fastjson-1.2.9, ContextValueFilter est fourni, semblable au ValueFilter fourni dans les versions précédentes, mais avec un paramètre BeanContext supplémentaire disponible.

@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 l'exemple ci-dessus, nous avons masqué le champ DATE OF BIRTH et filtré les champs dont le nom ne contient pas John :

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

Utilisation de NameFilter et SerializeConfig

NameFilter: Modifier la clé lors de la sérialisation.

SerializeConfig: En interne, il s'agit d'un conteneur de type map dont la fonction principale est de configurer et d'enregistrer la classe de sérialisation correspondant à chaque type Java.

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

Dans l'exemple, nous avons déclaré le filtre formatName à l'aide de la classe anonyme NameFilter pour gérer les noms de champs. Le filtre nouvellement créé est associé à la classe Person, puis ajouté à l'instance globale, qui est une propriété statique de la classe SerializeConfig.

Maintenant, nous pouvons facilement convertir des objets au format JSON.

Notez que nous utilisons toJSONStringWithDateFormat() au lieu de toJSONString(), ce qui peut formater les dates plus rapidement.

Résultat de sortie :

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