Applications pratiques et cas d'utilisation concrets
Maintenant que vous comprenez comment configurer ObjectMapper pour ignorer les propriétés inconnues, explorons quelques applications pratiques et des scénarios réels où cette fonctionnalité est utile.
1. Consommation d'API tierces
Lors de l'intégration avec des API externes, vous n'avez souvent aucun contrôle sur les changements de leur format de réponse. En configurant ObjectMapper pour ignorer les propriétés inconnues, votre application peut continuer à fonctionner même si l'API ajoute de nouveaux champs.
Créons un exemple simple qui simule la consommation d'une API météo :
- Créez un nouveau fichier à
~/project/src/main/java/com/labex/json/WeatherData.java
- Ajoutez le code suivant au fichier :
package com.labex.json;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
@JsonIgnoreProperties(ignoreUnknown = true)
public class WeatherData {
private String city;
private double temperature;
private int humidity;
// Default constructor needed for Jackson
public WeatherData() {
}
// Getters and setters
public String getCity() {
return city;
}
public void setCity(String city) {
this.city = city;
}
public double getTemperature() {
return temperature;
}
public void setTemperature(double temperature) {
this.temperature = temperature;
}
public int getHumidity() {
return humidity;
}
public void setHumidity(int humidity) {
this.humidity = humidity;
}
@Override
public String toString() {
return "WeatherData{" +
"city='" + city + '\'' +
", temperature=" + temperature +
", humidity=" + humidity +
'}';
}
}
- Créez un nouveau fichier à
~/project/src/main/java/com/labex/json/WeatherApiConsumer.java
- Ajoutez le code suivant au fichier :
package com.labex.json;
import com.fasterxml.jackson.databind.ObjectMapper;
public class WeatherApiConsumer {
public static void main(String[] args) {
try {
// Create an ObjectMapper
ObjectMapper objectMapper = new ObjectMapper();
// Simulate an initial API response with just the basics
String initialApiResponse = "{\"city\":\"New York\",\"temperature\":72.5,\"humidity\":65}";
// Parse the response
WeatherData weatherData = objectMapper.readValue(initialApiResponse, WeatherData.class);
System.out.println("Initial weather data: " + weatherData);
// Now simulate the API adding new fields in a future version
String updatedApiResponse =
"{\"city\":\"New York\",\"temperature\":72.5,\"humidity\":65," +
"\"wind_speed\":10.2,\"pressure\":1013.25,\"forecast\":\"sunny\"}";
// Parse the updated response with the same object model
WeatherData updatedWeatherData = objectMapper.readValue(updatedApiResponse, WeatherData.class);
System.out.println("Updated weather data (with ignored fields): " + updatedWeatherData);
// Notice how our application continues to work without changes to our model
} catch (Exception e) {
System.out.println("Error occurred: " + e.getMessage());
}
}
}
- Compilez et exécutez cette classe :
cd ~/project
mvn compile exec:java -Dexec.mainClass="com.labex.json.WeatherApiConsumer"
Vous devriez voir une sortie similaire à :
Initial weather data: WeatherData{city='New York', temperature=72.5, humidity=65}
Updated weather data (with ignored fields): WeatherData{city='New York', temperature=72.5, humidity=65}
Remarquez comment notre application continue de fonctionner avec la réponse de l'API mise à jour, même si elle contient des champs supplémentaires que notre classe WeatherData ne définit pas.
2. Gestion de différentes versions d'API
Un autre scénario courant est celui où vous devez prendre en charge plusieurs versions d'une API avec le même code client :
- Créez un nouveau fichier à
~/project/src/main/java/com/labex/json/ApiVersionDemo.java
- Ajoutez le code suivant au fichier :
package com.labex.json;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
public class ApiVersionDemo {
public static void main(String[] args) {
try {
// Create an ObjectMapper that ignores unknown properties
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
// API v1 response
String apiV1Response = "{\"name\":\"John Doe\",\"age\":30}";
// API v2 response with additional fields
String apiV2Response =
"{\"name\":\"John Doe\",\"age\":30,\"email\":\"john.doe@example.com\"," +
"\"address\":\"123 Main St\",\"phone\":\"555-1234\"}";
// We can use the same Person class for both versions
System.out.println("Parsing API v1 response:");
Person personV1 = objectMapper.readValue(apiV1Response, Person.class);
System.out.println(personV1);
System.out.println("\nParsing API v2 response with the same class:");
Person personV2 = objectMapper.readValue(apiV2Response, Person.class);
System.out.println(personV2);
// Both work fine with our simple Person class
} catch (Exception e) {
System.out.println("Error occurred: " + e.getMessage());
}
}
}
- Compilez et exécutez cette classe :
cd ~/project
mvn compile exec:java -Dexec.mainClass="com.labex.json.ApiVersionDemo"
Vous devriez voir une sortie similaire à :
Parsing API v1 response:
Person{name='John Doe', age=30}
Parsing API v2 response with the same class:
Person{name='John Doe', age=30}
Cet exemple démontre comment la configuration d'ObjectMapper pour ignorer les propriétés inconnues vous permet de gérer différentes versions d'une API avec les mêmes classes Java, ce qui rend votre code plus maintenable et adaptable aux changements.
