Pasa las explicaciones sobre anotaciones de Jackson a JSON

sio2sio2 · sio2sio2 · commit 3ee8cec665e0 · 2025-07-11T22:16:00.000+02:00
diff --git a/source/02.formatos/02.json/02.jackson.rst b/source/02.formatos/02.json/02.jackson.rst
@@ -44,8 +44,8 @@ Si, en cambio, quisiéramos generar una lista de grupos y no un array:
 
 .. code-block:: java
 
-   TypeReference<ArrayList<Grupo>> GrupoLista =  new TypeReference<>(){};
-   ArrayList<Grupo> grupos = mapper.readValue(sr, GrupoLista);
+   TypeReference<List<Grupo>> GrupoLista =  new TypeReference<>(){};
+   List<Grupo> grupos = mapper.readValue(sr, GrupoLista);
 
 .. note:: Que los miembros de cada grupo sean un array o una lista es
    absolutamente indiferente: la traducción se hará de igual forma.
@@ -101,6 +101,98 @@ Al escribir, es indiferente si usamos arrays o listas.
 
       String contenido = mapper.writeValueAsString(grupos);
 
+.. _json-jackson-annotations:
+
+Anotaciones
+-----------
+Hemos visto muy por encima cómo trasladar objetos a |JSON| y viceversa. La regla
+es que cada atributo del objeto se traduce en una propiedad |JSON| con el mismo
+nombre y que conserva el mismo valor\ [#]_. Centrémonos en ``Grupo``:
+
+.. code-block:: java
+
+   public class Grupo implements Serializable {
+
+       // Atributos
+       private short nivel;
+       private String etapa;
+       private char grupo;
+       private Tutor tutor;
+       private Alumno[] miembros;
+
+       // Resto de la implementación
+   }
+
+La serialización de un objeto ``Grupo`` será esta:
+
+.. code-block:: json
+
+   {
+      "nivel": 1,
+      "etapa": "ESO",
+      "grupo": "C",
+      "tutor": { 
+         // Serialización de un tutor
+      },
+      "miembros": [
+         // Serialización de los alumnos
+      ]
+   }
+
+Ahora bien, ¿cómo puede personalizarse la serialización para cambiar el nombre
+de un atributo o no serializarlo? La librería para ello utiliza `anotaciones
+<https://www.geeksforgeeks.org/java/annotations-in-java/>`_ que permiten indicar
+todos estos particulares:
+
+.. code-block:: java
+   :emphasize-lines: 6-7
+
+   public class Grupo implements Serializable {
+
+       // Atributos
+       private short nivel;
+
+       @JsonProperty("etapa_educativa")
+       private String etapa;
+       private char grupo;
+       private Tutor tutor;
+       private Alumno[] miembros;
+
+       // Resto de la implementación
+      
+   }
+
+De esta forma logramos que en el |JSON| la propiedad no sea  ``etapa``, sino
+``etapa_educativa``. Si nuestra intención fuera que algún atributo no pasará al
+archivo, tendríamos que anotarlo con ``@JsonIgnore``. El problema de anotar
+directamente la clase es que quizás no nos resulte elegante o directamente no
+podamos, porque no dependa de nosotros la definición. Para poder añadir
+anotaciones sin modificar la clase original, *Jackson* proporciona un mecanismo:
+la mezcla. Para ello podríamos definir aparte otra clase distinta que contenga
+exclusivamente los atributos que necesitan anotación:
+
+.. code-block:: java
+
+   public abstract class GrupoMixin {
+
+      @JsonProperty("etapa_educativo")
+      private String etapa;
+   }
+
+Luego, al definir el mapeo. se declara que deseamos mezclar la clase original
+con la clase abstracta anotada:
+
+.. code-block:: java
+   :emphasize-lines: 2
+
+   ObjectMapper mapper = new ObjectMapper();
+   mapper.addMixIn(Grupo.class, GrupoMixin.class);
+
+.. note:: Al :ref:`serializar en formato XML <xml-jackson>` con esta librería,
+   las anotaciones se vuelven imprescindibles, porque es la única forma de
+   indicar, entre otras cosas, si un atributo de la clase será un elemento o un
+   atributo |XML|.
+
 .. _json-jackson-no-primitivos:
 
 Tipos no primitivos
@@ -154,10 +246,6 @@ y podemos usar dos estrategias:
      `jackson-annotations
      <https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations>`_.
 
-  .. note:: Más adelante, al :ref:`tratar XML con esta librería <xml-jackson>`, veremos
-     que tenemos la :ref:`posibilidad de anotar sin necesidad de tocar la clase
-     original <jackson-mixin>`.
-
   .. warning:: Al usar esta anotación puede haber desajustes al serializar las fechas
      como consecuencia de la zona horaria, por lo que habría que especificarla
      en la propia anotación:
@@ -294,6 +382,10 @@ cada uno de los atributos y hacer lo siguiente:
 
 .. rubric:: Notas al pie
 
+.. [#] Siempre que el tipo, claro está, sea un primitivo de |JSON| (p. ej. una
+   cadena). Si no lo es entonces habrá que definir cómo realizar la traducción,
+   cosa que expondremos en :ref:`json-jackson-no-primitivos`.
+
 .. [#] Es decir, que si se tiene:
 
        .. code-block:: java
@@ -320,4 +412,5 @@ cada uno de los atributos y hacer lo siguiente:
 .. |JSON| replace:: :abbr:`JSON (JavaScript Object Notation)`
 .. |Date| replace:: :java-util:`Date <Date>`
 .. |LocalDate| replace:: :java-time:`LocalDate <LocalDate>`
+.. |XML| replace:: :abbr:`XML (eXtensible Markup Language)`
 
diff --git a/source/03.xml/02.jackson.rst b/source/03.xml/02.jackson.rst
@@ -205,39 +205,6 @@ lectura del formato es :ref:`prácticamente la misma que para JSON <json-jackson
       err.printStackTrace();
    }
 
-.. _jackson-mixin:
-
-Anotaciones
-===========
-La librería, sobre todo si la usamos para leer o escribir |XML| pero no sólo,
-requiere en muchas ocasiones que anotemos las clases del modelo. Si no se
-quiere (o no se puede) hacer anotaciones directamente sobre las clases,
-*Jackson* proporciona un mecanismo para evitarlo: la mezcla. Ilustrémoslo con el
-caso de la clase Profesor original:
-
-.. literalinclude:: files/Profesor.java
-   :language: java
-   :class: toggle
-   :caption: Profesor.java
-
-Necesitamos anotar los atributos ``id``, ``sustituye`` y ``casillero``, porque
-los tres deben ser atributos |XML|. Pues bien, podemos definir una clase que
-incluya sólo la parte anotada:
-
-.. literalinclude:: files/ProfesorMixIn.java
-   :language: java
-   :class: toggle
-   :caption: ProfesorMixIn.java
-
-Y, luego, al crear el *mapper* para leer o escribir, podemos indicar que
-queremos mezclar la clase original con esta parcial anotada:
-
-.. code-block:: java
-   :emphasize-lines: 2
-
-   ObjectMapper mapper = new XmlMapper();
-   mapper.addMixIn(Profesor.class, ProfesorMixIn.class);
-
 .. |XML| replace:: :abbr:`XML (eXtensible Markup Language)`
 .. |JSON| replace:: :abbr:`JSON (JavaScript Object Notation)`
 .. |YAML| replace:: :abbr:`YAML (YAML Ain't Markup Language)`
diff --git a/source/04.conector/01.basico.rst b/source/04.conector/01.basico.rst
@@ -343,8 +343,8 @@ a. El driver debe inferir el tipo |SQL| a partir del tipo de *Java*: eso
 
    .. code-block:: java
 
-      if(centro == null) pstmt.setNull(1, Types.INTEGER);
-      else pstmt.setInt(1, centro.getId());
+      if(centro == null) pstmt.setNull(3, Types.INTEGER);
+      else pstmt.setInt(3, centro.getId());
 
 .. rubric:: Notas al pie
 
diff --git a/source/98.apendices/files/Factory.java b/source/98.apendices/files/Factory.java
@@ -1,7 +1,8 @@
-package edu.acceso.almacenestudiantes.core;
+package edu.acceso.example.core;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
+import java.net.URL;
 import java.util.AbstractMap;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -35,6 +36,7 @@ public class Factory<I> {
      * @param interfaceClass La interfaz que implementan todas las clases que se quieren encontrar.
      */
     public Factory(String packageName, Class<I> interfaceClass) {
+        checkPackage(packageName);
         Reflections reflections = new Reflections(packageName);
 
         classes = reflections.getSubTypesOf(interfaceClass)
@@ -48,6 +50,23 @@ public Factory(String packageName, Class<I> interfaceClass) {
             ));
     }
 
+    /**
+     * Verifica que el paquete existe.
+     * @param packageName El nombre del paquete a verificar.
+     */
+    private void checkPackage(String packageName) {
+        if(packageName != null) {
+            String path = packageName.replace('.', '/');
+            URL resource = Thread.currentThread().getContextClassLoader().getResource(path);
+            if(resource == null) {
+                throw new IllegalArgumentException("El paquete '" + packageName + "' no existe.");
+            }
+        }
+        else {
+            throw new IllegalArgumentException("El nombre del paquete no puede ser nulo.");
+        }
+    }
+
     /**
      * Lista los nombres por los que se puede referir una clase (el propio nombre
      * de la clase más todos los que contenga el atributo alias)
diff --git a/source/99.ejercicios/02.formatos.rst b/source/99.ejercicios/02.formatos.rst
@@ -17,9 +17,9 @@ Formatos de información
 #. Recapitule todo lo hecho en los ejercicios anteriores y haga la misma aplicación,
    pero con las siguientes características:
 
-   a. La aplicación puede utilizar como formato de almacenamiento |CSV|, |JSON| o
-      la serialización directa de objetos. Qué formato se utilice se le puede
-      preguntar al usuario como pregunta adicional de la interfaz de texto.
+   a. La aplicación puede utilizar como formato de almacenamiento |CSV|, |JSON|,
+      |YAML| o la serialización directa de objetos. Qué formato se utilice se le
+      puede preguntar al usuario como pregunta adicional de la interfaz de texto.
 
    #. Alternativamente a la interfaz de texto, la aplicación debería poderse
       correr en modo *automático*. En este modo, el propio código tiene incluidos
@@ -34,3 +34,4 @@ Formatos de información
 
 .. |CSV| replace:: :abbr:`CSV (Comma-separated values)`
 .. |JSON| replace:: :abbr:`JSON (JavaScript Object Notation)`
+.. |YAML| replace:: :abbr:`YAML (YAML Ain't Markup Language)`
