Sérialisation et désérialisation JSON à l'aide de la bibliothèque Jackson

Si vous pensez que le contenu de ce blog vous est utile ou inspirant, suivez mon blog pour obtenir les derniers articles techniques et didacticiels dès que possible. Dans le même temps, vous êtes également invités à laisser un message dans la zone de commentaires pour partager vos réflexions et suggestions. Merci pour votre soutien! ​

1. Préambule

Dans le développement Web moderne, JSON (JavaScript Object Notation) est devenu un format de données largement utilisé pour la transmission et le stockage de données front-end et back-end. Java est un langage de programmation orienté objet et JSON est constitué de données dans un format de paire clé-valeur. Ainsi, en Java, vous devez convertir un objet Java en chaîne JSON ou convertir une chaîne JSON en objet Java. Ce processus est la sérialisation et la désérialisation de JSON.

Pour la sérialisation et la désérialisation JSON en Java, il existe de nombreuses bibliothèques open source parmi lesquelles la bibliothèque Jackson est l'une des plus populaires. La bibliothèque Jackson offre une multitude de fonctionnalités pour une sérialisation et une désérialisation JSON flexibles avec d'excellentes performances.

Cet article présentera la sérialisation et la désérialisation JSON de la bibliothèque Jackson, y compris la sérialisation et la désérialisation des objets de base, des collections, des types personnalisés, des types d'énumération et des types d'heure Java. Cet article vise à permettre aux lecteurs de comprendre et d'utiliser rapidement la bibliothèque Jackson pour la sérialisation et la désérialisation JSON.

2. Qu'est-ce que la sérialisation et la désérialisation JSON

La sérialisation JSON est le processus de conversion d'un objet Java en chaîne JSON. Au cours du processus de sérialisation JSON, les propriétés de l'objet Java seront converties en paires clé-valeur de l'objet JSON. Si l'objet Java contient d'autres objets ou collections Java, ces objets imbriqués seront également convertis en objets JSON imbriqués et en tableaux JSON. .

La désérialisation JSON est le processus de conversion d'une chaîne JSON en un objet Java. Au cours du processus de désérialisation JSON, les paires clé-valeur de l'objet JSON seront converties en propriétés de l'objet Java. Si l'objet JSON contient d'autres objets JSON ou tableaux JSON, ces JSON imbriqués seront également convertis en objets Java imbriqués et Collections Java.

Troisièmement, introduction à la bibliothèque Jackson

La bibliothèque Jackson est une bibliothèque de traitement JSON basée sur Java, qui fournit un analyseur JSON flexible et un générateur JSON, qui peuvent facilement convertir des objets Java et des données JSON. La bibliothèque Jackson est très simple à utiliser et offre d'excellentes performances, elle est donc largement utilisée dans le développement Java.

La bibliothèque Jackson comporte deux classes principales : ​ObjectMapper​et ​JsonNode​.

​​​​La classe​ObjectMapper​ est la classe la plus importante de la bibliothèque Jackson, qui assure la conversion entre la sérialisation et la désérialisation des objets Java et JSON. ​ObjectMapper​Les instances de la classe

​​​​La classe​JsonNode​ est une classe abstraite qui représente un nœud JSON. La classe​JsonNode​ a plusieurs sous-classes, telles que ​ObjectNode​​, ​ArrayNode​​,​, ​ValueNode​etc. , correspondant aux objets, aux tableaux et aux valeurs en JSON. La classe​JsonNode​ fournit des méthodes pratiques pour lire la valeur d'un nœud JSON.

4. Sérialisation JSON de type de base

1. Sérialisation d'objets

Le moyen le plus simple de convertir un objet Java en chaîne JSON consiste à ​ObjectMapper​utiliser ​writeValueAsString​la méthode de la classe. Cette méthode reçoit un objet Java en paramètre et renvoie une chaîne JSON.

Par exemple:

ObjectMapper mapper = new ObjectMapper();
User user = new User("Tom", 20);
String json = mapper.writeValueAsString(user);

Dans le code ci-dessus, nous créons un ​User​objet et utilisons ​ObjectMapper​la classe pour le sérialiser dans une chaîne JSON. ​User​La définition de la classe

public class User {
    private String name;
    private int age;
    
    public User() {
    }
    
    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String getName() {
        return name;
    }
    
    public void setName(String name) {
        this.name = name;
    }
    
    public int getAge() {
        return age;
    }
    
    public void setAge(int age) {
        this.age = age;
    }
}

La chaîne JSON résultante est la suivante :

{"name":"Tom","age":20}

2. Sérialisation des collections

En plus de sérialiser un seul objet Java, la bibliothèque Jackson prend également en charge la sérialisation de collections Java, notamment ​List​​​, ​Set​​​​​et ​Map​​​etc. Une collection Java peut être sérialisée en chaîne JSON en utilisant la méthode de ​ObjectMapper​la classe .​writeValueAsString​

ObjectMapper mapper = new ObjectMapper();
List<User> users = new ArrayList<>();
users.add(new User("Tom", 20));
users.add(new User("Jerry", 22));
String json = mapper.writeValueAsString(users);

Dans le code ci-dessus, nous créons une ​List​collection et ​User​ajoutons deux objets à la collection, puis utilisons ​ObjectMapper​la classe pour sérialiser la collection dans une chaîne JSON.

La chaîne JSON résultante est la suivante :

[{"name":"Tom","age":20},{"name":"Jerry","age":22}]

3. Type d'énumération sérialisée

En Java, un type énumération est un type de données courant, généralement utilisé pour représenter un ensemble limité de valeurs. La sérialisation d'un type enum en une chaîne JSON à l'aide de la bibliothèque Jackson est également une opération courante. Voici la définition d’un type énuméré simple :

public enum Gender {
    MALE, FEMALE
}

Pour sérialiser un type d'énumération dans une chaîne JSON, il suffit d'ajouter ​@JsonFormat​l'annotation et de spécifier le format de sérialisation. Par exemple, le code suivant sérialisera un type enum en utilisant des lettres majuscules :

public class User {
    private String name;
    private int age;
    private Gender gender;
    
    // getters and setters
}

ObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.INDENT_OUTPUT);

User user = new User();
user.setName("Tom");
user.setAge(20);
user.setGender(Gender.MALE);

String json = mapper.writeValueAsString(user);
System.out.println(json);

Le résultat est le suivant :

{
  "name" : "Tom",
  "age" : 20,
  "gender" : "MALE"
}

Dans le code ci-dessus, nous définissons d'abord une ​User​classe , qui contient un champ de type énumération ​gender​. Nous utilisons ensuite ​ObjectMapper​la classe pour ​User​sérialiser l'objet dans une chaîne JSON et imprimer le résultat. Comme vous pouvez le voir, la valeur du type énumération a été sérialisée en type chaîne.

4. Sérialisez le type d'heure Java

Dans les applications pratiques, nous devons souvent sérialiser les types d'heure Java en chaînes JSON pour les transmettre à d'autres systèmes ou les stocker dans des bases de données. La bibliothèque Jackson fournit une prise en charge très pratique pour la sérialisation des types d'heure Java 8 (tels que ​java.time.LocalDateTime​) en chaînes JSON.

Voici un exemple de sérialisation de type horaire Java utilisant la bibliothèque Jackson :

import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import com.fasterxml.jackson.databind.SerializationFeature;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

public class JacksonDemo {
    public static void main(String[] args) throws Exception {
        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        mapper.enable(SerializationFeature.INDENT_OUTPUT);
        
        LocalDateTime now = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
        String json = mapper.writeValueAsString(now);
        System.out.println(json);
        
        LocalDateTime parsed = mapper.readValue(json, LocalDateTime.class);
        System.out.println(parsed.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
    }
}

Dans le code ci-dessus, nous créons d'abord un ​ObjectMapper​objet et enregistrons ​JavaTimeModule​le module pour prendre en charge la sérialisation des types d'heure Java 8. Nous utilisons ensuite ​LocalDateTime.now()​la méthode pour obtenir l'heure actuelle et la sérialiser dans une chaîne JSON. Notez que nous utilisons pour ​ZoneId.of("Asia/Shanghai")​spécifier le fuseau horaire comme heure de Pékin.

Ensuite, nous désérialisons la chaîne JSON en un objet ​ObjectMapper​en utilisant la méthode​​​​. Enfin, nous formatons l'objet désérialisé au format horaire ISO-8601 et l'imprimons.​readValue()​​LocalDateTime​

Le résultat est le suivant :

"2022-02-23T14:25:23.845"
2022-02-23T14:25:23.845

Comme vous pouvez le voir, nous avons réussi à sérialiser l'heure actuelle dans une chaîne JSON et à restaurer l'objet temporel d'origine lors de la désérialisation.

Il convient de noter que lors de la sérialisation des types d'heure Java, la bibliothèque Jackson utilise par défaut le format d'heure ISO-8601. Si vous devez utiliser d'autres formats d'heure, vous pouvez utiliser l'annotation pour spécifier le format d'heure. Par exemple:​@JsonFormat​

@JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "Asia/Shanghai")
private LocalDateTime startTime;

Dans le code ci-dessus, nous avons spécifié le format de l'heure et le fuseau horaire à l'aide ​@JsonFormat​de l'annotation . De cette façon, la bibliothèque Jackson utilisera le format d'heure spécifié pour la sérialisation de l'heure.

Cinq, désérialisation JSON de type de base

La méthode de base pour convertir une chaîne JSON en objet Java consiste à ​ObjectMapper​utiliser ​readValue​la méthode de la classe. Cette méthode reçoit deux paramètres : une chaîne JSON et une classe Java, elle désérialisera la chaîne JSON dans l'objet classe Java spécifié.

1. Désérialiser un seul objet

Voyons d’abord comment désérialiser une chaîne JSON en un seul objet Java. Supposons que nous ayons une chaîne JSON représentant un ​User​objet :

{
    "name": "Tom",
    "age": 20
}

Il peut être désérialisé en objet en utilisant la méthode de ​ObjectMapper​la classe :​readValue​​User​

ObjectMapper mapper = new ObjectMapper();
String json = "{\"name\":\"Tom\",\"age\":20}";
User user = mapper.readValue(json, User.class);

Dans le code ci-dessus, nous créons ​ObjectMapper​une instance de la classe et désérialisons la chaîne JSON en ​User​objet.

2. Désérialiser les objets de collection

En plus de désérialiser un seul objet Java, la bibliothèque Jackson prend également en charge la désérialisation de collections Java, notamment ​List​​​, ​Set​​et ​Map​​​etc. Une chaîne JSON peut être désérialisée en une collection Java en utilisant la méthode de ​ObjectMapper​la classe .​readValue​

ObjectMapper mapper = new ObjectMapper();
String json = "[{\"name\":\"Tom\",\"age\":20},{\"name\":\"Jerry\",\"age\":22}]";
List<User> users = mapper.readValue(json, new TypeReference<List<User>>() {});

Dans le code ci-dessus, nous avons créé une chaîne JSON contenant deux ​User​objets et l'avons désérialisée en ​List​une collection.

Il convient de noter qu'en raison du mécanisme d'effacement générique de Java, vous ne pouvez pas ​List<User>​passer à ​readValue​la méthode et vous devez utiliser ​TypeReference​la classe pour spécifier le type de collection. ​​est​TypeReference​ une classe d'assistance fournie par la bibliothèque Jackson, qui est utilisée pour obtenir les informations de type des paramètres génériques.

3. Désérialiser le type d'énumération

En Java, un type énumération est un type de données spécial qui définit un ensemble fixe de constantes. Dans les données JSON, les chaînes sont généralement utilisées pour représenter les constantes d'énumération. L'utilisation de la bibliothèque Jackson peut facilement convertir les chaînes des données JSON en constantes d'énumération en Java.

L'exemple de code est le suivant :

Définissez d’abord un type d’énumération :

public enum Gender {
    MALE,
    FEMALE
}

Supposons ensuite que nous ayons les données JSON suivantes :

{
    "name": "Tom",
    "gender": "MALE"
}

Nous pouvons convertir des chaînes de données JSON en constantes d'énumération en Java en utilisant le code suivant :

ObjectMapper mapper = new ObjectMapper();
String json = "{\"name\": \"Tom\", \"gender\": \"MALE\"}";
Map<String, Object> map = mapper.readValue(json, new TypeReference<Map<String, Object>>(){});
Gender gender = Gender.valueOf(map.get("gender").toString());

Le code ci-dessus crée d'abord un objet à l'aide de la classe ObjectMapper, puis analyse les données JSON dans un objet Map. Enfin, nous pouvons convertir les chaînes de la Map en constantes d'énumération à l'aide de la méthode valueOf().

4. Désérialiser le type d'heure Java

En Java, le type d'heure est un type de données très courant, notamment Date, LocalDate, LocalTime, LocalDateTime, etc. Dans les données JSON, les types d'heure sont généralement représentés par des chaînes. L'utilisation de la bibliothèque Jackson peut facilement convertir les chaînes des données JSON en types d'heure en Java.

L'exemple de code est le suivant :

Supposons que nous disposions des données JSON suivantes :

{
    "name": "Tom",
    "birthday": "2000-01-01"
}

Nous pouvons utiliser le code suivant pour convertir une chaîne de données JSON en type LocalDate en Java :

ObjectMapper mapper = new ObjectMapper();
String json = "{\"name\": \"Tom\", \"birthday\": \"2000-01-01\"}";
Map<String, Object> map = mapper.readValue(json, new TypeReference<Map<String, Object>>(){});
LocalDate birthday = LocalDate.parse(map.get("birthday").toString());

Le code ci-dessus crée d'abord un objet à l'aide de la classe ObjectMapper, puis analyse les données JSON dans un objet Map. Enfin, nous pouvons utiliser la méthode parse() pour convertir les chaînes du Map en type LocalDate. La désérialisation d'autres types d'heure est similaire.

Six, sérialisation et désérialisation personnalisées

Dans certains cas, le comportement de sérialisation et de désérialisation par défaut fourni par la bibliothèque Jackson peut ne pas répondre aux exigences, et des règles de sérialisation et de désérialisation personnalisées sont requises. Par exemple, lors de la sérialisation ​User​d'un objet , nous souhaitons sérialiser l'âge en tant que type chaîne au lieu du type entier par défaut.

1. Sérialisation personnalisée

Pour personnaliser les règles de sérialisation, vous devez créer une classe qui implémente ​JsonSerializer​l'interface . ​​est​JsonSerializer​ une classe abstraite fournie par la bibliothèque Jackson, utilisée pour sérialiser des objets Java en chaînes JSON.

Voici un exemple de sérialisation de l'âge d' ​User​un objet sous forme de chaîne :

public class AgeToStringSerializer extends JsonSerializer<Integer> {
    @Override
    public void serialize(Integer value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
        gen.writeString(value.toString());
    }
}

Dans le code ci-dessus, nous avons défini une classe ​AgeToStringSerializer​appelée , qui hérite ​JsonSerializer​de et remplace ​serialize​la méthode . La méthode reçoit trois paramètres : l'objet Java à sérialiser, ​JsonGenerator​l'objet et un ​SerializerProvider​objet qui fournit certaines informations nécessaires à la sérialisation.

Dans ​serialize​la méthode , nous ​value​convertissons le paramètre en type chaîne et utilisons ​gen.writeString​la méthode pour l'écrire ​JsonGenerator​dans l'objet.

Ensuite, nous ​User​devons ​age​utiliser ​@JsonSerialize​l'annotation de la classe pour spécifier une ​AgeToStringSerializer​classe personnalisée pour la sérialisation :

public class User {
    private String name;
    @JsonSerialize(using = AgeToStringSerializer.class)
    private int age;
    private Address address;
    
    // ...
}

Ensuite, nous pouvons utiliser ​ObjectMapper​la classe pour ​User​sérialiser l'objet dans une chaîne JSON comme auparavant :

ObjectMapper mapper = new ObjectMapper();
User user = new User("Tom", 20, new Address("New York", "NY"));
String json = mapper.writeValueAsString(user);

La chaîne JSON résultante est la suivante :

{"name":"Tom","age":"20","address":{"city":"New York","state":"NY"}}

2. Désérialisation personnalisée

Semblable à la sérialisation personnalisée, pour personnaliser les règles de désérialisation, vous devez créer une classe qui implémente ​JsonDeserializer​l'interface . ​​est​JsonDeserializer​ une classe abstraite fournie par la bibliothèque Jackson, utilisée pour désérialiser les chaînes JSON en objets Java.

Voici un exemple qui désérialise l'âge d' ​User​un objet d'un type chaîne à un type entier :

public class StringToAgeDeserializer extends JsonDeserializer<Integer> {
    @Override
    public Integer deserialize(JsonParser p, DeserializationContext ctxt) throws IOException, JsonProcessingException {
        String value = p.getValueAsString();
        return Integer.parseInt(value);
    }
}

Dans le code ci-dessus, nous avons défini une classe ​StringToAgeDeserializer​appelée qui hérite de ​JsonDeserializer​la classe et remplace ​deserialize​la méthode . La méthode reçoit deux paramètres : l' ​JsonParser​objet et un ​DeserializationContext​objet qui fournit certaines informations nécessaires lors de la désérialisation.

Dans ​deserialize​la méthode , nous utilisons d'abord ​p.getValueAsString​la méthode pour obtenir la valeur dans la chaîne JSON et la convertir en type chaîne. Nous utilisons ensuite ​Integer.parseInt​la méthode pour convertir la valeur du type chaîne en type entier et renvoyer le résultat.

Ensuite, nous ​User​devons ​age​utiliser ​@JsonDeserialize​l'annotation de la classe pour spécifier une ​StringToAgeDeserializer​classe personnalisée pour la désérialisation :

public class User {
    private String name;
    @JsonSerialize(using = AgeToStringSerializer.class)
    @JsonDeserialize(using = StringToAgeDeserializer.class)
    private int age;
    private Address address;
    
    // ...
}

Ensuite, nous pouvons désérialiser la chaîne JSON en un objet en utilisant ​ObjectMapper​la classe ​User​:

ObjectMapper mapper = new ObjectMapper();
String json = "{\"name\":\"Tom\",\"age\":\"20\",\"address\":{\"city\":\"New York\",\"state\":\"NY\"}}";
User user = mapper.readValue(json, User.class);

Dans le code ci-dessus, nous définissons d'abord une chaîne JSON et ​ObjectMapper​utilisons ​readValue​la méthode de la classe pour la désérialiser en ​User​un objet . Étant donné que la valeur du ​age​champ est un type chaîne, elle sera ​StringToAgeDeserializer​analysée à l'aide de notre classe personnalisée lors de la désérialisation. Au final, nous obtiendrons un ​User​objet dont ​age​la valeur de champ est 20 de type entier.

5. Le but et l'utilisation des annotations communes

1. @JsonProperty

L'annotation @JsonProperty est utilisée pour spécifier le nom de la propriété dans l'objet Java lorsqu'il est sérialisé en données JSON. Si cette annotation n'est pas utilisée, le nom de la propriété est utilisé par défaut. Lors de la désérialisation, cette annotation est également utilisée pour spécifier à quelle propriété de l'objet Java correspond le nom de la propriété dans les données JSON.

L'exemple de code est le suivant :

Supposons que nous ayons l'objet Java suivant :

public class Person {
    private String name;
    private int age;

    @JsonProperty("person_gender")
    private Gender gender;

    // getters and setters
}

Nous pouvons utiliser l'annotation @JsonProperty pour spécifier le nom de la propriété, comme la propriété Gender dans le code ci-dessus. Lors de la sérialisation de cet objet Java en données JSON, l'attribut genre sera sérialisé en tant que champ « person_gender ».

ObjectMapper mapper = new ObjectMapper();
Person person = new Person();
person.setName("Tom");
person.setAge(20);
person.setGender(Gender.MALE);
String json = mapper.writeValueAsString(person);
System.out.println(json);

Le résultat est :

{"name":"Tom","age":20,"person_gender":"MALE"}

2. @JsonFormat

L'annotation @JsonFormat est utilisée pour spécifier le format du type de date et d'heure dans l'objet Java lorsqu'il est sérialisé en données JSON. Vous pouvez utiliser cette annotation pour spécifier le format datetime, le fuseau horaire, etc.

L'exemple de code est le suivant :

Supposons que nous ayons l'objet Java suivant :

public class Person {
    private String name;

    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
    private LocalDate birthday;

    // getters and setters
}

Nous pouvons utiliser l'annotation @JsonFormat pour spécifier le format de date et d'heure, comme l'attribut anniversaire dans le code ci-dessus. Lors de la sérialisation de cet objet Java en données JSON, la propriété d'anniversaire sera sérialisée en une chaîne de date au format « aaaa-MM-jj ».

ObjectMapper mapper = new ObjectMapper();
Person person = new Person();
person.setName("Tom");
person.setBirthday(LocalDate.of(2000, 1, 1));
String json = mapper.writeValueAsString(person);
System.out.println(json);

Le résultat est :

{"name":"Tom","birthday":"2000-01-01"}

3. @JsonIgnorer

L'annotation @JsonIgnore est utilisée pour ignorer le fonctionnement d'une propriété dans un objet Java lors de la sérialisation et de la désérialisation. Les attributs marqués de cette annotation ne seront pas inclus lors de la sérialisation dans les données JSON, et ne se verront pas non plus attribuer de valeurs lors de la désérialisation.

L'exemple de code est le suivant :

Supposons que nous ayons l'objet Java suivant :

public class Person {
    private String name;
    private int age;

    @JsonIgnore
    private Gender gender;

    // getters and setters
}

Nous pouvons utiliser l'annotation @JsonIgnore pour ignorer l'attribut de genre, qui ne sera pas inclus lors de la sérialisation vers les données JSON.

ObjectMapper mapper = new ObjectMapper();
Person person = new Person();
person.setName("Tom");
person.setAge(20);
person.setGender(Gender.MALE);
String json = mapper.writeValueAsString(person);
System.out.println(json);

Le résultat est :

{"name":"Tom","age":20}

4. @JsonInclude

L'annotation @JsonInclude est utilisée pour spécifier les conditions pour que certaines propriétés de l'objet Java soient sérialisées en données JSON. Par exemple, si la propriété est nulle ou la valeur par défaut, la propriété n'est pas incluse.

L'exemple de code est le suivant :

Supposons que nous ayons l'objet Java suivant :

@JsonInclude(JsonInclude.Include.NON_NULL)
public class Person {
    private String name;
    private Integer age;
    private Gender gender;

    // getters and setters
}

Nous pouvons utiliser l'annotation @JsonInclude pour spécifier que lors de la sérialisation vers des données JSON, si l'attribut age est nul, l'attribut ne sera pas inclus.

ObjectMapper mapper = new ObjectMapper();
Person person = new Person();
person.setName("Tom");
person.setAge(null);
person.setGender(Gender.MALE);
String json = mapper.writeValueAsString(person);
System.out.println(json);

Le résultat est :

{"name":"Tom","gender":"MALE"}

5. @JsonTypeInfo

L'annotation @JsonTypeInfo est utilisée pour spécifier les informations de type des objets Java lors de la sérialisation et de la désérialisation. Cette annotation peut être utilisée pour spécifier le type réel de la sous-classe et les données JSON peuvent être correctement converties en objet Java correspondant lors de la désérialisation.

L'exemple de code est le suivant :

Supposons que nous ayons l'objet Java suivant :

@JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.PROPERTY, property = "type")
@JsonSubTypes({
    @JsonSubTypes.Type(value = Dog.class, name = "dog"),
    @JsonSubTypes.Type(value = Cat.class, name = "cat")
})
public abstract class Animal {
    private String name;

    // getters and setters
}

public class Dog extends Animal {
    private String breed;

    // getters and setters
}

public class Cat extends Animal {
    private String color;

    // getters and setters
}

Nous pouvons utiliser l'annotation @JsonTypeInfo pour spécifier les informations de type de sous-classe de l'objet Animal, et les données JSON peuvent être correctement converties en objet Java correspondant lors de la sérialisation et de la désérialisation.

ObjectMapper mapper = new ObjectMapper();
Animal dog = new Dog();
dog.setName("Bobby");
((Dog) dog).setBreed("Bulldog");
String json = mapper.writeValueAsString(dog);
System.out.println(json);
Animal animal = mapper.readValue("{\"name\":\"Kitty\",\"type\":\"cat\",\"color\":\"white\"}", Animal.class);
System.out.println(animal.getClass().getName());
System.out.println(((Cat) animal).getColor());

Le résultat est :

{"type":"dog","name":"Bobby","breed":"Bulldog"}
com.example.jackson.Cat
white

Résumer

Cet article décrit comment utiliser la bibliothèque Jackson pour la sérialisation et la désérialisation JSON. Nous avons d'abord découvert les concepts de base et l'utilisation de la bibliothèque Jackson, puis avons expliqué en détail comment utiliser ​ObjectMapper​les classes pour la sérialisation et la désérialisation. Au cours du processus de sérialisation et de désérialisation, nous avons également présenté comment gérer les types de date et de collection, et expliqué comment personnaliser les règles de sérialisation et de désérialisation.

L'utilisation de la bibliothèque Jackson pour la sérialisation et la désérialisation JSON est une opération courante dans le développement Java. Le contenu présenté dans cet article couvre la plupart de l'utilisation de la bibliothèque Jackson. Je pense que les lecteurs ont une compréhension préliminaire de la bibliothèque Jackson. Dans le développement réel, vous pouvez choisir différentes méthodes de sérialisation et de désérialisation en fonction de vos besoins pour mieux répondre aux besoins de votre entreprise. ​

Si vous pensez que le contenu de ce blog vous est utile ou inspirant, suivez mon blog pour obtenir les derniers articles techniques et didacticiels dès que possible. Dans le même temps, vous êtes également invités à laisser un message dans la zone de commentaires pour partager vos réflexions et suggestions. Merci pour votre soutien!