Einlesen von JSON-Dateien über relative Pfade in Java

Einführung

In der modernen Java-Entwicklung ist der Umgang mit JSON (JavaScript Object Notation) eine grundlegende Fertigkeit. JSON ist der De-facto-Standard für den Datenaustausch in Webanwendungen und APIs, da es ein menschenlesbares Format bietet und von Maschinen leicht verarbeitet werden kann.

Dieses Tutorial bietet einen umfassenden Leitfaden zum Lesen und Parsen von JSON-Dateien über einen relativen Pfad in Ihren Java-Anwendungen. Sie lernen, wie Sie ein Maven-Projekt mit den erforderlichen Abhängigkeiten einrichten, eine JSON-Datei strukturieren, diese über einen relativen Pfad einlesen und deren Inhalte – einschließlich komplexer verschachtelter Daten – analysieren.

Am Ende dieses Praktikums werden Sie in der Lage sein, JSON-Daten innerhalb Ihrer Java-Projekte sicher zu verwalten. Dies ist eine entscheidende Kompetenz für jeden Entwickler, der mit Webdiensten, APIs oder Konfigurationsdateien arbeitet.

Projekt-Setup und Erstellung der JSON-Datei

Bevor wir eine JSON-Datei einlesen können, müssen wir unsere Projektumgebung einrichten und die Datei selbst erstellen. Dieses Praktikum verwendet Apache Maven zur Verwaltung der Projektabhängigkeiten. Das initiale Setup hat bereits eine Standard-Maven-Projektstruktur für Sie erstellt.

Die Projektstruktur verstehen

Im Datei-Explorer der WebIDE auf der linken Seite sehen Sie die folgende Struktur innerhalb des Verzeichnisses ~/project:

pom.xml: Die Project Object Model Datei für Maven. Sie definiert die Abhängigkeiten und Build-Konfigurationen des Projekts.
src/main/java: Das Verzeichnis für Ihren Java-Quellcode.
src/main/resources: Das Verzeichnis für Ressourcendateien, wie Konfigurations- oder Datendateien.

Die Datei pom.xml wurde vorkonfiguriert und enthält bereits die Bibliothek org.json, eine beliebte Wahl für die Arbeit mit JSON in Java.

Erstellen der JSON-Datendatei

Lassen Sie uns nun die JSON-Datei erstellen, die wir in den folgenden Schritten einlesen werden.

Navigieren Sie im Datei-Explorer der WebIDE zum Verzeichnis src/main/resources.
Klicken Sie mit der rechten Maustaste auf den Ordner resources und wählen Sie "New File".
Benennen Sie die Datei data.json.
Öffnen Sie die neu erstellte Datei data.json und fügen Sie den folgenden Inhalt hinzu:

{
  "name": "John Doe",
  "age": 28,
  "email": "john.doe@example.com",
  "isEmployed": true,
  "address": {
    "street": "123 Main St",
    "city": "Anytown"
  },
  "skills": ["Java", "SQL", "JavaScript"]
}

Diese JSON-Datei repräsentiert ein Benutzerprofil. Sie enthält einfache Schlüssel-Wert-Paare (wie "name": "John Doe"), ein verschachteltes Objekt (address) und ein Array von Zeichenfolgen (skills). Speichern Sie die Datei nach dem Einfügen des Inhalts.

Sie haben nun das Projekt erfolgreich eingerichtet und die JSON-Datendatei erstellt. Im nächsten Schritt werden wir Java-Code schreiben, um diese Datei zu lesen und zu parsen.

Einlesen und Parsen einer einfachen JSON-Datei

Nachdem unsere JSON-Datei bereitsteht, können wir ein Java-Programm schreiben, um sie einzulesen. Wir verwenden dabei einen relativen Pfad. Dies ist gängige Praxis, um sicherzustellen, dass die Anwendung in verschiedenen Umgebungen portabel bleibt.

Relative Pfade verstehen

Ein relativer Pfad wird ausgehend vom aktuellen Arbeitsverzeichnis angegeben. Wenn Sie ein Maven-Projekt über das Terminal ausführen, ist das Arbeitsverzeichnis normalerweise der Stammordner des Projekts, in unserem Fall also ~/project. Daher lautet der relative Pfad zu unserer JSON-Datei src/main/resources/data.json.

Erstellen des Java JSON-Readers

Lassen Sie uns eine Java-Klasse erstellen, um die Datei zu lesen.

Navigieren Sie im Datei-Explorer der WebIDE zu src/main/java/com/labex.
Klicken Sie mit der rechten Maustaste auf den Ordner com/labex und wählen Sie "New File".
Benennen Sie die Datei JsonReader.java.
Öffnen Sie die Datei und fügen Sie den folgenden Java-Code hinzu:

package com.labex;

import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class JsonReader {
    public static void main(String[] args) {
        try {
            // Define the relative path to the JSON file
            String filePath = "src/main/resources/data.json";
            System.out.println("Reading file from: " + filePath);

            // Read the file content into a string
            String content = new String(Files.readAllBytes(Paths.get(filePath)));

            // Create a JSONObject from the string content
            JSONObject jsonObject = new JSONObject(content);

            // Access and print the values of simple keys
            String name = jsonObject.getString("name");
            int age = jsonObject.getInt("age");
            boolean isEmployed = jsonObject.getBoolean("isEmployed");

            System.out.println("\n--- Parsed JSON Data ---");
            System.out.println("Name: " + name);
            System.out.println("Age: " + age);
            System.out.println("Is Employed: " + isEmployed);

        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Error parsing JSON: " + e.getMessage());
        }
    }
}

Erläuterung des Codes

package com.labex;: Deklariert, dass diese Klasse zum Paket com.labex gehört, entsprechend den Standard-Java-Konventionen.
String filePath = "src/main/resources/data.json";: Definiert den relativen Pfad zu unserer Datei.
Files.readAllBytes(Paths.get(filePath)): Liest den gesamten Inhalt der Datei in ein Byte-Array ein, das anschließend in einen String umgewandelt wird.
new JSONObject(content): Parsed den String mit den JSON-Daten in ein JSONObject.
jsonObject.getString("name"): Ruft den String-Wert ab, der dem Schlüssel "name" zugeordnet ist. Analoge Methoden wie getInt() und getBoolean() werden für andere Datentypen verwendet.

Kompilieren und Ausführen des Programms

Lassen Sie uns nun unseren Code mit Maven kompilieren und ausführen.

Öffnen Sie das Terminal in der WebIDE.
Führen Sie den folgenden Befehl aus, um Ihre Klasse zu kompilieren und zu starten:

mvn compile exec:java -Dexec.mainClass="com.labex.JsonReader"

Sie sollten die folgende Ausgabe im Terminal sehen:

Reading file from: src/main/resources/data.json

--- Parsed JSON Data ---
Name: John Doe
Age: 28
Is Employed: true

Diese Ausgabe bestätigt, dass Ihr Programm die Datei data.json erfolgreich über den relativen Pfad gelesen und die grundlegenden Eigenschaften extrahiert hat.

Umgang mit komplexen JSON-Daten

In der Praxis enthalten JSON-Daten oft verschachtelte Strukturen, wie Objekte innerhalb von Objekten oder Arrays von Werten. Unsere Datei data.json enthält ein verschachteltes address-Objekt und ein skills-Array. Erweitern wir unser Wissen, um diese komplexen Strukturen zu parsen.

Erstellen eines komplexen JSON-Parsers

Wir erstellen eine neue Klasse, um das Parsen dieser komplexeren Teile der JSON-Datei zu demonstrieren.

Navigieren Sie im Datei-Explorer der WebIDE zu src/main/java/com/labex.
Erstellen Sie eine neue Datei namens ComplexJsonParser.java.
Fügen Sie den folgenden Code in die Datei ein:

package com.labex;

import org.json.JSONArray;
import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class ComplexJsonParser {
    public static void main(String[] args) {
        try {
            String filePath = "src/main/resources/data.json";
            String content = new String(Files.readAllBytes(Paths.get(filePath)));
            JSONObject person = new JSONObject(content);

            System.out.println("--- Parsing Complex JSON Data ---");

            // Access the nested 'address' object
            JSONObject address = person.getJSONObject("address");
            String street = address.getString("street");
            String city = address.getString("city");

            System.out.println("\nAddress:");
            System.out.println("  Street: " + street);
            System.out.println("  City: " + city);

            // Access the 'skills' array
            JSONArray skills = person.getJSONArray("skills");
            System.out.println("\nSkills:");
            for (int i = 0; i < skills.length(); i++) {
                String skill = skills.getString(i);
                System.out.println("  - " + skill);
            }

        } catch (IOException e) {
            System.out.println("Error reading file: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("Error parsing JSON: " + e.getMessage());
        }
    }
}

Erläuterung des Codes

person.getJSONObject("address"): Diese Methode ruft das verschachtelte JSON-Objekt ab, das mit dem Schlüssel "address" verknüpft ist. Sie können dann Methoden wie getString() auf diesem neuen JSONObject aufrufen.
person.getJSONArray("skills"): Diese Methode ruft das JSON-Array ab, das dem Schlüssel "skills" zugeordnet ist.
skills.length(): Gibt die Anzahl der Elemente im JSONArray zurück.
skills.getString(i): Ruft das String-Element an einem bestimmten Index i innerhalb des JSONArray ab.

Kompilieren und Ausführen des Parsers

Führen wir diese neue Klasse aus, um das Ergebnis zu sehen.

Öffnen Sie das Terminal in der WebIDE.
Führen Sie den folgenden Befehl aus:

mvn compile exec:java -Dexec.mainClass="com.labex.ComplexJsonParser"

Die erwartete Ausgabe ist:

--- Parsing Complex JSON Data ---

Address:
  Street: 123 Main St
  City: Anytown

Skills:
  - Java
  - SQL
  - JavaScript

Dies zeigt Ihre Fähigkeit, durch verschachtelte Objekte und Arrays innerhalb einer JSON-Struktur zu navigieren und Daten zu extrahieren – eine entscheidende Fertigkeit für den Umgang mit komplexen Datenfeeds und API-Antworten.

Erstellen eines wiederverwendbaren JSON-Utilities

In der Softwareentwicklung ist es bewährte Praxis, wiederverwendbaren Code zu schreiben. Anstatt die Logik zum Einlesen von Dateien in jeder Klasse zu wiederholen, können wir eine Utility-Klasse erstellen. Dieser Ansatz, bekannt als "Don't Repeat Yourself" (DRY), macht Ihren Code sauberer, wartungsfreundlicher und weniger anfällig für Fehler.

Erstellen der Klasse `JsonUtils`

Lassen Sie uns eine Hilfsklasse erstellen, die die Logik zum Lesen einer JSON-Datei kapselt.

Erstellen Sie in der WebIDE eine neue Datei namens JsonUtils.java im Verzeichnis src/main/java/com/labex.
Fügen Sie den folgenden Code hinzu:

package com.labex;

import org.json.JSONObject;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

public class JsonUtils {

    /**
     * Reads a JSON file from a relative path and parses it into a JSONObject.
     *
     * @param filePath The relative path to the JSON file.
     * @return A JSONObject representing the file's content.
     * @throws IOException if an I/O error occurs reading from the file.
     */
    public static JSONObject readJsonObjectFromFile(String filePath) throws IOException {
        String content = new String(Files.readAllBytes(Paths.get(filePath)));
        return new JSONObject(content);
    }
}

Diese Klasse enthält eine einzige static Methode, readJsonObjectFromFile. Eine statische Methode gehört zur Klasse selbst und nicht zu einer Instanz. Sie können sie also direkt über den Klassennamen aufrufen (z. B. JsonUtils.readJsonObjectFromFile(...)), ohne ein Objekt erstellen zu müssen.

Verwendung der Utility-Klasse

Erstellen wir nun eine Hauptanwendungsklasse, die unser neues Utility nutzt.

Erstellen Sie in der WebIDE eine neue Datei namens Main.java im Verzeichnis src/main/java/com/labex.
Fügen Sie den folgenden Code in Main.java ein:

package com.labex;

import org.json.JSONObject;

public class Main {
    public static void main(String[] args) {
        try {
            // Use the utility class to read the JSON file
            JSONObject data = JsonUtils.readJsonObjectFromFile("src/main/resources/data.json");

            // Now we can work with the JSONObject as before
            String name = data.getString("name");
            String city = data.getJSONObject("address").getString("city");

            System.out.println("--- Data read using JsonUtils ---");
            System.out.println("Name: " + name);
            System.out.println("City: " + city);
            System.out.println("\nSuccessfully read JSON using JsonUtils.");

        } catch (Exception e) {
            System.out.println("An error occurred: " + e.getMessage());
        }
    }
}

Diese Main-Klasse ist deutlich übersichtlicher. Sie delegiert die Aufgabe des Lesens und Parsens an JsonUtils und konzentriert sich nur darauf, was mit dem resultierenden JSONObject geschehen soll.

Ausführen der Hauptanwendung

Führen wir abschließend unsere Main-Klasse aus.

Öffnen Sie das Terminal in der WebIDE.
Führen Sie den folgenden Befehl aus:

mvn compile exec:java -Dexec.mainClass="com.labex.Main"

Sie sehen die folgende Ausgabe:

--- Data read using JsonUtils ---
Name: John Doe
City: Anytown

Successfully read JSON using JsonUtils.

Durch die Erstellung einer Utility-Klasse haben Sie Ihren Code modularer und wiederverwendbarer gestaltet, was ein Kernprinzip effektiver Softwareentwicklung ist.

Zusammenfassung

In diesem Praktikum haben Sie praktische Fertigkeiten für den Umgang mit JSON-Dateien in Java erworben. Sie haben sich vom grundlegenden Setup bis hin zu fortgeschrittenen Parsing-Techniken vorgearbeitet und schließlich wiederverwendbaren Code erstellt.

Hier ist eine Zusammenfassung dessen, was Sie gelernt haben:

Projekt-Setup: Sie haben gelernt, wie man ein Maven-Projekt strukturiert und externe Bibliotheken wie org.json einbindet.
Erstellung von JSON-Dateien: Sie haben eine wohlgeformte JSON-Datei mit verschiedenen Datentypen erstellt, darunter Strings, Zahlen, Booleans, verschachtelte Objekte und Arrays.
Lesen über einen relativen Pfad: Sie haben erfolgreich eine Datei über einen relativen Pfad eingelesen, eine Technik, die Anwendungen portabler macht.
Parsen von JSON: Sie haben die Bibliothek org.json verwendet, um JSON-Strings in JSONObject- und JSONArray-Objekte umzuwandeln, was den programmatischen Zugriff auf die Daten ermöglicht.
Umgang mit komplexen Strukturen: Sie haben gelernt, durch verschachtelte JSON-Objekte zu navigieren und über JSON-Arrays zu iterieren, um komplexe Daten zu extrahieren.
Wiederverwendbarkeit von Code: Sie haben das DRY-Prinzip (Don't Repeat Yourself) angewendet, indem Sie eine JsonUtils-Klasse zur Kapselung der Dateilese-Logik erstellt haben, was zu saubererem und wartungsfreundlicherem Code führt.

Die Fähigkeit, JSON-Daten zu lesen, zu parsen und zu manipulieren, ist für jeden Java-Entwickler, der mit Webdiensten, API-Integrationen oder Anwendungskonfigurationen arbeitet, unerlässlich. Das Fundament, das Sie in diesem Praktikum gelegt haben, wird bei künftigen, komplexeren Entwicklungsaufgaben von unschätzbarem Wert sein.

Einlesen von JSON-Dateien über relative Pfade in Java

Einführung

Projekt-Setup und Erstellung der JSON-Datei

Die Projektstruktur verstehen

Erstellen der JSON-Datendatei

Einlesen und Parsen einer einfachen JSON-Datei

Relative Pfade verstehen

Erstellen des Java JSON-Readers

Erläuterung des Codes

Kompilieren und Ausführen des Programms

Umgang mit komplexen JSON-Daten

Erstellen eines komplexen JSON-Parsers

Erläuterung des Codes

Kompilieren und Ausführen des Parsers

Erstellen eines wiederverwendbaren JSON-Utilities

Erstellen der Klasse JsonUtils

Verwendung der Utility-Klasse

Ausführen der Hauptanwendung

Zusammenfassung

Erstellen der Klasse `JsonUtils`