Unlike JSON and XML, YAML is intended to be more readable by humans and less verbose. In contrast to its rivals JSON, which employs brackets, and XML, which utilizes user-defined tags, YAML uses indentation and whitespace to generate nested blocks. Usually, YAML files are used to configure applications that need servers for application hosting or clusters for application servers rather than serialization or deserialization. People aren’t particularly great fans of YAML, although it has a lot of applications and is simple enough for humans to read.
The YAML language is used in indentation to represent structure and nesting. When complex data needs to be parsed, indentation creates issues. When comparing YAML, failures can occur because of a missing or extra white space in complex structures. It’s challenging to locate these unexpected problems in the YAML file. Since YAML documents are now so widely used, we run into situations where we need to handle data in YAML documents using code in virtually every other project. Numerous open-source libraries are provided for manipulating YAML files in Java. Both well-liked libraries, Jackson and SnakeYAML, can be used to accomplish this. This article’s main topic is how to parse YAML files in Java using SnakeYAML.
How To Get the YAML Module in the Java Language in Ubuntu 20.04
YAML files can be parsed in a Java application using the SnakeYAML library. It is a simple, lightweight library providing high-level serialization and deserialization APIs for YAML files. To store several documents at once, use the load() or loadAll() functions in batches. The function uses InputStream, a popular standard for interacting with files and string objects holding sufficient YAML data.
If you are using a spring boot application, then the most recent version of Maven dependencies must be added before using SnakeYAML in a project in the Pom.xml file, as shown in the following:
Example 1: Read the YAML File in the Java Language
Let’s read the following document of the YAML file in Java. This YAML document is stored inside the employee.YAML file.
We will now parse the previous YAML document (employee.yaml) using the YAML class. This YAML is located in the resources folder of our Java project. First, let us load the file into an InputStream. After that, we will build the Yaml object, which serves as the starting point for using the library. We can read and parse any valid YAML data from an InputStream, Reader, or string when utilizing the Yaml instance using methods like load().
The module implements a Java Map where the keys and values for each property are represented by their names. Because our data is stored in YAML files as string values, numbers, or even collections, it is essential to remember that the Map values are of the type Object. These can fit inside an Object, which includes any value we could add.
The following outcome will be obtained if we display our data object where the YAML file was loaded:
Example 2: Read the Nested Document From the YAML File in the Java Language
As you can see, a Java Map object simply maps the properties from the YAML file as key-value pairs in our previous example code. Let’s modify our YAML file so that it also includes collection data. The updated YAML file appears as follows:
A collection of field “courses” with multiple data values is now included in our YAML file. Neither our Java code nor the modified YAML file requires updating. The YAML file can be loaded into our Map object using the previous code without any issues. We just have to update the YAML file name inside the FileInputStream method.
The outcome of reading the file is shown inside the image. Every value in the list of values for the column “courses” in the YAML file is a Map object.
Example 3: Read the YAML Object as the Java Custom Object
Now we have successfully used the YAML file in our Java code as straightforward key-value pairs, let’s import again the student.yaml file as a custom Java object, a more typical use-case. To import data from our YAML files, we will utilize the following Java classes: The first class is a Person class where the attributes are id, name, and address. The getter setter method is also defined for each attribute. Your data is protected by getters and setters, especially when constructing classes.
From the class Person, we have extended the student class and defined its attributes. The attributes are updated, and a variable’s value is obtained through the getter and setter method.
Like the previous two classes, the course class is also constructed with its attributes.
The data will be loaded into an object named Student, and the YAML file’s courses element will be transformed into a List of field Courses. The YAML file we used in the previous example will be utilized again and loaded as an InputStream.
Now, we provide the data type we wish to cast the data into when we create our YAML class object. SnakeYAML is instructed to read the data from the YAML file and map it to our Student object by the new Constructor(Student.class).
The mapping is simple, and your object attributes’ names must coincide with the attributes’ YAML names (courses -> courses). As a result, you will get the following output:
Conclusion
This article primarily introduces the Java implementation of snakeyaml-based YAML parsing and serialization. SnakeYAML makes it simple to manipulate YAML files in Java projects and requires little code to import YAML files into projects. SnakeYAML offers formatting options, allowing you to adjust and change them to suit your requirements. This page details the sample code, providing everyone with a valuable learning resource.
