Konvertieren Sie mit SnakeYAML ein YAML-Array in eine Java-Liste

Einleitung

YAML ist nachher eine der beliebtesten Datenserialisierungssprachen JSON. Daher wird es manchmal auch als bezeichnet streng Obermenge von JSON. Es wurde von Anfang an auf menschliche Interaktion und Lesbarkeit ausgelegt und ist daher für seine Einfachheit bekannt. Es wurde im Hinblick auf Flexibilität und Zugänglichkeit entwickelt, sodass es mit allen modernen Programmiersprachen und einem leistungsstarken Format zum Schreiben von Konfigurationsdateien funktioniert. Es wird auch für Datenpersistenz, Internet-Messaging, sprachübergreifende Datenfreigabe und viele weitere Optionen verwendet.

YAML wurde 2001 gestartet und hieß „Noch eine Markup-Sprache" zu dieser Zeit. Aber später wurde es markenrechtlich geschützt als „YAML ist keine Auszeichnungssprache“. Die Grundstruktur einer YAML-Datei ist a Karte. Es ist auch als Wörterbuch, Hash (Map) oder einfach objektbasiert bekannt, je nach Programmiersprache, die wir verwenden.

Leerzeichen und Einrückungen werden in YAML-Dateien verwendet, um Verschachtelungen zu kennzeichnen.

YAML-Syntax

Ein YAML-Format verwendet hauptsächlich 3 Knotentypen:

• Karten/Wörterbücher: A Karte Der Inhalt des Knotens ist eine ungeordnete Sammlung von Schlüsselwert Knoten Paare, mit der Anforderung, dass jeder Schlüssel unterschiedlich sein muss. Den Knoten werden durch YAML keine weiteren Beschränkungen auferlegt.
• Arrays/Listen: Ein Array Der Inhalt des Knotens ist eine geordnete Sammlung von null oder mehr Knoten. Eine Sequenz kann insbesondere denselben Knoten mehrfach enthalten. Es kann sogar sich selbst enthalten.
• Literale (Zeichenfolgen, Zahlen, boolesche Werte usw.): Eine Folge von Null oder mehr Unicode-Zeichen kann verwendet werden, um die undurchsichtigen Daten darzustellen, aus denen a besteht Skalar Inhalt des Knotens.

In diesem Artikel werden wir uns speziell mit der Konvertierung von YAML-Array-Inhalten in eine Liste in Java befassen. Es gibt viele Open-Source-Bibliotheken, aber die beliebtesten von ihnen sind Jackson und SchlangeYAML. In diesem Leitfaden verwenden wir SnakeYaml als unsere Bibliothek, um den YAML-Inhalt zu parsen.

SnakeYaml

SchlangeYAML ist ein YAML-Parsing-Paket, das eine High-Level-API für die Serialisierung und Deserialisierung von YAML-Dokumenten bietet. Der Einstiegspunkt für SnakeYAML ist die Yaml Klasse. Die Dokumente oder die YAML-Dateien können mit geladen werden load() Methode oder im Batch über die loadAll() Methode. Die Methoden nehmen auch echte YAML-Daten in Form von String-Objekten entgegen InputStreams, was ein typischer Dateityp ist.

Angenommen : Struktur, die YAML-Dateien eigen ist, mit der SnakeYAML natürlich gut funktioniert Java-Karten, aber wir können auch unique verwenden Java-Objekte.

Um die Bibliothek in unser Projekt aufzunehmen, fügen Sie die folgende Abhängigkeit zu Ihrer hinzu pom.xml Datei:

<dependencies>
    <dependency>
        <groupId>org.yaml</groupId>
        <artifactId>snakeyaml</artifactId>
        <version>1.33</version>
    </dependency>
</dependencies>

Oder wenn Sie Gradle verwenden:

compile group: 'org.yaml', name: 'snakeyaml', version: '1.33'

Lesen eines einfachen YAML-Arrays

Beginnen wir schnell mit dem Lesen eines einfachen Arrays aus einer YAML-Datei. Bedenken Sie, dass wir eine Yaml-Datei mit den folgenden Daten im Ressourcenordner unseres Java-Projekts haben:

- One
- Two
- Three
- Four

Dann können wir den Dateiinhalt als InputStream. Als nächstes konstruieren wir die Yaml -Instanz, die dann als Einstiegspunkt für den Zugriff auf die Bibliothek und das Objekt fungiert, um den Inhalt der YAML-Datei programmgesteuert darzustellen. Das load() -Methode ermöglicht es uns, alle zu lesen und zu analysieren InputStream mit gültigen YAML-Daten:

public void readYamlWithArray() {
    InputStream inputStream = this.getClass()
            .getClassLoader()
            .getResourceAsStream("number.yml");
    Yaml yaml = new Yaml();
    List data = yaml.load(inputStream);
    System.out.println(data);
 }

Die Methode gibt ein Java zurück List von String-Daten. Wenn wir die drucken data dann ergibt sich folgendes Ergebnis:

[One, Two, Three, Four]

Lesen eines gruppierten YAML-Arrays

Manchmal möchten wir ein Array von Inhalten für einen bestimmten Schlüssel definieren. Dies wird Gruppieren von Arrays in einem YAML-Zuordnungsknoten genannt. Eine Beispiel-YAML dieser Art sieht wie folgt aus:

languages:
  - Java
  - JavaScript
  - Python
  - Golang
  - Perl
  - Shell
  - Scala

Dies kann als Java betrachtet werden Map mit a : wobei der Wert ein ist Array. Die Daten werden also weiterhin geladen InputStream wie wir oben definiert haben. Aber die data muss definiert werden als Map of List of Strings:

public void readYamlWithArrayGroup() {
    InputStream inputStream = this.getClass()
            .getClassLoader()
            .getResourceAsStream("language.yml");
    Yaml yaml = new Yaml();
    Map<String, List> data = yaml.load(inputStream);
    System.out.println(data);
    
    data.values()
            .stream()
            .collect(Collectors.toList())
            .get(0)
            .forEach(System.out::println);
}

Wenn wir jetzt unsere lesen data, das würde ungefähr so ​​aussehen:

{languages=[Java, JavaScript, Python, Golang, Perl, Shell, Scala]}
Java
JavaScript
Python
Golang
Perl
Shell
Scala

Lesen eines mehrzeiligen YAML-Arrays von Arrays

Manchmal stoßen wir auf eine YAML-Datei mit Daten, die ein Array von Arrays enthalten. Zum Beispiel gruppieren wir die Kurse und stellen sie als Array von Arrays wie unten dar:

courses:
  - - C
    - Java
    - Data Structures
    - Algorithms
  - - Big Data
    - Spark
    - Kafka
    - Machine Learning

Dies kann als Java geparst werden Map of List of List of String. Wir können die wieder laden InputStream wie wir es früher getan haben. Aber die Daten werden wie folgt geladen:

public void readYamlWithMultiLineArrayGroup() {
    InputStream inputStream = this.getClass()
            .getClassLoader()
            .getResourceAsStream("courses.yml");
    Yaml yaml = new Yaml();
    
    Map<String, List<List>> data = yaml.load(inputStream);
    System.out.println(data);
    
    System.out.println("First Array Group:");
    data.values()
            .stream()
            .collect(Collectors.toList())
            .get(0)
            .get(0)
            .forEach(System.out::println);
    
    System.out.println("nSecond Array Group:");
    data.values()
            .stream()
            .collect(Collectors.toList())
            .get(0)
            .get(1)
            .forEach(System.out::println);
}

Wenn wir also drucken data, es würde in etwa so aussehen:

{courses=[[C, Java, Data Structures, Algorithms], [Big Data, Spark, Kafka, Machine Learning]]}

First Array Group:
C
Java
Data Structures
Algorithms

Second Array Group:
Big Data
Spark
Kafka
Machine Learning

Lesen eines komplex verschachtelten YAML-Inhalts als Java Bean

Wir haben gesehen, wie wir den Inhalt des Array-Typs separat handhaben können, aber mit komplexen verschachtelten YAML-Dateien – eine Karte von Karten mit Listen von Listen zu haben, ist schwer intuitiv zu analysieren und schwierig zu handhaben. Selbst im letzten Beispiel, wo wir nur zwei verschachtelte Listen hatten, wird die Behandlung als Listen ziemlich ausführlich.

In diesen Fällen ist es am besten, ein POJO zu erstellen, das den verschachtelten YAML-Daten zugeordnet werden kann. Lassen Sie uns zuerst eine Beispiel-YAML erstellen, die den verschachtelten Inhalt einer Website enthält:

website: stackabuse
skills:
  - python
  - javascript
  - java
  - unix
  - machine learning
  - web development
tutorials:
  - graphs:
      name: Graphs in Python - Theory and Implementation
      tags:
        - python
        - data structures
        - algorithm
      contributors:
        - David Landup
        - Dimitrije Stamenic
        - Jovana Ninkovic
      last_updated: June 2022
  - git:
      name: Git Essentials - Developer's Guide to Git
      tags:
        - git
      contributors:
        - David Landup
        - François Dupire
        - Jovana Ninkovic
      last_updated: April 2022
  - deep learning:
      name: Practical Deep Learning for Computer Vision with Python
      tags:
        - python
        - machine learning
        - tensorflow
        - computer vision
      contributors:
        - David Landup
        - Jovana Ninkovic
      last_updated: October 2022
published: true

Wir müssen eine übergeordnete Java-Klasse definieren WebsiteContent das wird bestehen aus List von Fähigkeiten und a List of Map von Tutorials, die wieder Listen von Tags und Mitwirkenden enthalten werden:

public class WebsiteContent {
    private String website;
    private List skills;
    private List<Map> tutorials;
    private Boolean published;

    

    @Override
    public String toString() {
        return "WebsiteContent{" +
                "website='" + website + ''' +
                ", skills=" + skills +
                ", tutorials=" + tutorials +
                ", published=" + published +
                '}';
    }
}

public class Tutorial {

    private String name;
    private List tags;
    private List contributors;
    private String lastUpdated;

    

    @Override
    public String toString() {
        return "Tutorial{" +
                "name='" + name + ''' +
                ", tags=" + tags +
                ", contributors=" + contributors +
                ", lastUpdated='" + lastUpdated + ''' +
                '}';
    }
}

Jetzt können wir wieder die Daten aus der Datei als laden InputStream wie wir es früher getan haben. Als nächstes erstellen wir unsere Yaml -Klassenobjekt müssen wir den Datentyp angeben, in den wir die Daten umwandeln möchten. Das new Constructor(WebsiteContent.class) weist SnakeYAML an, die Daten aus der YAML-Datei zu lesen, um sie unserer zuzuordnen WebsiteContent Objekt.

Die Zuordnung ist einfach und die Namen unserer Objektattribute müssen mit den Namen der YAML-Attribute übereinstimmen.

public void readYamlAsBeanWithNestedArrays(){
    
    InputStream inputStream = this.getClass()
            .getClassLoader()
            .getResourceAsStream("website_content.yml");
            
    
    Yaml yaml = new Yaml(new Constructor(WebsiteContent.class));
    WebsiteContent data = yaml.load(inputStream);
    
    
    System.out.println(data);
    System.out.println("nList of Skills: ");
    data.getSkills().stream().forEach(System.out::println);
    System.out.println("nList of Tutorials: ");
    data.getTutorials().stream().forEach(System.out::println);
}

Schließlich, wenn wir die drucken data, es würde in etwa so aussehen:

WebsiteContent{website='stackabuse', skills=[python, javascript, java, unix, machine learning, web development], tutorials=[{graphs={name=Graphs in Python - Theory and Implementation, tags=[python, data structures, algorithm], contributors=[David Landup, Dimitrije Stamenic, Jovana Ninkovic], last_updated=June 2022}}, {git={name=Git Essentials - Developer's Guide to Git, tags=[git], contributors=[David Landup, François Dupire, Jovana Ninkovic], last_updated=April 2022}}, {deep learning={name=Practical Deep Learning for Computer Vision with Python, tags=[python, machine learning, tensorflow, computer vision], contributors=[David Landup, Jovana Ninkovic], last_updated=October 2022}}], published=true}

List of Skills: 
python
javascript
java
unix
machine learning
web development

List of Tutorials: 
{graphs={name=Graphs in Python - Theory and Implementation, tags=[python, data structures, algorithm], contributors=[David Landup, Dimitrije Stamenic, Jovana Ninkovic], last_updated=June 2022}}
{git={name=Git Essentials - Developer's Guide to Git, tags=[git], contributors=[David Landup, François Dupire, Jovana Ninkovic], last_updated=April 2022}}
{deep learning={name=Practical Deep Learning for Computer Vision with Python, tags=[python, machine learning, tensorflow, computer vision], contributors=[David Landup, Jovana Ninkovic], last_updated=October 2022}}

Wie wir sehen können, hat SnakeYaml die Datei erfolgreich analysiert und konvertiert WebsiteContent Objekt und behielt das Erbe und die Assoziation mit Tutorial Objekt intakt.

Zusammenfassung

Da YAML-Dateien häufig für DevOps- und konfigurationsbezogene Daten verwendet werden, ist es sehr nützlich, die Daten mithilfe von Code zu analysieren und zu manipulieren.

SnakeYAML ermöglicht uns die einfache Verwaltung von YAML-Dateien in unserem Java-Projekt, und es erfordert nur ein wenig Code, um YAML-Dateien in unser Projekt zu laden oder Daten in YAML-Dateien zu schreiben. Darüber hinaus bietet SnakeYAML Formatierungsoptionen, sodass Sie es an unsere Bedürfnisse anpassen und personalisieren können.