Praktische Anwendungen und reale Anwendungsfälle
Nachdem Sie verstanden haben, wie man den ObjectMapper so konfiguriert, dass er unbekannte Eigenschaften ignoriert, wollen wir einige praktische Anwendungen und reale Szenarien untersuchen, in denen diese Funktion nützlich ist.
1. Nutzung von APIs von Drittanbietern
Bei der Integration mit externen APIs haben Sie oft keine Kontrolle über Änderungen an deren Antwortformat. Durch die Konfiguration des ObjectMapper zum Ignorieren unbekannter Eigenschaften kann Ihre Anwendung weiterhin funktionieren, selbst wenn die API neue Felder hinzufügt.
Lassen Sie uns ein einfaches Beispiel erstellen, das die Nutzung einer Wetter-API simuliert:
- Erstellen Sie eine neue Datei unter
~/project/src/main/java/com/labex/json/WeatherData.java
- Fügen Sie der Datei den folgenden Code hinzu:
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 +
'}';
}
}
- Erstellen Sie eine neue Datei unter
~/project/src/main/java/com/labex/json/WeatherApiConsumer.java
- Fügen Sie der Datei den folgenden Code hinzu:
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());
}
}
}
- Kompilieren und führen Sie diese Klasse aus:
cd ~/project
mvn compile exec:java -Dexec.mainClass="com.labex.json.WeatherApiConsumer"
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
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}
Beachten Sie, wie unsere Anwendung weiterhin mit der aktualisierten API-Antwort funktioniert, obwohl diese zusätzliche Felder enthält, die unsere WeatherData-Klasse nicht definiert.
2. Umgang mit verschiedenen API-Versionen
Ein weiteres häufiges Szenario ist, wenn Sie mehrere Versionen einer API mit demselben Client-Code unterstützen müssen:
- Erstellen Sie eine neue Datei unter
~/project/src/main/java/com/labex/json/ApiVersionDemo.java
- Fügen Sie der Datei den folgenden Code hinzu:
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\":\"[email protected]\"," +
"\"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());
}
}
}
- Kompilieren und führen Sie diese Klasse aus:
cd ~/project
mvn compile exec:java -Dexec.mainClass="com.labex.json.ApiVersionDemo"
Sie sollten eine Ausgabe ähnlich der folgenden sehen:
Parsing API v1 response:
Person{name='John Doe', age=30}
Parsing API v2 response with the same class:
Person{name='John Doe', age=30}
Dieses Beispiel zeigt, wie die Konfiguration des ObjectMapper zum Ignorieren unbekannter Eigenschaften es Ihnen ermöglicht, verschiedene Versionen einer API mit denselben Java-Klassen zu verarbeiten, wodurch Ihr Code wartbarer und anpassungsfähiger an Änderungen wird.
