{"id":461,"date":"2024-06-22T16:03:01","date_gmt":"2024-06-22T15:03:01","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=461"},"modified":"2024-07-04T16:03:21","modified_gmt":"2024-07-04T15:03:21","slug":"parsen-von-yaml-in-java-mit-der-snakeyaml-library","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=461","title":{"rendered":"Parsen von YAML in Java mit der SnakeYAML-Library"},"content":{"rendered":"\n

YAML (YAML Ain’t Markup Language) ist ein weit verbreitetes Datenserialisierungsformat, das f\u00fcr seine Einfachheit und Lesbarkeit bekannt ist. Es wird h\u00e4ufig 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\u00dflich Installation, grundlegender Verwendung und fortgeschrittenerer Techniken.<\/p>\n\n\n\n

1. Einf\u00fchrung in SnakeYAML<\/h2>\n\n\n\n

SnakeYAML ist eine Open-Source-Bibliothek, die von Andrey Somov entwickelt wurde und umfassende Unterst\u00fctzung f\u00fcr YAML 1.1 und 1.2 bietet. Die Bibliothek ist leistungsf\u00e4hig, flexibel und leicht zu verwenden, was sie zu einer ausgezeichneten Wahl f\u00fcr Java-Entwickler macht, die mit YAML arbeiten m\u00f6chten.<\/p>\n\n\n\n

2. Installation von SnakeYAML<\/h2>\n\n\n\n

Bevor wir mit dem Parsen von YAML-Daten beginnen k\u00f6nnen, m\u00fcssen wir die SnakeYAML-Bibliothek in unser Java-Projekt einbinden. Die einfachste M\u00f6glichkeit, dies zu tun, ist die Verwendung eines Build-Tools wie Maven oder Gradle.<\/p>\n\n\n\n

2.1 Maven<\/h3>\n\n\n\n

F\u00fcgen Sie die folgende Abh\u00e4ngigkeit zu Ihrer pom.xml<\/code> hinzu:<\/p>\n\n\n

<dependency<\/span>><\/span>\n    <groupId<\/span>><\/span>org.yaml<\/groupId<\/span>><\/span>\n    <artifactId<\/span>><\/span>snakeyaml<\/artifactId<\/span>><\/span>\n    <version<\/span>><\/span>1.30<\/version<\/span>><\/span>\n<\/dependency<\/span>><\/span><\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
2.2 Gradle<\/h3>\n\n\n\n
F\u00fcgen Sie die folgende Abh\u00e4ngigkeit zu Ihrem build.gradle<\/code> hinzu:<\/p>\n\n\n
implementation 'org.yaml:snakeyaml:1.30'<\/span><\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
3. Grundlagen des Parsens von YAML<\/h2>\n\n\n\n
Nachdem die Bibliothek installiert ist, k\u00f6nnen wir mit dem Parsen von YAML-Daten beginnen. Im einfachsten Fall m\u00f6chten wir eine YAML-Datei oder einen YAML-String in eine Java-Map oder ein anderes Java-Objekt umwandeln.<\/p>\n\n\n\n
3.1 Parsen von YAML in eine Map<\/h3>\n\n\n\n
Hier ist ein einfaches Beispiel, das zeigt, wie man einen YAML-String in eine Map<String, Object><\/code> parsen kann:<\/p>\n\n\n
import<\/span> org.yaml.snakeyaml.Yaml;\nimport<\/span> java.util.Map;\n\npublic class<\/span> YamlParserExample<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        String<\/span> yamlString = \"name: John Doe\\nage: 30\\naddress:\\n  street: 123 Main St\\n  city: Anytown\"<\/span>;\n\n        Yaml yaml = new<\/span> Yaml();\n        Map<\/span><String<\/span>, Object<\/span>> data = yaml.load(yamlString);\n\n        System.out.println(data);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel wird der YAML-String erfolgreich in eine Map<String, Object><\/code> konvertiert, die die hierarchische Struktur der YAML-Daten beibeh\u00e4lt.<\/p>\n\n\n\n
3.2 Parsen von YAML aus einer Datei<\/h3>\n\n\n\n
Wenn Sie YAML-Daten aus einer Datei parsen m\u00f6chten, k\u00f6nnen Sie die Datei einfach in einen InputStream<\/code> laden und die Yaml<\/code>-Klasse verwenden, um die Daten zu parsen:<\/p>\n\n\n
import<\/span> org.yaml.snakeyaml.Yaml;\n\nimport<\/span> java.io.InputStream;\nimport<\/span> java.util.Map;\n\npublic class<\/span> YamlFileParserExample<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        Yaml yaml = new<\/span> Yaml();\n\n        try<\/span> (InputStream inputStream = YamlFileParserExample.class.getClassLoader().getResourceAsStream(\"config.yaml\"<\/span>)) {\n            if<\/span> (inputStream == null<\/span>) {\n                throw<\/span> new<\/span> IllegalArgumentException(\"File not found!\"<\/span>);\n            }\n\n            Map<\/span><String<\/span>, Object<\/span>> data = yaml.load(inputStream);\n            System.out.println(data);\n        } catch<\/span> (Exception e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel wird eine Datei namens config.yaml<\/code> aus dem Klassenpfad geladen und geparst.<\/p>\n\n\n\n
4. Erweiterte Verwendung von SnakeYAML<\/h2>\n\n\n\n
Neben dem Parsen in Maps kann SnakeYAML auch YAML-Daten direkt in benutzerdefinierte Java-Klassen umwandeln. Dies ist besonders n\u00fctzlich, wenn Sie stark typisierte Konfigurationsdaten ben\u00f6tigen.<\/p>\n\n\n\n
4.1 YAML in benutzerdefinierte Java-Objekte umwandeln<\/h3>\n\n\n\n
Nehmen wir an, wir haben die folgende YAML-Datei:<\/p>\n\n\n
person:\n  name: John Doe\n  age: 30\n  address:\n    street: 123 Main St\n    city: Anytown<\/code><\/span><\/pre>\n\n\n
Und die folgenden Java-Klassen, um diese Daten darzustellen:<\/p>\n\n\n
public<\/span> class<\/span> Person<\/span> <\/span>{\n    private<\/span> String name;\n    private<\/span> int age;\n    private<\/span> Address address;\n\n    \/\/ Getter und Setter<\/span>\n}\n\npublic<\/span> class<\/span> Address<\/span> <\/span>{\n    private<\/span> String street;\n    private<\/span> String city;\n\n    \/\/ Getter und Setter<\/span>\n}<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n\n
Wir k\u00f6nnen nun SnakeYAML verwenden, um die YAML-Daten direkt in eine Instanz der Person<\/code>-Klasse zu laden:<\/p>\n\n\n
import<\/span> org.yaml.snakeyaml.Yaml;\nimport<\/span> org.yaml.snakeyaml.constructor.Constructor;\n\nimport<\/span> java.io.InputStream;\n\npublic class<\/span> YamlToJavaObjectExample<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        Yaml yaml = new<\/span> Yaml(new<\/span> Constructor(Person.class));\n\n        try<\/span> (InputStream inputStream = YamlToJavaObjectExample.class.getClassLoader().getResourceAsStream(\"person.yaml\"<\/span>)) {\n            if<\/span> (inputStream == null<\/span>) {\n                throw<\/span> new<\/span> IllegalArgumentException(\"File not found!\"<\/span>);\n            }\n\n            Person person = yaml.load(inputStream);\n            System.out.println(person);\n        } catch<\/span> (Exception e) {\n            e.printStackTrace();\n        }\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel verwenden wir einen benutzerdefinierten Constructor<\/code>, um anzugeben, dass die Wurzel des YAML-Dokuments eine Instanz der Person<\/code>-Klasse sein soll. SnakeYAML mappt die YAML-Daten automatisch auf die entsprechenden Felder der Person<\/code>– und Address<\/code>-Klassen.<\/p>\n\n\n\n
5. Konfigurieren von SnakeYAML<\/h2>\n\n\n\n
SnakeYAML bietet verschiedene Konfigurationsoptionen, um das Parsen und Erstellen von YAML-Daten anzupassen. Beispielsweise k\u00f6nnen Sie benutzerdefinierte Konstruktoren, Representer und Dumper konfigurieren.<\/p>\n\n\n\n
5.1 Anpassen des Parsens mit Tags und Konstruktoren<\/h3>\n\n\n\n
Sie k\u00f6nnen benutzerdefinierte Tags und Konstruktoren verwenden, um spezielle Objekttypen zu verarbeiten. Hier ist ein Beispiel, das zeigt, wie man einen benutzerdefinierten Konstruktor f\u00fcr ein spezielles Tag definiert:<\/p>\n\n\n
import<\/span> org.yaml.snakeyaml.Yaml;\nimport<\/span> org.yaml.snakeyaml.constructor.Constructor;\nimport<\/span> org.yaml.snakeyaml.nodes.Tag;\n\npublic class<\/span> CustomConstructorExample<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        Constructor constructor<\/span> = new Constructor();\n        constructor<\/span>.addTypeDescription(new TypeDescription(CustomType.class, new Tag(\"!custom\")));\n\n        Yaml yaml = new Yaml(constructor<\/span>);\n\n        String yamlString = \"!custom\\n  name: Custom Object\\n  value: 42\";\n        CustomType customObject = yaml.load(yamlString);\n\n        System.out.println(customObject);\n    }\n}\n\npublic class CustomType {\n    private String<\/span> name;\n    private int value;\n\n    \/\/ Getter und Setter<\/span>\n\n    @Override\n    public String<\/span> toString() {\n        return<\/span> \"CustomType{name='\"<\/span> + name + \"', value=\"<\/span> + value + '}'<\/span>;\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel definieren wir einen benutzerdefinierten Typ CustomType<\/code> und verwenden einen benutzerdefinierten Konstruktor, um Instanzen dieses Typs zu erstellen, wenn das !custom<\/code>-Tag im YAML-Dokument gefunden wird.<\/p>\n\n\n\n
6. Schreiben von YAML<\/h2>\n\n\n\n
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<\/code> in einen YAML-String umwandelt:<\/p>\n\n\n
import<\/span> org.yaml.snakeyaml.DumperOptions;\nimport<\/span> org.yaml.snakeyaml.Yaml;\n\nimport<\/span> java.util.HashMap;\nimport<\/span> java.util.Map;\n\npublic class<\/span> YamlSerializationExample<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        Map<\/span><String<\/span>, Object<\/span>> data = new<\/span> HashMap<>();\n        data.put(\"name\"<\/span>, \"John Doe\"<\/span>);\n        data.put(\"age\"<\/span>, 30<\/span>);\n\n        Map<\/span><String<\/span>, String<\/span>> address = new<\/span> HashMap<>();\n        address.put(\"street\"<\/span>, \"123 Main St\"<\/span>);\n        address.put(\"city\"<\/span>, \"Anytown\"<\/span>);\n        data.put(\"address\"<\/span>, address);\n\n        DumperOptions options = new<\/span> DumperOptions();\n        options.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);\n\n        Yaml yaml = new<\/span> Yaml(options);\n        String<\/span> yamlString = yaml.dump(data);\n\n        System.out.println(yamlString);\n    }\n}<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
In diesem Beispiel erstellen wir eine Map<\/code> und serialisieren sie in einen YAML-String. Die DumperOptions<\/code>-Klasse wird verwendet, um die Ausgabeformatierung zu konfigurieren.<\/p>\n\n\n\n
Fazit<\/h2>\n\n\n\n
SnakeYAML ist eine m\u00e4chtige und flexible Bibliothek f\u00fcr das Arbeiten mit YAML in Java. Sie bietet umfassende Funktionen zum Parsen und Erstellen von YAML-Dokumenten und l\u00e4sst sich leicht in verschiedene Java-Anwendungen integrieren. In diesem Artikel haben wir die grundlegenden und erweiterten Verwendungsm\u00f6glichkeiten von SnakeYAML behandelt, einschlie\u00dflich der Konfiguration und Anpassung der Bibliothek. Mit diesem Wissen sind Sie gut ger\u00fcstet, um YAML-Daten in Ihren Java-Projekten effektiv zu verwenden.<\/p>\n","protected":false},"excerpt":{"rendered":"
YAML (YAML Ain’t Markup Language) ist ein weit verbreitetes Datenserialisierungsformat, das f\u00fcr seine Einfachheit und Lesbarkeit bekannt ist. Es wird h\u00e4ufig 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 […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-461","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/461","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=461"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/461\/revisions"}],"predecessor-version":[{"id":462,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/461\/revisions\/462"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=461"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=461"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=461"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}