Konvertálja a YAML-tömböt Java-listává a SnakeYAML segítségével

Bevezetés

YAML után az egyik legnépszerűbb adatsorosító nyelv JSON. Ezért néha a szigorú szuperkészlet a JSON-ból. Kezdettől fogva emberi interakcióra és olvashatóságra tervezték, ezért egyszerűségéről ismert. A rugalmasságot és a hozzáférhetőséget szem előtt tartva tervezték, így minden modern programozási nyelvvel működik, és a konfigurációs fájlok írásának hatékony formátumával. Adatmegmaradásra, internetes üzenetküldésre, több nyelvű adatmegosztásra és még sok más lehetőségre is használják.

A YAML 2001-ben indult, és a „Még egy jelölőnyelv" abban az időben. De később a "védjegye" lettA YAML nem jelölőnyelv“. A YAML-fájlok alapvető szerkezete a térkép. Szótárként, hash(térképként) vagy egyszerűen objektumalapúként is ismert az általunk választott programozási nyelv alapján.

A YAML-fájlokban a szóközt és a behúzást a beágyazás jelölésére használják.

YAML szintaxis

A YAML formátum elsősorban 3 csomóponttípust használ:

• Térképek/szótárak: Egy térkép csomópont tartalma egy rendezetlen gyűjtemény kulcs érték csomópont párok, azzal a feltétellel, hogy minden kulcsnak külön kell lennie. A YAML nem szab további korlátozásokat a csomópontokra.
• Tömbök/listák: Egy sor A csomópont tartalma nulla vagy több csomópont rendezett gyűjteménye. Egy sorozat egynél többször is tartalmazhatja ugyanazt a csomópontot, különösen. Még önmagát is tartalmazhatja.
• Szó szerint (Karakterláncok, számok, logikai érték stb.): Nulla vagy több sorozat Unicode karakterek használható az átlátszatlan adatok ábrázolására, amelyek a skaláris csomópont tartalma.

Ebben a cikkben a YAML tömb tartalmának listává alakítását fogjuk megvizsgálni Java nyelven. Rengeteg nyílt forráskódú könyvtár áll rendelkezésre, de ezek közül a legnépszerűbbek Jackson és a SnakeYAML. Ebben az útmutatóban a SnakeYaml-t fogjuk használni könyvtárunkként a YAML-tartalom elemzéséhez.

SnakeYaml

SnakeYAML egy YAML-elemző csomag, amely magas szintű API-t kínál a YAML dokumentumok szerializálásához és deszerializálásához. A SnakeYAML belépési pontja a Yaml osztály. A dokumentumok vagy a YAML fájlok a segítségével tölthetők be load() módszerrel vagy kötegesen a loadAll() módszer. A metódusok valódi YAML-adatokat vesznek fel String objektumok formájában InputStreams, amely tipikus fájltípus, amellyel találkozhatunk.

Tekintettel a : A YAML fájlok veleszületett szerkezete, a SnakeYAML természetesen jól működik Java Maps, de használhatunk egyedit is Java objektumok.

A könyvtár projektünkbe való bevonásához adja hozzá a következő függőséget a sajátjához pom.xml file:

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

Vagy ha Gradle-t használ:

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

Egyszerű YAML-tömb olvasása

Kezdjük gyorsan egy egyszerű tömb beolvasásával egy YAML fájlból. Tegyük fel, hogy van egy yaml fájlunk a következő adatokkal Java projektünk erőforrás mappájában:

- One
- Two
- Three
- Four

Ezután betölthetjük a fájl tartalmát an InputStream. Ezután megépítjük a Yaml példány, amely ezután belépési pontként fog működni a könyvtár és az objektum eléréséhez a YAML-fájl tartalmának programozott megjelenítéséhez. A load() metódus lehetővé teszi bármely olvasását és elemzését InputStream érvényes YAML adatokkal:

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

A metódus egy Java-t ad vissza List karakterlánc adatokból. Ha kinyomtatjuk a data akkor a következő eredményt adja:

[One, Two, Three, Four]

YAML csoportosított tömb olvasása

Néha szeretnénk egy tartalomtömböt meghatározni egy adott kulcshoz képest. Ezt a tömbök YAML leképezési csomópontokba csoportosításának nevezik. Egy ilyen típusú YAML minta az alábbiak szerint néz ki:

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

Ez Javanak tekinthető Map tartalmazó a : ahol az érték an sor. Tehát az adatok továbbra is mint InputStream ahogy fentebb meghatároztuk. De a data ként kell meghatározni 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);
}

Most, ha elolvassuk a mi data, valahogy így nézne ki:

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

YAML többsoros tömb olvasása

Néha találkozunk egy YAML fájllal, amely tömbök tömbjét tartalmazó adatokat tartalmaz. Például csoportosítjuk a kurzusokat, és tömbökként ábrázoljuk őket az alábbiak szerint:

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

Ez Java-ként értelmezhető Map of List of List of String. Újra betölthetjük a InputStream ahogy korábban tettük. De az adatok az alábbiak szerint lesznek betöltve:

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

Tehát ha kinyomtatjuk a data, valahogy így nézne ki:

{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

Komplex beágyazott YAML-tartalom olvasása Java Bean-ként

Láttuk, hogyan tudjuk kezelni a tömb típusú tartalmat külön-külön, de összetett, egymásba ágyazott YAML-fájlokkal – a listák listáit tartalmazó térképtérképet nehéz intuitív módon elemezni, és nehéz kezelni. Még az utolsó példában is, ahol csak két egymásba ágyazott listánk volt – a listaként való kezelésük meglehetősen bőbeszédű.

Ezekben az esetekben a legjobb egy POJO létrehozása, amely hozzárendelhető a beágyazott YAML adatokhoz. Először hozzunk létre egy YAML mintát, amely egy webhely beágyazott tartalmát tartalmazza:

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

Meg kell határoznunk egy szülő Java osztályt WebsiteContent amely abból fog állni List készségek és a List of Map az oktatóanyagokból, amelyek ismét tartalmazni fogják a címkék és a közreműködők listáját:

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

Most újra betölthetjük az adatokat a fájlból mint InputStream ahogy korábban tettük. Következő, amikor létrehozzuk a sajátunkat Yaml osztályú objektum, meg kell adnunk az adattípust, amelybe az adatokat át szeretnénk adni. A new Constructor(WebsiteContent.class) utasítja a SnakeYAML-t, hogy olvassa be az adatokat a YAML fájlból, hogy leképezi azt a mi fájlunkra WebsiteContent tárgy.

A leképezés egyszerű, és az objektum attribútumaink nevének meg kell egyeznie a YAML attribútumok nevével.

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

Végül, amikor kinyomtatjuk a data, valahogy így nézne ki:

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

Amint látjuk, a SnakeYaml sikeresen elemezte és konvertálta a WebsiteContent tárgyat, és megtartotta az örökséget és a társítást Tutorial tárgy ép.

Következtetés

Mivel a YAML-fájlokat széles körben használják a DevOps-hoz és a konfigurációval kapcsolatos adatokhoz, nagyon hasznos az adatok kóddal történő elemzése és manipulálása.

A SnakeYAML lehetővé teszi számunkra, hogy könnyedén kezeljük a YAML fájlokat Java projektünkben, és csak egy kis kódra van szükség ahhoz, hogy YAML fájlokat töltsünk be a projektünkbe, vagy adatokat írjunk YAML fájlokba. Ezenkívül a SnakeYAML formázási lehetőségeket is kínál, így Ön igényeinknek megfelelően módosíthatja és személyre szabhatja.