Lecciones

Cómo reducir el tamaño y acelerar la serialización de objetos en Java: excluimos campos innecesarios con transient, tomamos control total mediante Externalizable, aplicamos compresión en streaming ( GZIPOutputStream, ZipOutputStream), aceleramos la E/S con almacenamiento en búfer ( BufferedOutputStream, BufferedInputStream) y copia rápida con FileChannel. transferTo. Para evaluar el rendimiento utilizamos tanto mediciones rápidas con System. nanoTime() como microbenchmarks fiables con JMH. Cerraremos con un mini experimento y el análisis de errores típicos.

Introducción breve y moderna al formato de intercambio de datos JSON: qué es y por qué se ha convertido en el estándar de facto para REST API; estructuras básicas — objetos { } y arrays [ ]; tipos permitidos (cadenas "...", números, valores booleanos true/ false, null); anidamiento; comparación con XML; correspondencias JSON ↔ Java (colecciones Map<K, V>, HashMap<K, V>). Analizamos ejemplos prácticos y errores típicos: comillas simples, comas sobrantes, undefined, números con ceros a la izquierda.

Jackson es el estándar de facto para trabajar con JSON en Java: desde operaciones simples de serialización y deserialización mediante ObjectMapper hasta un ajuste fino con las anotaciones @JsonProperty, @JsonIgnore, @JsonInclude, @JsonFormat. En la lección veremos cómo añadir la dependencia ( jackson-databind), la lectura y escritura de objetos y colecciones, el pretty printing, el trabajo con fechas y los errores típicos, incluidos los genéricos con TypeReference y los requisitos para los POJO (constructor sin parámetros, getters/setters).

En esta lección analizamos la biblioteca Google Gson: inicio rápido con los métodos toJson/ fromJson, deserialización de colecciones mediante TypeToken<>, configuración flexible con GsonBuilder ( setPrettyPrinting, serializeNulls, setDateFormat). Veremos las anotaciones @SerializedName, @Expose, el versionado con @Since/ @Until, adaptadores propios mediante TypeAdapter y registerTypeAdapter, y luego compararemos con Jackson y revisaremos errores típicos.

Cuando la estructura de un JSON es desconocida de antemano o cambia con frecuencia, es más cómodo trabajar no con clases de Java rígidas, sino con contenedores universales: Map, List y árboles JSON. En la lección vemos cómo, con ObjectMapper, leer los datos en Map<String, Object> y List; cómo recorrer el árbol de forma segura mediante JsonNode y sus métodos get/ path/ asText(); y también la alternativa con Gson usando JsonElement, JsonObject, JsonArray. Cerramos con práctica de extracción de configuración y un repaso de errores típicos.

Para qué y cómo comprobar los datos de entrada en formato JSON antes de deserializar: analizamos el contrato de datos con JSON Schema (claves type, properties, required, format), validamos en Java con la biblioteca everit-org/json-schema (carga de esquema en Schema, llamada a validate), gestionamos correctamente ValidationException y formamos mensajes de error claros para usuarios y API.

Una introducción breve y práctica a XML: estructura básica (elementos, atributos, nodos de texto, comentarios, CDATA), el prólogo y, sobre todo, para qué sirven los espacios de nombres y cómo declararlos y usarlos mediante los atributos xmlns y xmlns:prefix. Veremos los prefijos, el espacio por defecto ( xmlns= "URI"), la mezcla de diferentes “vocabularios” en un mismo documento y los errores típicos de análisis.

En esta lección analizamos dos enfoques clásicos para procesar XML: el basado en árbol, DOM, y el basado en eventos, SAX. Aprenderás a leer y modificar documentos a través del árbol ( Document, Element, NodeList) y a procesar archivos grandes en streaming con manejadores de eventos ( SAXParser, DefaultHandler, startElement/ characters/ endElement). Mostraremos pros y contras de cada enfoque, ejemplos prácticos y revisaremos errores típicos (memoria, división del texto en characters, intentos de modificar XML en SAX).

Analizamos el análisis sintáctico en flujo (streaming) de XML con StAX: en qué se diferencia el modelo pull del enfoque push de SAX, cómo crear un parser mediante XMLInputFactory y leer eventos de XMLStreamReader con un bucle que llama a reader. next(), qué tipos de eventos existen ( START_ELEMENT, CHARACTERS, END_ELEMENT, END_DOCUMENT) y cuándo StAX es preferible a DOM/ SAX. Además: tabla comparativa de enfoques, diagrama Mermaid y revisión de errores típicos (fugas de flujos, anidamiento de elementos, excepciones XMLStreamException, IOException).

Cómo, con JAXB (Jakarta XML Binding), convertir objetos de Java a XML y viceversa: anotaciones clave @XmlRootElement, @XmlElement, @XmlAttribute, @XmlType, @XmlTransient; clases básicas JAXBContext, Marshaller, Unmarshaller; configuración del formato mediante la propiedad Marshaller.JAXB_FORMATTED_OUTPUT. Revisamos las dependencias de Maven para Java 11+ ( jakarta.xml.bind-api, jaxb-runtime), el trabajo con colecciones y objetos anidados, el control del orden de los elementos ( propOrder), la exclusión de campos y los errores típicos.

Cómo enseñar a JAXB a serializar tipos «no estándar» y a representar los datos en el formato deseado: usamos la anotación @XmlJavaTypeAdapter y escribimos adaptadores propios basados en XmlAdapter<ValueType, BoundType>. Veremos el formateo de fechas ( LocalDate → "dd.MM.yyyy"), números ( BigDecimal), el trabajo con colecciones, cómo pasar valores a atributos con @XmlAttribute, a elementos con @XmlElement y excluir campos con @XmlTransient. Practicaremos la serialización/deserialización con Marshaller/ Unmarshaller y analizaremos errores típicos.

Repasamos y profundizamos en las expresiones lambda en Java: sintaxis (parámetros, flecha ->, cuerpo), formas abreviadas sin paréntesis y sin return, relación con las interfaces funcionales ( Comparator, Runnable, Consumer), ejemplos cotidianos con listas, flujos y Stream API. Analizamos el ámbito de visibilidad y la regla «efectivamente final», la diferencia de this en lambdas y clases anónimas, así como los errores típicos y cómo evitarlos.