Bibliothèque Java Gson

Java 常用类库Bibliothèques communes Java

Gson est une bibliothèque Java fournie par Google pour convertir des objets Java en représentation JSON (sérialisation) et convertir des chaînes JSON en objets Java (désérialisation).

Les principales fonctionnalités de Gson incluent :

  • API simple et facile à utiliser
  • Aucune annotation n'est requise dans les classes Java (mais les annotations sont prises en charge)
  • Hautes performances
  • Prise en charge des génériques
  • Prise en charge de la sérialisation et de la désérialisation personnalisées

Classes principales :

  • Gson: Classe principale, fournit des méthodes de sérialisation et de désérialisation

  • JsonElement: Classe abstraite pour les éléments JSON

  • JsonObject: Représentation d'un objet JSON

  • JsonArray: Représentation d'un tableau JSON

Pourquoi utiliser Gson ?

Dans le développement Java, nous avons souvent besoin de manipuler des données JSON dans les scénarios suivants :

  • Interaction avec les API RESTful
  • Lecture et écriture de fichiers de configuration
  • Persistance des données
  • Échange de données entre différents systèmes

Gson fournit un moyen simple et efficace d'accomplir ces tâches, et est plus pratique que le traitement JSON natif de Java.

Utilisation de base de Gson

Ajouter la dépendance Gson

Tout d'abord, vous devez ajouter la dépendance Gson à votre projet. Si vous utilisez Maven, vous pouvez l'ajouter à pom.xml :

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.9</version>
</dependency>

Un exemple simple de conversion entre objets Java et JSON :

Exemple

import com.google.gson.Gson;

public class GsonDemo {
    public static void main(String[] args) {
        Gson gson = new Gson();
       
        // Convertir un objet Java en JSON
        Person person = new Person("Zhang San", 30);
        String json = gson.toJson(person);
        System.out.println(json); // Sortie : {"name":"Zhang San","age":30}
       
        // Convertir un objet JSON en objet Java
        Person parsedPerson = gson.fromJson(json, Person.class);
        System.out.println(parsedPerson.getName()); // Sortie : Zhang San
    }
}

class Person {
    private String name;
    private int age;
   
    // Constructeur
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
   
    // Méthodes getter (Gson nécessite des getters/setters)
    public String getName() { return name; }
    public int getAge() { return age; }
}

Créer une instance de Gson

Gson gson = new Gson();

Objet Java vers JSON (Sérialisation)

Exemple

class User {
    private String name;
    private int age;
   
    // Constructeur, getters et setters omis
}

User user = new User("Zhang San", 25);
String json = gson.toJson(user);
// Sortie : {"name":"Zhang San","age":25}

JSON vers objet Java (Désérialisation)

Exemple

String json = "{\"name\":\"Li Si\",\"age\":30}";
User user = gson.fromJson(json, User.class);
System.out.println(user.getName()); // Sortie : Li Si

Fonctionnalités courantes

Gestion des collections

Exemple

// Sérialiser une collection
List<Person> people = Arrays.asList(
    new Person("Wang Wu", 28),
    new Person("Zhao Liu", 32)
);
String jsonList = gson.toJson(people);

// Désérialiser une collection
Type listType = new TypeToken<List<Person>>(){}.getType();
List<Person> parsedPeople = gson.fromJson(jsonList, listType);

Gestion des dates

Exemple

Gson gson = new GsonBuilder()
    .setDateFormat("yyyy-MM-dd HH:mm:ss")
    .create();

Date now = new Date();
String dateJson = gson.toJson(now);
Date parsedDate = gson.fromJson(dateJson, Date.classe);

Gestion du modèle d'arbre

Exemple

String json = "{\"name\":\"Li Si\",\"age\":25}";
JsonElement element = JsonParser.parseString(json);
JsonObject object = element.getAsJsonObject();
String name = object.get("name").getAsString();
int age = object.get("age").getAsInt();

Configurations courantes

Impression formatée

Gson gson = new GsonBuilder()
    .setPrettyPrinting()
    .create();

Gestion des valeurs nulles

Gson gson = new GsonBuilder()
    .serializeNulls() // 序列化null值
    .create();

Stratégie de nommage des champs

Gson gson = new GsonBuilder()
    .setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES)
    .create();
// 会将userName转换为user_name

Fonctionnalités avancées de Gson

Gestion des objets complexes

Gson peut gérer des structures de données complexes contenant des objets imbriqués, des tableaux, des collections, etc. :

Exemple

class Order {
    private String orderId;
    private List<Product> products;
    // Autre code omis
}

Order order = new Order("123", Arrays.asList(
    new Product("Téléphone mobile", 1, 2999.00),
    new Product("Casque", 2, 199.00)
));

String json = gson.toJson(order);

Utilisation de TypeToken pour gérer les génériques

Lorsque vous devez gérer des collections génériques, vous pouvez utiliser TypeToken :

Exemple

String json = "[{\"name\":\"Apple\",\"price\":5.5},{\"name\":\"Banana\",\"price\":3.2}]";

Type productListType = new TypeToken<List<Product>>(){}.getType();
List<Product> products = gson.fromJson(json, productListType);

Sérialisation et désérialisation personnalisées

Vous pouvez personnaliser la logique de traitement en implémentant les interfaces JsonSerializer et JsonDeserializer :

Exemple

public class DateSerializer implements JsonSerializer<Date> {
    private static final SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd");
   
    @Override
    public JsonElement serialize(Date date, Type type, JsonSerializationContext context) {
        return new JsonPrimitive(format.format(date));
    }
}

// Utiliser un sérialiseur personnalisé
Gson gson = new GsonBuilder()
    .registerTypeAdapter(Date.class, new DateSerializer())
    .create();

Utilisation des annotations

Gson fournit quelques annotations utiles :

Exemple

class User {
    @SerializedName("user_name")  // Nom du champ JSON
    private String name;
   
    @Expose(serialize = false)   // Non sérialisé
    private String password;
   
    @Since(1.0)                  // Contrôle de version
    private String email;
}

Configuration de GsonBuilder

GsonBuilder fournit diverses options de configuration :

Exemple

Gson gson = new GsonBuilder()
    .setPrettyPrinting()         // Affichage formaté
    .serializeNulls()           // Sérialiser les valeurs null
    .setDateFormat("yyyy-MM-dd") // Format de date
    .disableHtmlEscaping()       // Désactiver l'échappement HTML
    .create();

Considérations de performance

  • Réutiliser les instances Gson : Gson est thread-safe, il est donc recommandé de les réutiliser plutôt que d'en créer fréquemment
  • Pour de grands volumes de données, envisagez d'utiliser l'API de streaming (JsonReader/JsonWriter)
  • Les structures d'objets complexes peuvent affecter les performances

Comparaison de Gson avec d'autres bibliothèques JSON

Fonctionnalité Gson Jackson org.json
Facilité d'utilisation Élevée Moyenne Élevée
Performance Moyenne Élevée Faible
Complétude fonctionnelle Élevée Très élevé Faible
Support communautaire Élevée Très élevé Moyenne

Résumé

Gson est une bibliothèque de traitement JSON puissante mais simple, adaptée à la plupart des projets Java. Elle offre :

  • Conception d'API simple
  • Options de configuration flexibles
  • Bonnes performances
  • Fonctionnalités riches

Pour des besoins simples de traitement JSON, Gson est souvent le premier choix des développeurs Java. Pour des exigences de hautes performances ou des scénarios complexes, vous pouvez envisagerJacksonet d'autres bibliothèques.

Java 常用类库Bibliothèques communes Java

Autres extensions