Saltar a contenido

Taller UD08_T03: Introducción a JSON y YAML

¿Qué es JSON?

JSON (JavaScript Object Notation) es un formato ligero de intercambio de datos que es fácil de leer y escribir para los humanos, y fácil de parsear y generar para las máquinas. Es un formato basado en texto que utiliza una estructura de pares clave-valor, similar a los objetos en JavaScript.

¿Qué es YAML?

YAML (YAML Ain't Markup Language) es un formato de serialización de datos legible por humanos que se utiliza comúnmente para archivos de configuración y en aplicaciones donde los datos deben ser almacenados o transmitidos. YAML es más expresivo que JSON y permite comentarios, lo que lo hace más adecuado para configuraciones complejas.

Comparación entre JSON y YAML:

Característica JSON YAML
Legibilidad Buena, pero menos expresivo Muy buena, más expresivo
Comentarios No soporta comentarios Soporta comentarios
Estructura Basado en pares clave-valor Basado en indentación
Uso común APIs, intercambio de datos Configuraciones, DevOps
Complejidad Más simple Más flexible y complejo

Generación y Carga de JSON y YAML en Java

Para trabajar con JSON y YAML en Java, utilizaremos las bibliotecas Jackson.

Porqué Jackson y no Gson?

Tanto Jackson como Gson son bibliotecas populares en Java para trabajar con JSON (serialización y deserialización). Ambas son ampliamente utilizadas, pero tienen diferencias en términos de rendimiento, funcionalidades, flexibilidad y facilidad de uso. - Jackson, desarrollada por FasterXML, es más potente, flexible y rápido, pero tiene una curva de aprendizaje más pronunciada. Es ideal para proyectos complejos o cuando necesitas trabajar con múltiples formatos (YAML, CSV, etc). - Gson, desarrollada por Google, es más sencilla y fácil de usar, pero menos flexible y potente. Es ideal para proyectos pequeños o cuando necesitas una solución rápida y ligera.

Para trabajar con JSON y YAML en Java usando Jackson, asegúrate de agregar las dependencias correctas en tu pom.xml. Jackson es una biblioteca poderosa y flexible que te permite manejar ambos formatos de manera eficiente.

Dependencias Maven:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
    <dependencies>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <!-- Dependencia para trabajar con JSON -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.15.2</version> <!-- Usa la versión más reciente -->
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.dataformat/jackson-dataformat-yaml -->
        <!-- Dependencia para trabajar con YAML -->
        <dependency>
            <groupId>com.fasterxml.jackson.dataformat</groupId>
            <artifactId>jackson-dataformat-yaml</artifactId>
            <version>2.15.2</version> <!-- Usa la versión más reciente -->
        </dependency>
    </dependencies>

Ejemplo Simple: Generación y Carga de JSON y YAML

Clase Libro:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class Libro {
    private String titulo;
    private String autor;
    private int anyoPublicacion;

    //Constructor por defecto, necesario para Jackson
    public Libro() {
    }

    // Constructor, getters y setters
    public Libro(String titulo, String autor, int anyoPublicacion) {
        this.titulo = titulo;
        this.autor = autor;
        this.anyoPublicacion = anyoPublicacion;
    }

    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    public String getAutor() {
        return autor;
    }

    public void setAutor(String autor) {
        this.autor = autor;
    }

    public int getAnyoPublicacion() {
        return anyoPublicacion;
    }

    public void setAnyoPublicacion(int anyoPublicacion) {
        this.anyoPublicacion = anyoPublicacion;
    }

    @Override
    public String toString() {
        return "Libro{" +
                "titulo='" + titulo + '\'' +
                ", autor='" + autor + '\'' +
                ", año Publicacion=" + anyoPublicacion +
                '}';
    }
}
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.dataformat.yaml.YAMLFactory;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;

public class TestLibro {
    public static void main(String[] args) {
        // Crear una lista de libros
        ArrayList<Libro> libros = new ArrayList<>();
        libros.add(new Libro("El Principito", "Antoine de Saint-Exupéry", 1943));
        libros.add(new Libro("Cien Años de Soledad", "Gabriel García Márquez", 1967));
        libros.add(new Libro("1984", "George Orwell", 1949));

        // Generar JSON con Jackson
        ObjectMapper jsonMapper = new ObjectMapper(); // ObjectMapper de Jackson: permite leer y escribir JSON
        try {
            jsonMapper.writeValue(new File("libros.json"), libros);
        } catch (IOException ex) {
            System.out.println("Error al generar el archivo JSON.");
        }
        System.out.println("Archivo JSON generado con éxito.");

        // Cargar JSON con Jackson
        ArrayList<Libro> librosCargadosJson = null;
        try {
            librosCargadosJson = jsonMapper.readValue(new File("libros.json"), jsonMapper.getTypeFactory().constructCollectionType(ArrayList.class, Libro.class));
        } catch (IOException ex) {
            System.out.println("Error al cargar el archivo JSON.");
        }
        System.out.println("Libros cargados desde JSON:");
        if (librosCargadosJson != null) {
            for (Libro libro : librosCargadosJson) {
                System.out.println(libro);
            }
        } else {
            System.out.println("No se han cargado libros del JSON.");
        }

        // Generar YAML con Jackson
        ObjectMapper yamlMapper = new ObjectMapper(new YAMLFactory());
        try {
            yamlMapper.writeValue(new File("libros.yaml"), libros);
        } catch (IOException ex) {
            System.out.println("Error al generar el archivo YAML.");
        }
        System.out.println("Archivo YAML generado con éxito.");

        // Cargar YAML con Jackson
        ArrayList<Libro> librosCargadosYaml = null;
        try {
            librosCargadosYaml = yamlMapper.readValue(new File("libros.yaml"), jsonMapper.getTypeFactory().constructCollectionType(ArrayList.class, Libro.class));
        } catch (IOException ex) {
            System.out.println("Error al cargar el archivo YAML.");
        }
        System.out.println("Libros cargados desde YAML:");
        if (librosCargadosYaml != null) {
            for (Libro libro : librosCargadosYaml) {
                System.out.println(libro);
            }
        } else {
            System.out.println("No se han cargado libros del YAML.");
        }
    }
}

Resultado Esperado:

Archivo libros.json:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
[
  {
    "titulo": "El Principito",
    "autor": "Antoine de Saint-Exupéry",
    "anyoPublicacion": 1943
  },
  {
    "titulo": "Cien Años de Soledad",
    "autor": "Gabriel García Márquez",
    "anyoPublicacion": 1967
  },
  {
    "titulo": "1984",
    "autor": "George Orwell",
    "anyoPublicacion": 1949
  }
]

Archivo libros.yaml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
---
- titulo: "El Principito"
  autor: "Antoine de Saint-Exupéry"
  anyoPublicacion: 1943
- titulo: "Cien Años de Soledad"
  autor: "Gabriel García Márquez"
  anyoPublicacion: 1967
- titulo: "1984"
  autor: "George Orwell"
  anyoPublicacion: 1949

Salida en Consola:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
Archivo JSON generado con éxito.
Libros cargados desde JSON:
Libro{titulo='El Principito', autor='Antoine de Saint-Exupéry', año Publicacion=1943}
Libro{titulo='Cien Años de Soledad', autor='Gabriel García Márquez', año Publicacion=1967}
Libro{titulo='1984', autor='George Orwell', año Publicacion=1949}
Archivo YAML generado con éxito.
Libros cargados desde YAML:
Libro{titulo='El Principito', autor='Antoine de Saint-Exupéry', año Publicacion=1943}
Libro{titulo='Cien Años de Soledad', autor='Gabriel García Márquez', año Publicacion=1967}
Libro{titulo='1984', autor='George Orwell', año Publicacion=1949}

Tarea

Genera un nuevo proyecto, crea una clase Producto con los siguientes atributos:

  • nombre (String)
  • precio (double)
  • stock (int)

Crear otra clase TestProducto con una lista de objetos Producto con al menos 3 productos.

Genera y guarda la lista en un archivo JSON (productos.json) y en un archivo YAML (productos.yaml).

Carga y muestra los datos desde ambos archivos.

Genera un zip con el proyecto de IntelliJ. Envía el archivo zip a la tarea de Aules.