Parsen von YAML in Java mit der SnakeYAML-Library

YAML (YAML Ain’t Markup Language) ist ein weit verbreitetes Datenserialisierungsformat, das für seine Einfachheit und Lesbarkeit bekannt ist. Es wird häufig in Konfigurationsdateien und Datenaustauschformaten verwendet. In Java ist die SnakeYAML-Bibliothek eine der beliebtesten Optionen zum Parsen und Erstellen von YAML-Dateien. In diesem Artikel werden wir uns eingehend mit dem Parsen von YAML in Java mit SnakeYAML befassen, einschließlich Installation, grundlegender Verwendung und fortgeschrittenerer Techniken.

1. Einführung in SnakeYAML

SnakeYAML ist eine Open-Source-Bibliothek, die von Andrey Somov entwickelt wurde und umfassende Unterstützung für YAML 1.1 und 1.2 bietet. Die Bibliothek ist leistungsfähig, flexibel und leicht zu verwenden, was sie zu einer ausgezeichneten Wahl für Java-Entwickler macht, die mit YAML arbeiten möchten.

2. Installation von SnakeYAML

Bevor wir mit dem Parsen von YAML-Daten beginnen können, müssen wir die SnakeYAML-Bibliothek in unser Java-Projekt einbinden. Die einfachste Möglichkeit, dies zu tun, ist die Verwendung eines Build-Tools wie Maven oder Gradle.

2.1 Maven

Fügen Sie die folgende Abhängigkeit zu Ihrer pom.xml hinzu:

<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>1.30</version>
</dependency>Code-Sprache: HTML, XML (xml)

2.2 Gradle

Fügen Sie die folgende Abhängigkeit zu Ihrem build.gradle hinzu:

implementation 'org.yaml:snakeyaml:1.30'Code-Sprache: JavaScript (javascript)

3. Grundlagen des Parsens von YAML

Nachdem die Bibliothek installiert ist, können wir mit dem Parsen von YAML-Daten beginnen. Im einfachsten Fall möchten wir eine YAML-Datei oder einen YAML-String in eine Java-Map oder ein anderes Java-Objekt umwandeln.

3.1 Parsen von YAML in eine Map

Hier ist ein einfaches Beispiel, das zeigt, wie man einen YAML-String in eine Map<String, Object> parsen kann:

import org.yaml.snakeyaml.Yaml;
import java.util.Map;

public class YamlParserExample {
    public static void main(String[] args) {
        String yamlString = "name: John Doe\nage: 30\naddress:\n  street: 123 Main St\n  city: Anytown";

        Yaml yaml = new Yaml();
        Map<String, Object> data = yaml.load(yamlString);

        System.out.println(data);
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel wird der YAML-String erfolgreich in eine Map<String, Object> konvertiert, die die hierarchische Struktur der YAML-Daten beibehält.

3.2 Parsen von YAML aus einer Datei

Wenn Sie YAML-Daten aus einer Datei parsen möchten, können Sie die Datei einfach in einen InputStream laden und die Yaml-Klasse verwenden, um die Daten zu parsen:

import org.yaml.snakeyaml.Yaml;

import java.io.InputStream;
import java.util.Map;

public class YamlFileParserExample {
    public static void main(String[] args) {
        Yaml yaml = new Yaml();

        try (InputStream inputStream = YamlFileParserExample.class.getClassLoader().getResourceAsStream("config.yaml")) {
            if (inputStream == null) {
                throw new IllegalArgumentException("File not found!");
            }

            Map<String, Object> data = yaml.load(inputStream);
            System.out.println(data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel wird eine Datei namens config.yaml aus dem Klassenpfad geladen und geparst.

4. Erweiterte Verwendung von SnakeYAML

Neben dem Parsen in Maps kann SnakeYAML auch YAML-Daten direkt in benutzerdefinierte Java-Klassen umwandeln. Dies ist besonders nützlich, wenn Sie stark typisierte Konfigurationsdaten benötigen.

4.1 YAML in benutzerdefinierte Java-Objekte umwandeln

Nehmen wir an, wir haben die folgende YAML-Datei:

person:
  name: John Doe
  age: 30
  address:
    street: 123 Main St
    city: Anytown

Und die folgenden Java-Klassen, um diese Daten darzustellen:

public class Person {
    private String name;
    private int age;
    private Address address;

    // Getter und Setter
}

public class Address {
    private String street;
    private String city;

    // Getter und Setter
}Code-Sprache: PHP (php)

Wir können nun SnakeYAML verwenden, um die YAML-Daten direkt in eine Instanz der Person-Klasse zu laden:

import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.constructor.Constructor;

import java.io.InputStream;

public class YamlToJavaObjectExample {
    public static void main(String[] args) {
        Yaml yaml = new Yaml(new Constructor(Person.class));

        try (InputStream inputStream = YamlToJavaObjectExample.class.getClassLoader().getResourceAsStream("person.yaml")) {
            if (inputStream == null) {
                throw new IllegalArgumentException("File not found!");
            }

            Person person = yaml.load(inputStream);
            System.out.println(person);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel verwenden wir einen benutzerdefinierten Constructor, um anzugeben, dass die Wurzel des YAML-Dokuments eine Instanz der Person-Klasse sein soll. SnakeYAML mappt die YAML-Daten automatisch auf die entsprechenden Felder der Person– und Address-Klassen.

5. Konfigurieren von SnakeYAML

SnakeYAML bietet verschiedene Konfigurationsoptionen, um das Parsen und Erstellen von YAML-Daten anzupassen. Beispielsweise können Sie benutzerdefinierte Konstruktoren, Representer und Dumper konfigurieren.

5.1 Anpassen des Parsens mit Tags und Konstruktoren

Sie können benutzerdefinierte Tags und Konstruktoren verwenden, um spezielle Objekttypen zu verarbeiten. Hier ist ein Beispiel, das zeigt, wie man einen benutzerdefinierten Konstruktor für ein spezielles Tag definiert:

import org.yaml.snakeyaml.Yaml;
import org.yaml.snakeyaml.constructor.Constructor;
import org.yaml.snakeyaml.nodes.Tag;

public class CustomConstructorExample {
    public static void main(String[] args) {
        Constructor constructor = new Constructor();
        constructor.addTypeDescription(new TypeDescription(CustomType.class, new Tag("!custom")));

        Yaml yaml = new Yaml(constructor);

        String yamlString = "!custom\n  name: Custom Object\n  value: 42";
        CustomType customObject = yaml.load(yamlString);

        System.out.println(customObject);
    }
}

public class CustomType {
    private String name;
    private int value;

    // Getter und Setter

    @Override
    public String toString() {
        return "CustomType{name='" + name + "', value=" + value + '}';
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel definieren wir einen benutzerdefinierten Typ CustomType und verwenden einen benutzerdefinierten Konstruktor, um Instanzen dieses Typs zu erstellen, wenn das !custom-Tag im YAML-Dokument gefunden wird.

6. Schreiben von YAML

Neben dem Parsen kann SnakeYAML auch verwendet werden, um Java-Objekte in YAML-Dokumente zu serialisieren. Hier ist ein einfaches Beispiel, das zeigt, wie man eine Map in einen YAML-String umwandelt:

import org.yaml.snakeyaml.DumperOptions;
import org.yaml.snakeyaml.Yaml;

import java.util.HashMap;
import java.util.Map;

public class YamlSerializationExample {
    public static void main(String[] args) {
        Map<String, Object> data = new HashMap<>();
        data.put("name", "John Doe");
        data.put("age", 30);

        Map<String, String> address = new HashMap<>();
        address.put("street", "123 Main St");
        address.put("city", "Anytown");
        data.put("address", address);

        DumperOptions options = new DumperOptions();
        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);

        Yaml yaml = new Yaml(options);
        String yamlString = yaml.dump(data);

        System.out.println(yamlString);
    }
}Code-Sprache: JavaScript (javascript)

In diesem Beispiel erstellen wir eine Map und serialisieren sie in einen YAML-String. Die DumperOptions-Klasse wird verwendet, um die Ausgabeformatierung zu konfigurieren.

Fazit

SnakeYAML ist eine mächtige und flexible Bibliothek für das Arbeiten mit YAML in Java. Sie bietet umfassende Funktionen zum Parsen und Erstellen von YAML-Dokumenten und lässt sich leicht in verschiedene Java-Anwendungen integrieren. In diesem Artikel haben wir die grundlegenden und erweiterten Verwendungsmöglichkeiten von SnakeYAML behandelt, einschließlich der Konfiguration und Anpassung der Bibliothek. Mit diesem Wissen sind Sie gut gerüstet, um YAML-Daten in Ihren Java-Projekten effektiv zu verwenden.