💡 Dieser Artikel wurde von AI-Assistenten übersetzt. Um die englische Version anzuzeigen, können Sie hier klicken
In diesem Lab werden wir lernen, wie man die Jackson ObjectMapper-Klasse verwendet, um Objekte in JSON und JSON in Objekte zu mappen. Wir werden eine einfache Java-Klasse namens DemoClass verwenden und verschiedene Techniken kennenlernen, um JSON-Daten zu lesen und zu schreiben.
Erstellen Sie ein neues Projekt im Verzeichnis ~/project und erstellen Sie eine neue Java-Klasse namens DemoClass. Fügen Sie den folgenden Code in die Datei DemoClass.java ein.
import java.util.Date;
public class DemoClass {
private String field1;
private Double field2;
private Date dateField;
// Konstruktoren
DemoClass() {}
DemoClass(String field1, Double field2, Date dateField) {
this.field1 = field1;
this.field2 = field2;
this.dateField = dateField;
}
// Getter und Setter
public String getField1() {
return field1;
}
public void setField1(String field1) {
this.field1 = field1;
}
public Double getField2() {
return field2;
}
public void setField2(Double field2) {
this.field2 = field2;
}
public Date getDateField() {
return dateField;
}
public void setDateField(Date dateField) {
this.dateField = dateField;
}
}Kompilieren Sie die Java-Klasse DemoClass mit dem folgenden Befehl:
javac DemoClass.javaWir können die readValue()-Methode der ObjectMapper-Klasse verwenden, um Daten aus einer JSON-Datei in ein Objekt zu lesen. Unsere JSON-Datei enthält nur die Eigenschaft-Wert-Paare eines einzelnen Objekts.
Erstellen Sie eine neue Datei namens demo.json und fügen Sie den folgenden JSON-Inhalt hinein.
{
"field1": "Sample-1",
"field2": 20.21,
"dateField": "2021-07-30T14:20:30.000Z"
}Verwenden Sie den folgenden Code, um die JSON-Datei zu lesen und sie in ein DemoClass-Objekt zuzuordnen.
import java.io.File;
import java.text.SimpleDateFormat;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
public class ObjectMapperDemo {
public static void main(String[] args) {
try {
String filePath = "demo.json";
File file = new File(filePath);
ObjectMapper objMapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
DemoClass obj = objMapper.readValue(file, DemoClass.class);
System.out.println("Field1: " + obj.getField1());
System.out.println("Field2: " + obj.getField2());
System.out.println("DateField: " + obj.getDateField());
} catch (Exception e) {
System.out.println(e);
}
}
}Die Ausgabe wird wie folgt sein:
Field1: Sample-1
Field2: 20.21
DateField: Fri Jul 30 14:20:30 UTC 2021Wir können Daten aus einem JSON-String in ein Objekt lesen. Wir werden die readValue()-Methode der ObjectMapper-Klasse verwenden. Wir müssen auch den Klassen-Typ an diese Methode übergeben.
Fügen Sie den folgenden Code hinzu, um Daten aus einem JSON-String zu lesen.
String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21,\"dateField\":\"2021-07-30T14:20:30.000Z\"}";
ObjectMapper objMapper = new ObjectMapper();
DemoClass obj = objMapper.readValue(jsonString, DemoClass.class);
System.out.println("Field1: " + obj.getField1());
System.out.println("Field2: " + obj.getField2());
System.out.println("DateField: " + obj.getDateField());Die Ausgabe wird wie folgt sein:
Field1: Sample-1
Field2: 20.21
DateField: Fri Jul 30 14:20:30 UTC 2021Das Lesen von Objekten aus einer URL ist ebenfalls recht einfach. Wir müssen das URL-Objekt und den Klassen-Typ an die readValue()-Methode übergeben.
Fügen Sie den folgenden Code hinzu, um Objekte aus einer JSON-URL zu lesen und zuzuordnen.
import java.net.URL;
import java.text.SimpleDateFormat;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
public class ObjectMapperDemo {
public static void main(String[] args) {
try {
URL jsonFileUrl = new URL("file:demo.json");
ObjectMapper objMapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
DemoClass obj = objMapper.readValue(jsonFileUrl, DemoClass.class);
System.out.println("Field1: " + obj.getField1());
System.out.println("Field2: " + obj.getField2());
System.out.println("DateField: " + obj.getDateField());
} catch (Exception e) {
System.out.println(e);
}
}
}Die Ausgabe wird der gleichen wie in Schritt 2 sein.
Angenommen, ein String enthält mehrere Objektdaten (als Array) im JSON-Format. Wir können all diese Daten in ein Array vom Typ DemoClass mithilfe der ObjectMapper-Klasse lesen.
Fügen Sie den folgenden Code hinzu, um Objekte aus einem JSON-String-Array in ein Objekt-Array zu lesen.
String jsonString = " [{\"field1\":\"Sample-1\",\"field2\":20.21,\"dateField\":\"2021-07-30T14:20:30.000Z\"}," +
" {\"field1\":\"Sample-2\",\"field2\":22.55,\"dateField\":\"2021-07-31T14:20:30.000Z\"}]";
ObjectMapper objMapper = new ObjectMapper();
DemoClass[] objectArr = objMapper.readValue(jsonString, DemoClass[].class);
for (DemoClass obj : objectArr) {
System.out.println("Field1: " + obj.getField1());
System.out.println("Field2: " + obj.getField2());
System.out.println("DateField: " + obj.getDateField());
System.out.println();
}Die Ausgabe wird wie folgt sein:
Field1: Sample-1
Field2: 20.21
DateField: Fri Jul 30 14:20:30 UTC 2021
Field1: Sample-2
Field2: 22.55
DateField: Sat Jul 31 14:20:30 UTC 2021Wir können die Objekte in eine Liste lesen, wenn wir nicht möchten, dass die Daten in ein Objekt-Array fester Größe gelesen werden.
Fügen Sie den folgenden Code hinzu, um Objekte aus einem JSON-String-Array in eine Objektliste zu lesen.
String jsonString = " [{\"field1\":\"Sample-1\",\"field2\":20.21,\"dateField\":\"2021-07-30T14:20:30.000Z\"}," +
" {\"field1\":\"Sample-2\",\"field2\":22.55,\"dateField\":\"2021-07-31T14:20:30.000Z\"}]";
ObjectMapper objMapper = new ObjectMapper();
ArrayList<DemoClass> objectList = objMapper.readValue(jsonString, new TypeReference<ArrayList<DemoClass>>(){});
for (DemoClass obj : objectList) {
System.out.println("Field1: " + obj.getField1());
System.out.println("Field2: " + obj.getField2());
System.out.println("DateField: " + obj.getDateField());
System.out.println();
}Die Ausgabe wird der gleichen wie in Schritt 5 sein.
Wir können auch Daten aus einem JSON-String in eine Karte lesen. Jede Eigenschaft der Klasse wird ein Schlüssel werden, und der Eigenschaftswert wird der Wert.
Fügen Sie den folgenden Code hinzu, um Daten aus einem JSON-String-Array in eine Karte zu lesen.
String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21,\"dateField\":\"2021-07-30T14:20:30.000Z\"}";
ObjectMapper objMapper = new ObjectMapper();
Map<String, Object> objectMap = objMapper.readValue(jsonString, new TypeReference<Map<String, Object>>() {});
for (Map.Entry<String, Object> entry : objectMap.entrySet()) {
System.out.println(entry.getKey() + ": " + entry.getValue());
}Die Ausgabe wird wie folgt sein:
field1: Sample-1
field2: 20.21
dateField: 2021-07-30T14:20:30.000ZDie JsonNode-Klasse bietet uns eine flexiblere Möglichkeit, JSON zu analysieren. Wir können die readTree()-Methode der ObjectMapper-Klasse verwenden, um JSON in ein JsonNode-Objekt zu lesen.
Fügen Sie den folgenden Code hinzu, um JSON in ein JsonNode-Objekt zu lesen.
String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21,\"dateField\":\"2021-07-30T14:20:30.000Z\"}";
ObjectMapper objMapper = new ObjectMapper();
JsonNode node = objMapper.readTree(jsonString);
System.out.println("Field1: " + node.get("field1").asText());
System.out.println("Field2: " + node.get("field2").asDouble());
System.out.println("DateField: " + node.get("dateField").asText());Die Ausgabe wird der gleichen wie in Schritt 2 sein.
Wir können die ObjectMapper so konfigurieren, dass sie mit unerwarteten Eingaben umgehen kann.
Fügen Sie den folgenden Code hinzu, um die ObjectMapper so zu konfigurieren, dass sie alle neuen Eigenschaften ignoriert.
String jsonString = "{\"field1\":\"Sample-1\",\"field2\":20.21,\"field3\":\"Unknown\"}";
ObjectMapper objMapper = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
DemoClass obj = objMapper.readValue(jsonString, DemoClass.class);
System.out.println("Field1: " + obj.getField1());
System.out.println("Field2: " + obj.getField2());
System.out.println("DateField: " + obj.getDateField());Die Ausgabe wird der gleichen wie in Schritt 2 sein.
Standardmäßig wird die ObjectMapper ein java.util.date in einen Long-Wert abbilden. Dieser Long-Wert ist die Anzahl der vergangenen Millisekunden seit dem 1. Januar 1970.
Fügen Sie den folgenden Code hinzu, um zu demonstrieren, wie man ein Datumsformat mit SimpleDateFormat definiert, um das java.util.date zu serialisieren.
ObjectMapper objMapper = new ObjectMapper();
SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MM-yyyy");
objMapper.setDateFormat(dateFormat);
DemoClass obj = new DemoClass("Sample-1", 20.21, new Date());
String jsonString = objMapper.writeValueAsString(obj);
System.out.println(jsonString);Die Ausgabe wird wie folgt sein:
{"field1":"Sample-1","field2":20.21,"dateField":"30-07-2021"}In diesem Lab haben wir gelernt, wie man die Jackson-ObjectMapper-Klasse verwendet, um Objekte in JSON und JSON in Objekte zu mappen. Wir haben gelernt, wie man eine JSON-Datei in ein Objekt einliest, Daten aus einem JSON-String liest und in ein Objekt abbildet, und wie man Objekte aus einem JSON-String-Array in eine Objektliste oder -Array liest. Wir haben auch gelernt, wie man einen JSON-String in ein JsonNode-Objekt liest und die ObjectMapper so konfiguriert, dass neue Eigenschaften oder NULL-Werte für primitive Typen ignoriert werden. Schließlich haben wir gelernt, wie man mit Daten und Zeiten umgeht und ein bestimmtes Datumsformat verwendet, wenn man das java.util.date serialisiert.