Comprendre le Data Binding avec Jackson

ObjectMapper est une classe principale de Jackson qui permet de convertir les objets Java en JSON et vice versa.

Cette classe utilise une stratégie de mappage pour convertir les propriétés de l'objet en propriétés JSON et vice versa. ObjectMapper est responsable de toutes les opérations de sérialisation et de désérialisation de JSON en Java.

Voyons maintenant quelques exemples d'utilisation d'ObjectMapper :

• JSON Serialization / Deserialization avec Jackson :

Nous pouvons utiliser ObjectMapper pour sérialiser et désérialiser des objets Java en JSON. La sérialisation est le processus de conversion d'un objet Java en JSON, tandis que la désérialisation est le processus inverse. Voici un exemple simple de sérialisation et de désérialisation d'un objet Java en JSON :

java
ObjectMapper objectMapper = new ObjectMapper();


// Serialization : Java object to JSON

String jsonString = objectMapper.writeValueAsString(student);


// Deserialization : JSON to Java object

Student deserializedStudent = objectMapper.readValue(jsonString, Student.class);

• POJO / JSON Conversion avec ObjectMapper :

Nous pouvons également utiliser ObjectMapper pour convertir une chaîne JSON en un objet Java et vice versa. Voici un exemple :

java
ObjectMapper objectMapper = new ObjectMapper();


// JSON to Java object

String json = "{\"name\":\"John Doe\",\"age\":30}";

Person person = objectMapper.readValue(json, Person.class);


// Java object to JSON

String jsonString = objectMapper.writeValueAsString(person);

• Création de POJO à partir de file JSON :
• 
  

• Il existe plusieurs méthodes pour créer des POJO à partir d'un fichier JSON en utilisant Jackson :

  1. Utilisation de la méthode readValue() de l'ObjectMapper : Cette méthode est utilisée pour mapper un fichier JSON en objet Java. La syntaxe de base est la suivante :

     java
     ObjectMapper objectMapper = new ObjectMapper();
     
     MyClass myClass = objectMapper.readValue(new File("myFile.json"), MyClass.class);
     

  2. Utilisation de la méthode readTree() de l'ObjectMapper : Cette méthode est utilisée pour mapper un fichier JSON en un objet JsonNode, qui peut ensuite être utilisé pour accéder aux différentes propriétés JSON. La syntaxe de base est la suivante :

     java
     ObjectMapper objectMapper = new ObjectMapper();
     
     JsonNode jsonNode = objectMapper.readTree(new File("myFile.json"));
     

  3. Utilisation de la méthode readValues() de l'ObjectMapper : Cette méthode est utilisée pour mapper un fichier JSON en une liste d'objets Java. Cette méthode est utile lorsque le fichier JSON contient une liste d'objets plutôt qu'un seul objet. La syntaxe de base est la suivante :

     java
     ObjectMapper objectMapper = new ObjectMapper();
     List<MyClass> myList = objectMapper.readValue(new File("myFile.json"), new TypeReference<List<MyClass>>(){});
     

  4. Utilisation de la méthode JsonParser et JsonFactory : Cette méthode est utilisée pour lire le fichier JSON en tant que flux d'entrée et mapper chaque élément en objet Java à l'aide de la classe JsonParser et JsonFactory. La syntaxe de base est la suivante :

     java
     ObjectMapper objectMapper = new ObjectMapper();
     
     JsonFactory jsonFactory = objectMapper.getFactory();
     
     JsonParser jsonParser = jsonFactory.createParser(new File("myFile.json"));
     while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
        
     MyClass myClass = objectMapper.readValue(jsonParser, MyClass.class);
        
     // ajouter chaque objet à une liste, par exemple
     
     }
     

  Chacune de ces méthodes peut être utilisée en fonction des besoins spécifiques de l'application et du format du fichier JSON.

• Création de POJO à partir de Byte Array JSON :

• Nous pouvons également créer un objet Java à partir d'un tableau d'octets JSON. Voici un exemple :

java
ObjectMapper objectMapper = new ObjectMapper();


byte[] jsonBytes = "{\"name\":\"John Doe\",\"age\":30}".getBytes();

Person person = objectMapper.readValue(jsonBytes, Person.class);

• Créer une liste d'objets Java à partir d'un tableau JSON :

TypeReference est une classe abstraite fournie par Jackson qui permet de résoudre le problème de la désérialisation de types génériques en Java.

Lorsque vous essayez de désérialiser un objet JSON en Java, vous devez fournir une classe Java cible pour stocker les données JSON. Cependant, cela peut être difficile si vous travaillez avec des types génériques tels que List<T> ou Map<K, V>, car la classe cible doit être paramétrée avec des types spécifiques pour que Jackson puisse la désérialiser correctement.

TypeReference permet de contourner ce problème en permettant de définir le type de manière dynamique à l'exécution. Vous pouvez utiliser cette classe abstraite pour définir le type cible de la désérialisation de manière à ce que Jackson puisse construire un objet Java approprié pour stocker les données JSON.

Voici un exemple qui illustre l'utilisation de TypeReference :

swift
String json = "[{\"id\": 1, \"name\": \"John\"}, {\"id\": 2, \"name\": \"Jane\"}]";


ObjectMapper mapper = new ObjectMapper();

List<User> users = mapper.readValue(json, new TypeReference<List<User>>() {});

Dans cet exemple, nous utilisons TypeReference pour désérialiser un tableau JSON en une liste d'objets User. En utilisant la classe abstraite, nous pouvons définir le type de manière dynamique à l'exécution, ce qui nous permet de travailler avec des types génériques de manière flexible.

• 
  
• Créer une Map Java à partir d'un objet JSON :

• Nous pouvons également créer une carte Java à partir d'un objet JSON. Voici un exemple :

java
ObjectMapper objectMapper = new ObjectMapper();


String json = "{\"name\":\"John Doe\",\"age\":30}";

Map<String, Object> personMap = objectMapper.readValue(json, new TypeReference<Map<String, Object>>(){});

• Ignorer les propriétés JSON inconnues lors de la désérialisation :

Supposons que nous avons un JSON contenant une propriété nommée "age" :

json
{
  
"name": "John",
  
"age": 30,
  
"email": "john@example.com"

}

Et supposons que nous avons une classe Java correspondante avec seulement les propriétés "name" et "email" :

java
public class User {
    
private String name;
    
private String email;

    
// constructors, getters and setters

}

Si nous essayons de désérialiser ce JSON dans notre objet User, nous aurons une exception car la propriété "age" est inconnue dans la classe User.

Pour ignorer cette propriété, nous pouvons utiliser l'annotation @JsonIgnoreProperties sur notre classe User :

java
@JsonIgnoreProperties(ignoreUnknown = true)

public class User {
    
private String name;
    
private String email;

    
// constructors, getters and setters

}

Maintenant, si nous essayons de désérialiser le même JSON, la propriété "age" sera simplement ignorée :

java
ObjectMapper objectMapper = new ObjectMapper();

String json = "{\"name\":\"John\",\"age\":30,\"email\":\"john@example.com\"}";

User user = objectMapper.readValue(json, User.class);

System.out.println(user.getName());  // John

System.out.println(user.getEmail()); // john@example.com

Notez que nous avons défini l'option ignoreUnknown à true dans l'annotation @JsonIgnoreProperties. Cela signifie que toutes les propriétés inconnues dans le JSON seront ignorées lors de la désérialisation. Si vous préférez une approche plus restrictive où une exception est levée si une propriété inconnue est trouvée, vous pouvez définir cette option à false. Gérer les dates Java 8 et ultérieures avec Jackson

1. Conversion d'une Date en JSON

Pour convertir une Date en JSON, vous pouvez utiliser la classe ObjectMapper de Jackson, ainsi que la classe JavaTimeModule pour gérer les dates Java 8 et ultérieures. Voici un exemple de code complet de configuration globale de l'objet ObjectMapper pour sérialiser une instance de LocalDateTime en une chaîne JSON sans horodatage :

java
public class LocalDateTimeSerializerTest {
    
@Test
    
public void whenSerializingLocalDateTime_thenCorrect() throws JsonProcessingException {
        
LocalDateTime date = LocalDateTime.of(2023, Month.MARCH, 7, 10, 30);

        ObjectMapper mapper = new ObjectMapper();
        mapper.registerModule(new JavaTimeModule());
        mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

        
String result = mapper.writeValueAsString(date);

 assertThat(result, is("\"2023-03-07T10:30:00\""));

 }

}

Dans cet exemple, la méthode disable est utilisée pour désactiver l'écriture des horodatages et ainsi forcer la sérialisation de la date sous la forme d'une chaîne. Le résultat attendu est une chaîne JSON représentant la date sous la forme "yyyy-MM-ddTHH:mm:ss".

Cette configuration globale peut être appliquée à l'ensemble de l'application en utilisant la méthode configure de l'objet ObjectMapper :

java
ObjectMapper mapper = new ObjectMapper();
mapper.registerModule(new JavaTimeModule());
mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

// Appliquer cette configuration globale à l'ensemble de l'application
mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);

Cette méthode permet de configurer l'objet ObjectMapper pour qu'il n'écrive pas les horodatages dans toutes les sérialisations de dates.

2. Conversion d'un JSON en Date

Pour convertir un JSON en Date, vous pouvez utiliser la méthode readValue de la classe ObjectMapper. Voici un exemple de code :

java
ObjectMapper mapper = new ObjectMapper();

mapper.registerModule(new JavaTimeModule());


String json = "{\"date\":\"2022-03-10T14:30:00.000Z\"}";

MyClass obj = mapper.readValue(json, MyClass.class);

Dans cet exemple, la méthode readValue de la classe ObjectMapper convertit le JSON en objet Java. La classe MyClass doit contenir une propriété date de type Date.

3. Configuration de la sérialisation et de la désérialisation des dates

Vous pouvez configurer la manière dont les dates sont sérialisées et désérialisées en utilisant les annotations de Jackson. Par exemple, vous pouvez utiliser l'annotation @JsonFormat pour spécifier le format de la date

Résumé :

Cet article explique comment utiliser Jackson, une bibliothèque Java pour le parsing JSON.

Il couvre les différentes méthodes de parsing JSON avec Jackson, notamment l'API Streaming, le Tree Model et le Data Binding. Il explique également comment utiliser ObjectMapper pour sérialiser et désérialiser des objets Java en JSON, et comment gérer les propriétés inconnues lors de la désérialisation. Enfin, l'article couvre l'utilisation des annotations de Jackson pour personnaliser le parsing JSON.

• serialization - Jackson Annotations: Difference Between JsonIgnoreProperties(ignoreUnknown=true) and JsonInclude(Include.NON_EMPTY) - Stack Overflow
• spring - What is the difference between @JsonIgnore and @JsonIgnoreProperties - Stack Overflow