Cómo leer y escribir archivos YAML en Java usando Jackson

/ Java / Por

Cómo leer y escribir archivos YAML en Java usando Jackson



1. Introducción

En este breve tutorial, vamos a aprender cómo utilizar Jackson para leer y escribir archivos YAML en Java. El formato YAML es ampliamente conocido por su legibilidad y simplicidad, lo que lo convierte en una opción popular para la configuración de aplicaciones y el intercambio de datos. A lo largo de este artículo, revisaremos una estructura de ejemplo y usaremos el ObjectMapper de Jackson para leer un archivo YAML en un objeto Java y también para escribir un objeto en un archivo.



2. Dependencias

Primero, necesitas agregar la dependencia para el formato de datos YAML de Jackson. A continuación, se muestra cómo hacerlo en tu archivo pom.xml si estás utilizando Maven:

<dependency>
    <groupId>com.fasterxml.jackson.dataformat</groupId>
    <artifactId>jackson-dataformat-yaml</artifactId>
    <version>2.13.0</version>
</dependency>

Siempre puedes encontrar la versión más reciente de esta dependencia en Maven Central.

Dado que nuestra clase Java utilizará un objeto LocalDate, también debemos agregar una dependencia para el datatype JSR-310:

<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-jsr310</artifactId>
    <version>2.13.0</version>
</dependency>

De nuevo, puedes consultar su versión más reciente en Maven Central.



3. Estructura de Datos y Objetos

Con nuestras dependencias configuradas, ahora pasamos al archivo de entrada y a las clases Java que utilizaremos. Primero, echemos un vistazo al archivo que vamos a leer:

orderNo: A001
date: 2019-04-17
customerName: Customer, Joe
orderLines:
    - item: No. 9 Sprockets
      quantity: 12
      unitPrice: 1.23
    - item: Widget (10mm)
      quantity: 4
      unitPrice: 3.45

A continuación, definamos la clase Order:

import java.time.LocalDate;
import java.util.List;

public class Order {
    private String orderNo;
    private LocalDate date;
    private String customerName;
    private List<OrderLine> orderLines;

    // Constructores, Getters, Setters y toString
}

Finalmente, creemos nuestra clase OrderLine:

import java.math.BigDecimal;

public class OrderLine {
    private String item;
    private int quantity;
    private BigDecimal unitPrice;

    // Constructores, Getters, Setters y toString
}


4. Leyendo YAML

Ahora vamos a utilizar el ObjectMapper de Jackson para leer el archivo YAML en un objeto Order. Primero, configuramos el ObjectMapper de la siguiente manera:

ObjectMapper mapper = new ObjectMapper(new YAMLFactory());

Ahora, debemos utilizar el método findAndRegisterModules para que Jackson maneje nuestros objetos de fecha correctamente:

mapper.findAndRegisterModules();

Una vez que tengamos nuestro ObjectMapper configurado, simplemente utilizamos readValue:

Order order = mapper.readValue(new File("src/main/resources/orderInput.yaml"), Order.class);

Después de esta operación, nuestro objeto Order estará poblado desde el archivo, incluyendo la lista de OrderLine.



5. Escribiendo YAML

También vamos a utilizar ObjectMapper para escribir un Order en un archivo. Primero, agreguemos un poco de configuración:

mapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);

Esta línea le dice a Jackson que simplemente escriba nuestra fecha como un String en lugar de partes numéricas individuales.

Por defecto, nuestro archivo comenzará con tres guiones. Esto es absolutamente válido para el formato YAML, pero podemos desactivar esta característica en el YAMLFactory:

mapper = new ObjectMapper(new YAMLFactory().disable(Feature.WRITE_DOC_START_MARKER));

Con eso configurado, vamos a crear un Order:

List<OrderLine> lines = new ArrayList<>();
lines.add(new OrderLine("Copper Wire (200ft)", 1, 
  new BigDecimal(50.67).setScale(2, RoundingMode.HALF_UP)));
lines.add(new OrderLine("Washers (1/4")", 24, 
  new BigDecimal(0.15).setScale(2, RoundingMode.HALF_UP)));
Order order = new Order(
  "B-9910", 
  LocalDate.parse("2019-04-18", DateTimeFormatter.ISO_DATE),
  "Customer, Jane", 
  lines);

Finalmente, escribimos nuestra orden usando writeValue:

mapper.writeValue(new File("src/main/resources/orderOutput.yaml"), order);

Cuando miremos en el orderOutput.yaml, debería verse similar a esto:

orderNo: "B-9910"
date: "2019-04-18"
customerName: "Customer, Jane"
orderLines:
- item: "Copper Wire (200ft)"
  quantity: 1
  unitPrice: 50.67
- item: "Washers (1/4")"
  quantity: 24
  unitPrice: 0.15


6. Conclusión

En este rápido tutorial, aprendimos a leer y escribir archivos YAML en Java usando la biblioteca Jackson. También revisamos algunas configuraciones que nos ayudarán a que nuestros datos se vean como queremos.



Consejos Prácticos para Programadores Java

  • Mantén tus dependencias actualizadas: Siempre verifica las versiones más recientes de las bibliotecas que utilizas para beneficiarte de mejoras y correcciones de errores.
  • Manejo de excepciones: Asegúrate siempre de manejar las excepciones que pueden surgir al leer o escribir archivos, ya que muchos factores externos pueden causar fallos, como la ausencia del archivo o problemas de permisos.
  • Organización de Clases: Mantén tus clases de modelo (como Order y OrderLine) bien organizadas, separando propiedades, métodos y constructores para mejorar la legibilidad y el mantenimiento.
  • Validación de Datos: Considera implementar validaciones para tu objeto antes de escribirlo en un archivo, para asegurarte de que todos los datos necesarios están presentes y son válidos.
  • Usa comentarios: Documenta tu código con comentarios claros para que futuros tú (o tus compañeros de equipo) puedan entender la lógica detrás de las configuraciones.

Esperamos que este tutorial te haya sido de ayuda y que ahora estés listo para trabajar con archivos YAML en Java usando Jackson. ¡Feliz codificación!