Lectura y escritura de archivos YAML en Java con Jackson

    Introducci贸n

    YAML Actualmente, los archivos se utilizan ampliamente para definir propiedades de herramientas y aplicaciones debido a la sintaxis muy legible por humanos.

    Adem谩s de contener propiedades de configuraci贸n, tambi茅n se utilizan a menudo para la transmisi贸n / serializaci贸n de datos, de forma similar a como se utiliza JSON.

    Leer y escribir archivos YAML se est谩 convirtiendo r谩pidamente en una habilidad b谩sica del desarrollador, similar a c贸mo lo es leer y escribir archivos JSON y XML.

    驴Qu茅 es YAML?

    YAML no es otro lenguaje de marcado (YAML) es un lenguaje de serializaci贸n de datos simple y legible por humanos, muy parecido a JSON. Es m谩s f谩cil de leer y comprender y tiene la capacidad de hacer referencia a otros elementos dentro de un archivo YAML, as铆 como de incrustar otros formatos como JSON y XML dentro de s铆 mismo.

    No pretende ser un reemplazo de las soluciones actuales y se usa principalmente para archivos de configuraci贸n debido al hecho de que es f谩cil de leer y editar, y admite comentarios, lo que lo hace mucho m谩s amigable para el equipo.

    La mayor铆a de los archivos YAML se pueden convertir a JSON y viceversa, ya que YAML es un superconjunto de JSON. A continuaci贸n, se muestra un ejemplo de un archivo YAML:

    --- #Employee Info
    name: David
    wage: 1500
    position: Developer
    techstack:
        - Java
        - Spring
        - Hibernate
    

    La sintaxis es realmente simple, un diccionario (nuestra entidad de empleado) se representa con <key>: <value>.

    Despu茅s de definir algunas propiedades como el name, wagey position, se incluye una lista, nuevamente, con sangr铆a con cada elemento de la lista que comienza con un -.

    Cada uno de estos elementos tambi茅n puede ser un diccionario:

    ---
    name: David
    wage: 1500
    position: Developer
    colleagues:
        -   name: Martha
            wage: 1500
            position: Developer
        -   name: Jim
            wage: 1800
            position: DevOps Engineer
    

    Puede acortar diccionarios y formar colecciones m谩s complejas, aunque eso est谩 fuera del alcance de este tutorial.

    Con un repaso sobre YAML, estamos listos para escribir c贸digo que lee / escribe archivos YAML. Para lograr esto, podemos usar cualquiera de las dos bibliotecas populares: Jackson o Serpiente YAML. En este art铆culo, nos centraremos en Jackson.

    Leyendo YAML con Jackson

    Jackson es una biblioteca basada en Java extremadamente popular que se utiliza para analizar y manipular archivos JSON y XML.

    No hace falta decir que tambi茅n nos permite analizar y manipular archivos YAML de manera similar a como ya estamos acostumbrados a hacerlo con los dos formatos mencionados anteriormente.

    Al usar Jackson como nuestra biblioteca, estamos en un entorno familiar y muchas aplicaciones Java ya tienen Jackson para otros prop贸sitos de todos modos.

    Primero, agreguemos a Jackson a nuestro proyecto a trav茅s de Maven:

    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-dataformat-yaml</artifactId>
        <version>{$version}</version>
    </dependency>
    
    <dependency>
        <groupId>com.fasterxml.jackson.core</groupId>
        <artifactId>jackson-databind</artifactId>
        <version>{$version}</version>
    </dependency>
    

    Necesitaremos ambos jackson-databind del cual extraeremos el ObjectMapper clase y el jackson-dataformat-yaml dependencia de la que extraeremos el YAMLFactory clase.

    Al igual que hicimos con JSON y XML, la clase principal que usaremos para esta tarea ser谩 la ObjectMapper clase. Sus readValue() El m茅todo se utiliza para mapear la fuente (archivo YAML) en el resultado (un objeto de una clase).

    Primero definamos una clase simple a la que nos gustar铆a mapear. Con respecto al ejemplo anterior de YAML, hagamos un Employee clase:

    public class Employee {
    
        public Employee(String name, int wage, String position, List<Employee> colleagues) {
            this.name = name;
            this.wage = wage;
            this.position = position;
            this.colleagues = colleagues;
        }
    
        // Without a default constructor, Jackson will throw an exception
        public Employee() {}
    
        private String name;
        private int wage;
        private String position;
        private List<Employee> colleagues;
    
        // Getters and setters
    
        @Override
        public String toString() {
            return "nName: " + name + "nWage: " + wage + "nPosition: " + position + "nColleagues: " + colleagues + "n";
        }
    

    Ahora, leeremos un archivo YAML, digamos person.yaml, con el contenido:

    ---
    name: David
    wage: 1500
    position: Developer
    colleagues:
        -   name: Martha
            wage: 1500
            position: Developer
        -   name: Jim
            wage: 1800
            position: DevOps Engineer
    

    Asignaremos este archivo a una instancia de nuestro Employee clase usando Jackson’s ObjectMapper clase:

    // Loading the YAML file from the /resources folder
    ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
    File file = new File(classLoader.getResource("person.yaml").getFile());
    
    // Instantiating a new ObjectMapper as a YAMLFactory
    ObjectMapper om = new ObjectMapper(new YAMLFactory());
    
    // Mapping the employee from the YAML file to the Employee class
    Employee employee = om.readValue(file, Employee.class);
    
    // Printing out the information
    System.out.println("Employee info " + employee.toString());
    
    // Access the first element of the list and print it as well
    System.out.println("Accessing first element: " + employee.getColleagues().get(0).toString());
    

    Ejecutar este fragmento de c贸digo nos dar谩:

    Employee info
    Name: David
    Wage: 1500
    Position: Developer
    Colleagues: [
    Name: Martha
    Wage: 1500
    Position: Developer
    Colleagues: null
    ,
    Name: Jim
    Wage: 1800
    Position: DevOps Engineer
    Colleagues: null
    ]
    
    Accessing first element:
    Name: Martha
    Wage: 1500
    Position: Developer
    Colleagues: null
    

    Nuestra person.yaml El archivo se asign贸 a una instancia de un objeto que luego podemos usar para cualquier prop贸sito previsto.

    Escribiendo YAML con Jackson

    Con la lectura y el mapeo fuera del camino, tambi茅n sigamos adelante y escribamos en un archivo YAML.

    A diferencia de usar el readValue() m茅todo, usaremos el writeValue() m茅todo, especificando d贸nde terminar谩 el archivo resultante y el objeto desde el que estamos mapeando en el archivo YAML.

    Creemos una instancia de un empleado y asignemos algunos valores:

    List<Employee> colleagues = new ArrayList<Employee>();
    
    colleagues.add(new Employee("Mary", 1800, "Developer", null));
    colleagues.add(new Employee("Jane", 1200, "Developer", null));
    colleagues.add(new Employee("Tim", 1600, "Developer", null));
    colleagues.add(new Employee("Vladimir", 1000, "Developer", null));
    
    // We want to save this Employee in a YAML file
    Employee employee = new Employee("David", 1500, "Developer", colleagues);
    
    // ObjectMapper is instantiated just like before
    ObjectMapper om = new ObjectMapper(new YAMLFactory());
    
    // We write the `employee` into `person2.yaml`
    om.writeValue(new File("/src/main/resources/person2.yaml"), employee);
    

    Ejecutar este fragmento de c贸digo nos dar谩 un archivo YAML con el contenido:

    ---
    name: "David"
    wage: 1500
    position: "Developer"
    colleagues:
    - name: "Mary"
      wage: 1800
      position: "Developer"
      colleagues: null
    - name: "Jane"
      wage: 1200
      position: "Developer"
      colleagues: null
    - name: "Tim"
      wage: 1600
      position: "Developer"
      colleagues: null
    - name: "Vladimir"
      wage: 1000
      position: "Developer"
      colleagues: null
    

    Como puede ver, Java employee El objeto se serializ贸 en un archivo con formato YAML utilizando la compatibilidad de Jackson con YAML.

    Conclusi贸n

    Los archivos con formato YAML se est谩n volviendo cada vez m谩s populares para definir propiedades de herramientas y aplicaciones debido a la sintaxis muy legible por humanos. Adem谩s de contener propiedades de configuraci贸n, tambi茅n se utilizan cada vez m谩s para la transmisi贸n de datos, de forma similar a como se utiliza JSON, aunque su uso en esta 谩rea todav铆a no es tan frecuente en la naturaleza.

    Jackson es una biblioteca basada en Java extremadamente popular que se utiliza para analizar y manipular archivos JSON y XML. Adem谩s, se ampli贸 para permitir a los desarrolladores trabajar tambi茅n con el formato de archivo YAML.

     

    Etiquetas:

    Deja una respuesta

    Tu direcci贸n de correo electr贸nico no ser谩 publicada. Los campos obligatorios est谩n marcados con *