Converti l'array YAML in un elenco Java con SnakeYAML

Introduzione

Yamla è uno dei linguaggi di serializzazione dei dati più popolari dopo JSON. Pertanto, a volte è chiamato come a rigoroso superinsieme di JSON. È stato progettato per l'interazione umana e la leggibilità sin dall'inizio, quindi è noto per la sua semplicità. È progettato pensando alla flessibilità e all'accessibilità, quindi funziona con tutti i moderni linguaggi di programmazione e un formato potente per la scrittura di file di configurazione. Viene anche utilizzato per la persistenza dei dati, la messaggistica Internet, la condivisione dei dati in più lingue e molte altre opzioni.

YAML è stato avviato nel 2001 ed è stato definito come "Ancora un altro linguaggio di markup" a quel tempo. Ma in seguito è stato registrato come "YAML non è un linguaggio di markup“. La struttura di base di un file YAML è a carta geografica. È anche noto come dizionario, hash(map) o semplicemente basato su oggetti sul linguaggio di programmazione che scegliamo di utilizzare.

Gli spazi bianchi e il rientro vengono utilizzati nei file YAML per denotare l'annidamento.

Sintassi YAML

Un formato YAML utilizza principalmente 3 tipi di nodi:

• Mappe/Dizionari: Un carta geografica il contenuto di node è una raccolta non ordinata di chiave/valore nodo coppie, con il requisito che ogni chiave deve essere distinta. YAML non impone ulteriori limitazioni ai nodi.
• Matrici/Elenchi: An schieramento il contenuto del nodo è una raccolta ordinata di zero o più nodi. Una sequenza può includere lo stesso nodo più di una volta, in particolare. Può contenere anche se stesso.
• Letterali (Stringhe, numeri, booleano, ecc.): una sequenza di zero o più Caratteri Unicode può essere utilizzato per rappresentare i dati opachi che compongono a scalare contenuto del nodo.

In questo articolo, daremo un'occhiata in particolare alla conversione del contenuto dell'array YAML in un elenco in Java. Ci sono molte librerie open source disponibili, ma le più popolari lo sono Jackson ed Snake YAML. In questa guida, useremo SnakeYaml come nostra libreria per analizzare il contenuto YAML.

Snake Yaml

Snake YAML è un pacchetto di analisi YAML che offre un'API di alto livello per la serializzazione e la deserializzazione dei documenti YAML. Il punto di ingresso per SnakeYAML è il Yaml classe. I documenti oi file YAML possono essere caricati utilizzando load() metodo o in batch tramite il loadAll() metodo. I metodi prendono dati YAML autentici sotto forma di oggetti String e anche InputStreams, che è un tipico tipo di file da incontrare.

dato che : struttura innata nei file YAML, SnakeYAML funziona naturalmente bene con Mappe Java, ma possiamo anche usare unique Oggetti Java.

Per includere la libreria nel nostro progetto, aggiungi la seguente dipendenza a your pom.xml file:

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

Oppure, se stai usando Gradle:

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

Lettura di un semplice array YAML

Iniziamo rapidamente leggendo un semplice array da un file YAML. Considera che abbiamo un file yaml con i seguenti dati nella cartella delle risorse del nostro progetto Java:

- One
- Two
- Three
- Four

Quindi possiamo caricare il contenuto del file come file InputStream. Successivamente, costruiremo il Yaml istanza che fungerà quindi da punto di ingresso per l'accesso alla libreria e all'oggetto per rappresentare il contenuto del file YAML in modo programmatico. Il load() il metodo ci consente di leggere e analizzare qualsiasi InputStream con dati YAML validi:

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

Il metodo restituirà un Java List di dati stringa. Se stampiamo il data quindi darà il seguente risultato:

[One, Two, Three, Four]

Lettura di un array raggruppato YAML

A volte vorremmo definire una serie di contenuti rispetto a una determinata chiave. Questo è chiamato raggruppamento di array in un nodo della mappa YAML. Un esempio di YAML di questo tipo è simile al seguente:

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

Questo può essere considerato come Java Map contenente un file : dove il valore è un schieramento. Quindi i dati verranno comunque caricati come InputStream come abbiamo definito sopra. Ma il data deve essere definito come 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);
}

Ora se leggiamo il nostro data, sarebbe simile a questo:

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

Lettura di una matrice di array multilinea YAML

A volte ci imbattiamo in un file YAML con dati contenenti array di array. Ad esempio, raggruppiamo i corsi e li rappresentiamo come array di array come di seguito:

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

Questo può essere analizzato come Java Map of List of List of String. Possiamo di nuovo caricare il InputStream come abbiamo fatto prima. Ma i dati verranno caricati come di seguito:

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);
}

Quindi se stampiamo il data, sarebbe simile al seguente:

{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

Lettura di un contenuto YAML nidificato complesso come Java Bean

Abbiamo visto come possiamo gestire il contenuto del tipo di array separatamente, ma con file YAML nidificati complessi: avere una mappa di mappe con elenchi di elenchi è difficile da analizzare intuitivamente e difficile da gestire. Anche nell'ultimo esempio in cui avevamo solo due elenchi nidificati: gestirli come elenchi diventa piuttosto prolisso.

In questi casi, è meglio creare un POJO che può essere mappato ai dati YAML nidificati. Creiamo prima un YAML di esempio contenente il contenuto nidificato di un sito Web:

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

Dobbiamo definire una classe Java madre WebsiteContent che sarà composto da List di abilità e a List of Map di tutorial che conterranno nuovamente elenchi di tag e contributori:

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 + ''' +
                '}';
    }
}

Ora possiamo caricare di nuovo i dati dal file come InputStream come abbiamo fatto prima. Successivamente, quando creiamo il nostro Yaml oggetto classe, dobbiamo specificare il tipo di dati in cui vogliamo eseguire il cast dei dati. Il new Constructor(WebsiteContent.class) dice a SnakeYAML di leggere i dati dal file YAML e mapparlo sul nostro WebsiteContent oggetto.

La mappatura è semplice ei nomi dei nostri attributi oggetto devono corrispondere ai nomi degli attributi YAML.

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);
}

Infine, quando stampiamo il data, sarebbe simile al seguente:

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}}

Come possiamo vedere, SnakeYaml ha analizzato e convertito con successo il file WebsiteContent oggetto e mantenuto l'eredità e l'associazione con Tutorial oggetto integro.

Conclusione

Poiché i file YAML sono ampiamente utilizzati per DevOps e dati relativi alla configurazione, è molto utile analizzare e manipolare i dati utilizzando il codice.

SnakeYAML ci consente di gestire facilmente i file YAML nel nostro progetto Java e richiede solo un po' di codice per caricare i file YAML nel nostro progetto o scrivere dati nei file YAML. Inoltre, SnakeYAML offre scelte di formattazione in modo che tu possa adattarlo e personalizzarlo in base alle nostre esigenze.