Tauchen Sie ein in Jackson für JSON in Java: JsonNode, ArrayNode und ObjectMapper verstehen

Hey, liebe Java-Entwickler! ?

Starren Sie schon einmal auf JSON-Daten und denken Sie: „Wie um alles in der Welt arbeite ich damit in Java?“ Machen Sie sich keine Sorgen  – Sie sind nicht allein! Ob es darum geht, APIs zu erstellen, sie zu nutzen oder einfach nur Daten zu verarbeiten, der Umgang mit JSON ist fast unvermeidlich. Aber hier ist die gute Nachricht: Jackson steht hinter Ihnen!

In diesem Artikel werde ich Sie durch einige Jackson-Grundlagen führen, wie JsonNode, ArrayNode und den ObjectMapper. Wir halten es einfach, mit einfachen Codebeispielen und Ausgaben, um Ihnen genau zu zeigen, wie die Dinge funktionieren.

Klingt gut? Lass uns eintauchen! ?

Einrichten von Jackson in einem Spring Boot-Projekt

Bevor wir uns mit den Beispielen befassen, wollen wir uns kurz mit der Einrichtung von Jackson in einem Spring Boot-Projekt befassen. Gute Nachrichten: In Spring Boot ist Jackson integriert, sodass nur ein minimaler Einrichtungsaufwand erforderlich ist. ?

Wenn Sie ein neues Spring Boot-Projekt erstellen, wird Jackson als Standard-JSON-Bibliothek für die Serialisierung und Deserialisierung bereitgestellt. Wenn Sie Jackson explizit hinzufügen möchten, stellen Sie sicher, dass die folgende Abhängigkeit in Ihrer pom.xml enthalten ist:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.18.0</version> <!-- You can use the latest version -->
</dependency>

Dadurch werden Jacksons Kernfunktionen, einschließlich ObjectMapper, für die JSON-Verarbeitung hinzugefügt.

Bonus: Spring Boot-Konfiguration
Spring Boot bietet ein sofort einsatzbereites Setup für Jackson, Sie können es jedoch auch über die Datei „application.properties“ oder „application.yml“ anpassen.

Um beispielsweise Pretty-Printing von JSON zu konfigurieren, können Sie Folgendes hinzufügen:

spring.jackson.serialization.indent_output=true

Oder in application.yml:

spring:
  jackson:
    serialization:
      indent_output: true

Sobald Ihre Spring Boot-App JSON serialisiert, wird es jetzt gut formatiert sein!

Nachdem diese Einrichtung abgeschlossen ist, können Sie mit Jackson in Ihrer Spring Boot-App mit JSON arbeiten.

Also, was ist Jackson?

Jackson ist wie ein Schweizer Taschenmesser für die Arbeit mit JSON in Java. Sie können es verwenden, um:

• 1. Konvertieren Sie Java-Objekte in JSON (Serialisierung).
• 2. Konvertieren Sie JSON in Java-Objekte (Deserialisierung).
• 3. Behandeln Sie JSON in einer baumartigen Struktur mit JsonNode.

Wir werden heute einige dieser Funktionen erkunden, also machen Sie sich bereit, die Handhabung von JSON viel weniger beängstigend zu gestalten!

JsonNode: Ihr erster Schritt in JSON

Stellen Sie sich JsonNode als einen magischen Schlüssel vor, mit dem Sie JSON-Daten erkunden und bearbeiten können. Es ist eine Möglichkeit, verschiedene Teile einer JSON-Struktur in Java darzustellen.

Stellen Sie sich vor, Sie haben diese einfachen JSON-Daten:

{
  "name": "Samarth",
  "age": 30,
  "city": "New York"
}

Wie liest man das in Java? Mal sehen!

Hier ist der Code:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonNodeExample {
    public static void main(String[] args) throws Exception {
        String jsonString = "{\"name\":\"Samarth\", \"age\":30, \"city\":\"New York\"}";

        // Step 1: Create an ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();

        // Step 2: Parse the JSON string into a JsonNode
        JsonNode jsonNode = objectMapper.readTree(jsonString);

        // Step 3: Access values from the JsonNode
        System.out.println("Name: " + jsonNode.get("name").asText());
        System.out.println("Age: " + jsonNode.get("age").asInt());
        System.out.println("City: " + jsonNode.get("city").asText());
    }
}

Und die Ausgabe:

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.18.0</version> <!-- You can use the latest version -->
</dependency>

Was passiert hier?

1. ObjectMapper ist Jacksons wichtigster Helfer. Es ist diejenige, die zwischen JSON und Java übersetzt.
2. readTree() liest den JSON und konvertiert ihn in ein JsonNode-Objekt.
3. Wir verwenden .get(), um auf die einzelnen Felder „Name“, „Alter“ und „Stadt“ aus dem JSON zuzugreifen.

Ziemlich cool, oder? Jetzt beginnen Sie zu sehen, wie einfach es ist, mit JSON in Java zu arbeiten!

ArrayNode: Umgang mit JSON-Arrays

Aber was ist, wenn Ihr JSON ein Array ist? Keine Sorge, Jackson hat auch das im Griff! Nehmen wir an, Sie haben dieses JSON-Array:

spring.jackson.serialization.indent_output=true

Wir können ArrayNode verwenden, um dieses Array von Objekten zu lesen und damit zu arbeiten.

Hier ist der Code:

spring:
  jackson:
    serialization:
      indent_output: true

Und die Ausgabe:

{
  "name": "Samarth",
  "age": 30,
  "city": "New York"
}

Was passiert hier?

1. **ArrayNode **ist ein spezieller Typ von **JsonNode **, der ein Array von JSON-Objekten darstellt.
2. Wir durchlaufen jedes Element im Array und geben den „Namen“ jeder Person aus.

Einfach, oder? Mit ArrayNode macht Jackson den Umgang mit JSON-Arrays zum Kinderspiel!

ObjectMapper: Das Herz von Jackson

Lassen Sie uns nun über ObjectMapper  sprechen –  das Herz und die Seele von Jackson. Es ist Ihr bevorzugtes Tool zum Konvertieren von Java-Objekten in JSON und umgekehrt.

Java-Objekte in JSON serialisieren
Serialisierung ist einfach eine schicke Art zu sagen: „Verwandle mein Java-Objekt in einen JSON-String.“ Nehmen wir an, Sie haben eine einfache Personclass:

Code:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;

public class JsonNodeExample {
    public static void main(String[] args) throws Exception {
        String jsonString = "{\"name\":\"Samarth\", \"age\":30, \"city\":\"New York\"}";

        // Step 1: Create an ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();

        // Step 2: Parse the JSON string into a JsonNode
        JsonNode jsonNode = objectMapper.readTree(jsonString);

        // Step 3: Access values from the JsonNode
        System.out.println("Name: " + jsonNode.get("name").asText());
        System.out.println("Age: " + jsonNode.get("age").asInt());
        System.out.println("City: " + jsonNode.get("city").asText());
    }
}

Ausgabe:

Name: Samarth  
Age: 30  
City: New York

Was passiert hier?

1. **ObjectMapper **nimmt das Personobject und wandelt es mit writeValueAsString() in einen JSON-String um.
2. Die Methode writeValueAsString() erstellt eine JSON-Darstellung des Java-Objekts.
3. Das Ergebnis ist eine gültige JSON-Zeichenfolge, die Sie an eine API senden oder in einer Datenbank speichern können.

JSON in ein Java-Objekt deserialisieren

Und umgekehrt funktioniert es auch! Sie können JSON nehmen und es wieder in ein Java-Objekt umwandeln. Dies wird als Deserialisierung bezeichnet.

Hier ist der Code:

[
  {"name": "Samarth"},
  {"name": "Ujjwal"},
  {"name": "Gaurav"}
]

Und die Ausgabe:

import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ArrayNode;

public class ArrayNodeExample {
    public static void main(String[] args) throws Exception {
        String jsonArrayString = "[{\"name\":\"Samarth\"}, {\"name\":\"Ujjwal\"}, {\"name\":\"Gaurav\"}]";

        // Step 1: Create an ObjectMapper
        ObjectMapper objectMapper = new ObjectMapper();

        // Step 2: Parse the JSON array into an ArrayNode
        ArrayNode arrayNode = (ArrayNode) objectMapper.readTree(jsonArrayString);

        // Step 3: Loop through each element in the array
        for (JsonNode jsonNode : arrayNode) {
            System.out.println("Name: " + jsonNode.get("name").asText());
        }
    }
}

Was passiert hier?

Wir verwenden wieder **ObjectMapper **, aber dieses Mal liest er einen JSON-String und konvertiert ihn zurück in ein Person-Objekt.
Dies erfolgt mit readValue() und das Ergebnis ist ein vollständiges Java-Objekt, das zur Verwendung in Ihrem Code bereit ist.

Zusammenfassung

Und da haben Sie es! Wir haben viel abgedeckt:

• JsonNode: So lesen und bearbeiten Sie JSON-Daten.
• ArrayNode: Umgang mit JSON-Arrays.
• ObjectMapper: So serialisieren und deserialisieren Sie Java-Objekte in und von JSON.

Ich hoffe, dieser Leitfaden macht Jackson etwas weniger einschüchternd und macht viel mehr Spaß! Sobald Sie den Dreh raus haben, werden Sie im Handumdrehen wie ein Profi mit JSON umgehen können.

Aber hey, hören Sie hier nicht auf! Halten Sie Ausschau nach meinem nächsten Artikel, in dem wir tiefer in die erweiterten Jackson-Funktionen und Best Practices für reale Anwendungen eintauchen.

Bis zum nächsten Mal! Viel Spaß beim Codieren! ?

Das obige ist der detaillierte Inhalt vonTauchen Sie ein in Jackson für JSON in Java: JsonNode, ArrayNode und ObjectMapper verstehen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!