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 *