📚 Chuleta M0486 · Acceso a Datos — Teoría + práctica media-manager

0 El módulo M0486 · Acceso a Datos

Gestionar datos = almacenar de forma persistente y segura, recuperar eficientemente, modificar manteniendo la integridad, eliminar datos obsoletos y convertir entre formatos.

Objetivo: aplicar técnicas de persistencia (ficheros, BD relacionales y no relacionales) con una separación clara entre lógica de negocio y capa de persistencia.

0.1 Arquitectura de aplicaciones

Comunicación: API

• API = puerta de entrada al back end, idioma común. Protocolo HTTP/HTTPS.
• Verbos: GET recuperar · POST crear/enviar nuevo · PUT/PATCH actualizar · DELETE eliminar.
• Formato normal: JSON (ligero, legible). Seguridad: tokens (JWT) o claves. Rendimiento: cachés. Documentación: OpenAPI/Swagger. El front trabaja de forma asíncrona (no bloquea la UI).

1 Acceso a datos en ficheros · java.io vs java.nio

Las apps guardan información persistente en ficheros o bases de datos. En Java hay dos grandes familias de APIs.

La clase java.io.File

Constructores

File f1 = new File("dades.txt");                 // 1) File(String pathname) – ruta absoluta o relativa
File f2 = new File("resources", "dades.txt");    // 2) File(String parent, String child)
File carpeta = new File("resources");
File f3 = new File(carpeta, "dades.txt");        // 3) File(File parent, String child)

Tipos de path

File fitxer = new File("resources/../resources/dades.txt");
fitxer.getPath();          // resources/../resources/dades.txt  (tal cual)
fitxer.getAbsolutePath();  // /home/user/proj/resources/../resources/dades.txt
fitxer.getCanonicalPath(); // /home/user/proj/resources/dades.txt  (limpio) → throws IOException
fitxer.getName();          // dades.txt
fitxer.getParent();        // resources/../resources
fitxer.toString();         // = getPath()

Métodos más habituales

Ejemplo FileFile fitxer = new File("dades.txt");
if (fitxer.exists()) {
    System.out.println("Ruta absoluta: " + fitxer.getAbsolutePath());
    System.out.println("És un directori? " + fitxer.isDirectory());
    System.out.println("Mida en bytes: " + fitxer.length());
} else {
    System.out.println("El fitxer no existeix.");
}

Excepciones: detección y tratamiento

Una excepción es un evento anómalo que interrumpe el flujo normal. Se lanza (throw) un objeto que deriva de Throwable. El método se para y la JVM busca un catch compatible en ese método; si no hay, sube al método llamador… recorriendo la pila de llamadas (call stack) hasta main. Si nadie la captura → el programa termina y muestra el stack trace.

Gestión automática de recursos: try-with-resources

• La memoria de objetos normales la libera el Garbage Collector (no hay free/delete como en C).
• Los recursos externos (ficheros, streams, conexiones de red/BD) NO los libera el GC → hay que cerrarlos con close() o usar try-with-resources.
• Java 7. Los recursos se declaran entre paréntesis tras try y se cierran automáticamente (haya excepción o no) en orden inverso al de declaración. Evita resource leaks. El recurso debe implementar AutoCloseable.

try (BufferedReader br = new BufferedReader(new FileReader("in.txt"));   // se cierra 2º
     BufferedWriter bw = new BufferedWriter(new FileWriter("out.txt"))) { // se cierra 1º
    // ...
} catch (IOException e) {
    e.printStackTrace();
}

2 Tipos de acceso a ficheros

Tres enfoques: secuencial, aleatorio/directo y secuencial con buffers. La forma de acceder impacta en rendimiento y complejidad.

3 Lectura y escritura secuencial (streams)

Un stream es una secuencia ordenada de datos que circula de un origen (fichero, memoria, red…) a un destino (fichero, pantalla, socket…). Permite tratar la E/S de forma uniforme sea cual sea el dispositivo.

Bytes (copia byte a byte)FileInputStream in = new FileInputStream("entrada.bin");
FileOutputStream out = new FileOutputStream("sortida.bin");
int byteLlegit;
while ((byteLlegit = in.read()) != -1) { // -1 = fin
    out.write(byteLlegit);
}
in.close();
out.close();

Caracteres (copia carácter a carácter)FileReader in = new FileReader("entrada.txt");
FileWriter out = new FileWriter("sortida.txt");
int caracter;
while ((caracter = in.read()) != -1) {
    out.write(caracter);
}
in.close();
out.close();

Buffered + try-with-resources (numera líneas)try (BufferedReader br = new BufferedReader(new FileReader("entrada.txt"));
     BufferedWriter bw = new BufferedWriter(new FileWriter("sortida.txt"))) {
    String linia;
    int numLinia = 1;
    while ((linia = br.readLine()) != null) {   // readLine devuelve null al final
        bw.write(numLinia + ": " + linia);
        bw.newLine();                           // salto de línea
        numLinia++;
    }
} catch (IOException e) {
    e.printStackTrace();
}

4 Acceso directo / aleatorio · RandomAccessFile

Situarse en cualquier posición física del fichero para leer/escribir sin recorrerlo. Imprescindible: registros de tamaño fijo y conocido → se calcula dónde empieza cada registro.

• Un fichero es una secuencia de bytes; cada byte tiene un índice desde 0 (offset).
• Un puntero de fichero (file pointer) indica la posición actual; se reposiciona con seek.
• Casos de uso: registros fijos con acceso rápido y actualización sin reescribir todo, sistemas antiguos, mini-BD / ejercicios académicos.

RandomAccessFile (paquete java.io)

• Modo "r" (solo lectura → el fichero debe existir, si no FileNotFoundException) o "rw" (lectura/escritura → si no existe lo crea).
• Puntero inicia en 0; cada read/write lo avanza los bytes leídos/escritos.

RandomAccessFile raf = new RandomAccessFile("dades.dat", "rw");
long pos = raf.getFilePointer();
raf.seek(100);            // salta al byte 100
raf.seek(0);              // al principio
raf.seek(raf.length());   // al final (para AÑADIR)
raf.seek(pos - 10);       // retroceder 10 bytes
raf.skipBytes(50);        // avanza 50 bytes

Tamaño de los tipos primitivos MEMORIZAR

Métodos: read()/write(int b) (1 byte), readBoolean/writeBoolean, readChar/writeChar, readInt/writeInt, readDouble/writeDouble, etc. Lectura avanza el puntero. Escritura: si el puntero está en medio sobrescribe; si está al final añade.

Ejemplo: mini-BD de Alumnos

Campos: id (int) · nom (15 chars) · cognom (30 chars) · edat (int) · notaMitjana (double)

GestorAlumnes (resumen del ejemplo)private static final int MIDA_NOM_CHAR = 15, MIDA_COGNOM_CHAR = 30, MIDA_CHAR = 2;
private static final int MIDA_REGISTRE = 4 + MIDA_NOM_CHAR*MIDA_CHAR + MIDA_COGNOM_CHAR*MIDA_CHAR + 4 + 8; // 106

// AÑADIR
public static void afegirAlumne(Alumne a) throws IOException {
    File fitxer = new File(NOM_FITXER);
    File carpeta = fitxer.getParentFile();
    if (carpeta != null && !carpeta.exists()) carpeta.mkdirs();
    try (RandomAccessFile bd = new RandomAccessFile(NOM_FITXER, "rw")) {
        int id = (int) (bd.length() / MIDA_REGISTRE) + 1;   // id automático, evita el 0
        bd.seek(bd.length());                               // ir al final
        bd.writeInt(id);
        escriureStringFix(bd, a.getNom(), MIDA_NOM_CHAR);
        escriureStringFix(bd, a.getCognom(), MIDA_COGNOM_CHAR);
        bd.writeInt(a.getEdat());
        bd.writeDouble(a.getNotaMitjana());
    }
}

// LEER POR ID
public static Alumne llegirAlumne(int id) throws IOException {
    try (RandomAccessFile bd = new RandomAccessFile(NOM_FITXER, "r")) {
        long posicio = (long)(id - 1) * MIDA_REGISTRE;
        if (posicio >= bd.length()) return null;           // no existe
        bd.seek(posicio);
        int idL = bd.readInt();                             // MISMO ORDEN que al escribir
        String nom = llegirStringFix(bd, MIDA_NOM_CHAR);
        String cognom = llegirStringFix(bd, MIDA_COGNOM_CHAR);
        int edat = bd.readInt();
        double nota = bd.readDouble();
        return new Alumne(idL, nom, cognom, edat, nota);
    }
}

// LISTAR TODOS: for (i = 0; i < bd.length()/MIDA_REGISTRE; i++) { bd.seek(i*MIDA_REGISTRE); ...leer... }

// Strings de tamaño fijo: rellenar con espacios / trim al leer
private static void escriureStringFix(RandomAccessFile raf, String text, int mida) throws IOException {
    for (int i = 0; i < mida; i++) {
        char c = (i < text.length()) ? text.charAt(i) : ' ';
        raf.writeChar(c);
    }
}
private static String llegirStringFix(RandomAccessFile raf, int mida) throws IOException {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < mida; i++) sb.append(raf.readChar());
    return sb.toString().trim();
}

Baja lógica vs baja física EXAMEN

5 Serialización y deserialización de objetos

Serializar = convertir un objeto (y todos los que contiene/referencia) en una secuencia de bytes (fichero, red, BD). Deserializar = reconstruir el objeto con el mismo estado.

Usos: guardar/recuperar objetos fácilmente, enviarlos entre programas Java por red (cliente-servidor), replicar estado en frameworks/servidores (Tomcat serializa sesiones, cachés distribuidas). Herramienta para la eficiencia interna en entornos Java.

Funcionamiento

• La clase debe implementar Serializable (interfaz marcadora). Escritura con ObjectOutputStream (writeObject), lectura con ObjectInputStream (readObject + cast).
• Si una clase es serializable, sus hijas también.
• serialVersionUID: identifica la versión de la clase; si cambia la definición y no coincide → InvalidClassException. Recomendable definirlo explícitamente.
• transient: atributos que no se guardan (sensibles o derivables) → al deserializar valen null/0.
• Atributos static no se serializan (son de la clase, no de la instancia).

Ejemplo serializaciónclass Usuari implements Serializable {
    private static final long serialVersionUID = 1L;
    private String email;
    private transient String password;   // NO se guarda → al leer será null
    // constructor, getters...
}

// Serializar
try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("usuari.dat"))) {
    oos.writeObject(usuari);
} catch (IOException e) { e.printStackTrace(); }

// Deserializar
try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("usuari.dat"))) {
    Usuari u = (Usuari) ois.readObject();          // cast obligatorio
} catch (IOException | ClassNotFoundException e) { // ClassNotFoundException también
    e.printStackTrace();
}

6 Intercambio de datos: formatos

Cuando aplicaciones/servicios/módulos se comunican necesitan un lenguaje común: los formatos de intercambio.

Otros formatos: YAML (configuraciones, legible, comentarios, sensible a la indentación) · NDJSON (un JSON por línea, streaming) · Avro / Parquet / Protocol Buffers (binarios, eficientes, esquemas tipados; Big Data y microservicios) · INI / .properties (config. sencilla, típico de Java: Properties.load).

Parsers (analizadores sintácticos) y binding

Los parsers son críticos: puente entre representaciones, abstracción de complejidad, validación y seguridad (comprueban coherencia), eficiencia con grandes volúmenes.

Data binding (mapeo automático)

El desarrollador define clases que describen la estructura y, con anotaciones, esquemas o convenciones de nombres, el parser hace la serialización (objeto → documento) y la deserialización (documento → objeto) de forma transparente.

• Productividad y código limpio, objetos tipados, validación integrada

• Pérdida de control fino del flujo, coste inicial de configuración con datos irregulares, más coste computacional (overhead)

Tipos de parsers según el modelo de procesamiento

7 Parser DOM XML árbol

DOM (Document Object Model): representación jerárquica en árbol de un XML cargado en memoria. Estándar del W3C. El parser lee el XML entero, lo valida (si se pide) y construye el árbol; permite navegar, consultar y modificar.

Consideraciones al generar el árbol EXAMEN

• Aunque haya esquema, DOM no valida salvo que se indique; solo exige que esté bien formado.
• El primer nodo es el nodo raíz que representa el documento.
• Los atributos NO generan nodos hijos: forman parte de la información del nodo.
• Los valores de los elementos son nodos #text hijos del elemento.
• Los saltos de línea y espacios también son nodos #text.
• La librería permite ignorar comentarios, espacios en blanco, etc.

Arquitectura

Proceso

• normalize() (doc.getDocumentElement().normalize()): fusiona nodos de texto adyacentes y limpia.
• Lectura: getElementsByTagName, getAttribute, getTextContent, recorridos con NodeList (getLength(), item(i)).
• Modificación: setTextContent, setAttribute, appendChild, removeChild, replaceChild, doc.createElement.
• Serialización: con Transformer (TransformerFactory, DOMSource, StreamResult).

LibrosXML.xml (estructura usada en todos los ejemplos)<Libros>
  <Libro publicado_en="1840">
    <Titulo>...</Titulo>
    <Autor>...</Autor>
  </Libro>
  ...
</Libros>

DOMLibrosExample// 1) Configuración
DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
f.setFeature(XMLConstants.FEATURE_SECURE_PROCESSING, true); // protección XXE
f.setNamespaceAware(true);
f.setIgnoringElementContentWhitespace(true);
f.setIgnoringComments(true);
DocumentBuilder b = f.newDocumentBuilder();

// 2) Parsear  3) Normalizar
Document doc = b.parse(new File("data/LibrosXML.xml"));
doc.getDocumentElement().normalize();

// 4A) Recorrer con getChildNodes (hay que filtrar los #text → instanceof Element)
NodeList llista = doc.getFirstChild().getChildNodes();
for (int i = 0; i < llista.getLength(); i++) {
    if (llista.item(i) instanceof Element) {
        Node e = llista.item(i);
        String any = e.getAttributes().getNamedItem("publicado_en").getNodeValue();
        NodeList fills = e.getChildNodes();
        for (int j = 0; j < fills.getLength(); j++) {
            if (fills.item(j) instanceof Element) {
                Node fill = fills.item(j);
                if (fill.getNodeName().equals("Titulo")) titol = fill.getTextContent();
                else if (fill.getNodeName().equals("Autor")) autor = fill.getTextContent();
            }
        }
    }
}

// 4B) Recorrer con getElementsByTagName (más cómodo)
NodeList llibres = doc.getElementsByTagName("Libro");
for (int i = 0; i < llibres.getLength(); i++) {
    Element e = (Element) llibres.item(i);
    String any   = e.getAttribute("publicado_en");
    String titol = e.getElementsByTagName("Titulo").item(0).getTextContent();
    String autor = e.getElementsByTagName("Autor").item(0).getTextContent();
}

// 4C) Modificar atributo
if (llibres.getLength() > 0) ((Element) llibres.item(0)).setAttribute("publicado_en", "1842");

// 4D) Añadir nuevo libro
Element arrel = doc.getDocumentElement();
Element nou = doc.createElement("Libro");
nou.setAttribute("publicado_en", "2025");
Element t = doc.createElement("Titulo"); t.setTextContent("Llibre exemple DOM");
Element a = doc.createElement("Autor");  a.setTextContent("Joan Developer");
nou.appendChild(t); nou.appendChild(a);
arrel.appendChild(nou);

// 5) Guardar
Transformer tr = TransformerFactory.newInstance().newTransformer();
tr.setOutputProperty(OutputKeys.INDENT, "yes");
tr.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
tr.transform(new DOMSource(doc), new StreamResult(new File("data/LibrosXML_modificat.xml")));

8 Parser DOM JSON (Gson / Jackson Tree) árbol binding

Árbol en memoria de un JSON, similar al DOM XML. No es un estándar W3C, pero es un modelo común (Jackson, Gson, org.json).

Diferencias con el DOM XML EXAMEN

• Jackson/Gson no validan contra JSON Schema automáticamente; solo comprueban sintaxis (comillas, llaves, comas).
• El nodo raíz puede ser objeto o array (equivale al Document).
• Clave y valor son parte del mismo nodo. No hay atributos (Attr).
• Valores literales (texto, números, booleanos, null) = nodos hoja. No hay nodos #text.
• Espacios y saltos de línea se ignoran (no son nodos).
• Comentarios no permitidos por el estándar → error. Jackson puede aceptarlos si se activa la propiedad.

Lectura: get("clau"), getAsString(), getAsInt(), getAsBoolean(), getAsJsonArray(), getAsJsonObject() · Modificación: addProperty("clau", valor), add("clau", JsonElement), remove("clau") · Guardar: gson.toJson(arrel, writer) (con setPrettyPrinting() sale indentado).

Gson SIN binding (árbol)try (Reader reader = new InputStreamReader(new FileInputStream("data/Libros.json"), StandardCharsets.UTF_8)) {
    Gson gson = new GsonBuilder().setPrettyPrinting().serializeNulls().create();

    JsonObject arrel = JsonParser.parseReader(reader).getAsJsonObject();   // árbol
    JsonArray llibres = arrel.getAsJsonArray("Libros");
    if (llibres == null) { System.err.println("No hi ha 'Libros'"); return; }

    for (JsonElement e : llibres) {
        JsonObject llibre = e.getAsJsonObject();
        String titol = llibre.get("Titulo").getAsString();
        int any = llibre.get("publicado_en").getAsInt();
    }
    llibres.get(0).getAsJsonObject().addProperty("publicado_en", 1842);    // modificar

    JsonObject nou = new JsonObject();                                      // añadir
    nou.addProperty("Titulo", "DOM i JSON");
    nou.addProperty("Autor", "Maria Dom");
    nou.addProperty("publicado_en", 2025);
    llibres.add(nou);

    try (Writer w = new OutputStreamWriter(new FileOutputStream("data/Libros_modificat.json"), StandardCharsets.UTF_8)) {
        gson.toJson(arrel, w);                                              // guardar
    }
} catch (IOException e) { ...
} catch (IllegalStateException e) { /* formato JSON incorrecto */ }

Gson CON binding (POJO)

POJO (Plain Old Java Object): clase simple con atributos, constructores, getters y setters. Requisitos: nombres de propiedades = claves JSON (si no, anotar con @SerializedName("Clau")), constructor vacío, getters y setters.

Gson CON bindingGson gson = new GsonBuilder().setPrettyPrinting().create();
Biblioteca biblioteca = gson.fromJson(reader, Biblioteca.class);   // JSON → objeto (deserialización)
biblioteca.getLibros().get(0).setPublicadoEn(1842);
biblioteca.getLibros().add(new Libro("Json, Java i Pojo", "Ana Java", 2025));
gson.toJson(biblioteca, writer);                                    // objeto → JSON (serialización)

public class Biblioteca {
    @SerializedName("Libros") private List<Libro> libros;
    // getters/setters
}
public class Libro {
    @SerializedName("Titulo")       private String titulo;
    @SerializedName("Autor")        private String autor;
    @SerializedName("publicado_en") private int publicadoEn;
    public Libro() {}                       // constructor vacío obligatorio
    // constructor completo, getters, setters, toString
}

9 Parser SAX XML push

SAX (Simple API for XML): procesamiento secuencial basado en eventos. No carga el documento: lo recorre de inicio a fin y genera eventos que ejecutan métodos callback automáticamente.

Muy eficiente en memoria y rápido. No permite acceso libre a cualquier parte ni modificaciones (unidireccional, sin árbol).

LibrosHandler extends DefaultHandlerpublic class LibrosHandler extends DefaultHandler {
    private List<Libro> llistaLlibres;
    private Libro llibreActual;
    private StringBuilder contingut;

    @Override public void startDocument() { llistaLlibres = new ArrayList<>(); contingut = new StringBuilder(); }

    @Override public void startElement(String uri, String localName, String qName, Attributes attributes) {
        contingut.setLength(0);
        if ("libro".equalsIgnoreCase(qName)) {
            llibreActual = new Libro();
            String p = attributes.getValue("publicado_en");
            if (p != null) llibreActual.setPublicadoEn(Integer.parseInt(p));
        }
    }

    @Override public void characters(char[] ch, int start, int length) {
        contingut.append(ch, start, length);        // ACUMULAR: puede venir en varios trozos
    }

    @Override public void endElement(String uri, String localName, String qName) {
        String dades = contingut.toString().trim();
        if (llibreActual != null) {
            switch (qName.toLowerCase()) {
                case "titulo": llibreActual.setTitulo(dades); break;
                case "autor":  llibreActual.setAutor(dades);  break;
                case "libro":  llistaLlibres.add(llibreActual); llibreActual = null; break;
            }
        }
        contingut.setLength(0);
    }
    public List<Libro> getLlistaLlibres() { return llistaLlibres; }
}

LibrosSAXReaderSAXParserFactory factory = SAXParserFactory.newInstance();
factory.setNamespaceAware(true);
factory.setValidating(false);
// Seguridad XXE
factory.setFeature("http://xml.org/sax/features/external-general-entities", false);
factory.setFeature("http://xml.org/sax/features/external-parameter-entities", false);
factory.setFeature("http://apache.org/xml/features/nonvalidating/load-external-dtd", false);

SAXParser parser = factory.newSAXParser();
LibrosHandler handler = new LibrosHandler();
parser.parse("data/LibrosXML.xml", handler);       // el parser llama a los callbacks
List<Libro> llibres = handler.getLlistaLlibres();

10 Parser StAX XML pull

StAX (Streaming API for XML): streaming con modelo pull-parsing; la aplicación cliente mantiene el control síncrono. El parser espera hasta que se llama a next(), avanza al siguiente token y devuelve su tipo.

Gestión determinista del flujo, muy eficiente (solo el nodo actual). Mismas limitaciones que SAX: sin acceso aleatorio ni modificación.

javax.xml.stream.*

Métodos: next() (avanza y devuelve tipo, int) · hasNext() · getEventType() · getLocalName() / getAttributeValue(null,"nom") (en START_ELEMENT) · getText() (en CHARACTERS).

LibrosStaxReaderXMLInputFactory factory = XMLInputFactory.newInstance();
factory.setProperty(XMLInputFactory.IS_SUPPORTING_EXTERNAL_ENTITIES, false); // XXE
factory.setProperty(XMLInputFactory.SUPPORT_DTD, false);

try (FileInputStream fis = new FileInputStream("data/LibrosXML.xml")) {
    XMLStreamReader reader = factory.createXMLStreamReader(fis);
    Libro llibre = null;
    StringBuilder text = new StringBuilder();

    while (reader.hasNext()) {
        int event = reader.next();                     // EL PROGRAMA pide el siguiente
        switch (event) {
            case XMLStreamConstants.START_ELEMENT:
                text.setLength(0);
                if ("Libro".equals(reader.getLocalName())) {
                    llibre = new Libro();
                    String any = reader.getAttributeValue(null, "publicado_en");
                    if (any != null) llibre.setPublicadoEn(Integer.parseInt(any));
                }
                break;
            case XMLStreamConstants.CHARACTERS:
                text.append(reader.getText());         // acumular
                break;
            case XMLStreamConstants.END_ELEMENT:
                String value = text.toString().trim();
                if (llibre != null) switch (reader.getLocalName()) {
                    case "Titulo": llibre.setTitulo(value); break;
                    case "Autor":  llibre.setAutor(value);  break;
                    case "Libro":  llista.add(llibre); llibre = null; break;
                }
                text.setLength(0);
                break;
        }
    }
    reader.close();   // XMLStreamReader NO es AutoCloseable → close() manual
}

11 Jackson Streaming API (JSON) pull binding

Streaming pull-parsing para JSON: el parser espera a nextToken(), avanza y devuelve el tipo de token. Solo el token actual en memoria. Sin acceso aleatorio ni modificación (como StAX). Ideal para documentos grandes o flujos continuos.

com.fasterxml.jackson.core

• JsonFactory: crea JsonParser y JsonGenerator; opciones (comentarios, apóstrofes como comillas, tolerancia a errores).
• JsonParser: lectura secuencial pull.
• JsonToken (enum): START_OBJECT, END_OBJECT, START_ARRAY, END_ARRAY, FIELD_NAME, VALUE_STRING, VALUE_NUMBER_INT, VALUE_TRUE, VALUE_FALSE, VALUE_NULL.
• JsonGenerator: escritura (writeStartObject(), writeFieldName(), writeString(), writeNumber(), writeEndObject()).
• JsonProcessingException · JsonFactory.Feature / JsonParser.Feature (configuración).

Métodos: nextToken() · currentName() (nombre del campo) · getValueAsString() / getValueAsInt() · skipChildren() (salta un objeto/array entero sin leerlo).

LibrosJacksonReader (sin binding)JsonFactory factory = new JsonFactory();
factory.enable(JsonParser.Feature.ALLOW_COMMENTS);          // aceptar comentarios

try (JsonParser parser = factory.createParser(new File("data/Libros.json"))) {   // SÍ es AutoCloseable
    if (parser.nextToken() != JsonToken.START_OBJECT) { System.out.println("S'esperava un objecte"); return; }

    while (parser.nextToken() != JsonToken.END_OBJECT) {
        String fieldName = parser.currentName();
        if ("Libros".equals(fieldName)) {
            parser.nextToken();                                  // START_ARRAY
            while (parser.nextToken() != JsonToken.END_ARRAY) {
                if (parser.getCurrentToken() == JsonToken.START_OBJECT) {
                    Libro llibre = new Libro();
                    while (parser.nextToken() != JsonToken.END_OBJECT) {
                        String nomCamp = parser.currentName();   // estamos en FIELD_NAME
                        parser.nextToken();                      // pasar al VALOR
                        switch (nomCamp) {
                            case "Titulo":       llibre.setTitulo(parser.getValueAsString()); break;
                            case "Autor":        llibre.setAutor(parser.getValueAsString());  break;
                            case "publicado_en": llibre.setPublicadoEn(parser.getValueAsInt()); break;
                            default:             parser.skipChildren();
                        }
                    }
                    llista.add(llibre);
                } else parser.skipChildren();
            }
        } else { parser.nextToken(); parser.skipChildren(); }   // otro campo → saltarlo
    }
}

Jackson CON binding (ObjectMapper)

Requisitos: nombres atributos = claves (si no, @JsonProperty("NomCamp")), constructor vacío, getters y setters públicos.

LibrosJacksonReaderBindingObjectMapper mapper = new ObjectMapper();
Biblioteca biblioteca = mapper.readValue(new File("data/Libros.json"), Biblioteca.class); // JSON → objetos
// mapper.writeValue(new File("out.json"), biblioteca);                                    // objetos → JSON

public class Biblioteca {
    @JsonProperty("Libros") private List<Libro> llibres;
    // getters/setters
}
public class Libro {
    @JsonProperty("Titulo")       private String titulo;
    @JsonProperty("Autor")        private String autor;
    @JsonProperty("publicado_en") private int publicadoEn;
    // getters/setters, toString
}

12 API JAXB (XML) binding

JAXB (Java Architecture for XML Binding) no es un parser: es una especificación oficial de Java para mapear XML ↔ objetos Java (bidireccional). Solo define interfaces, anotaciones y comportamiento; no incluye implementación.

• Necesita una implementación real, que internamente usa un parser de bajo nivel.
• Implementación oficial: GlassFish JAXB RI (Reference Implementation) → por defecto usa SAX (se puede forzar StAX).
• Desde Java 11 JAXB no está en el JDK → añadir dependencias: la API (especificación) + la implementación. Paquete: jakarta.xml.bind.

Arquitectura en 3 capas

Anotaciones EXAMEN

<!-- @XmlElementWrapper(name="Cont") + @XmlElement(name="Ind") sobre una List -->
<Cont><Ind>...</Ind><Ind>...</Ind></Cont>

JAXB completo@XmlRootElement(name = "Libros")
@XmlAccessorType(XmlAccessType.FIELD)
public class Biblioteca {
    @XmlElement(name = "Libro")
    private List<Libro> llibres;
    public Biblioteca() {}                     // obligatorio
    // getters/setters
}

@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(propOrder = { "titulo", "autor" })   // orden de los ELEMENTOS (el atributo no va)
public class Libro {
    @XmlElement(name = "Titulo")         private String titulo;
    @XmlElement(name = "Autor")          private String autor;
    @XmlAttribute(name = "publicado_en") private int publicadoEn;
    public Libro() {}
    // constructor completo, getters/setters, toString
}

// Lectura y escritura
JAXBContext context = JAXBContext.newInstance(Biblioteca.class);

Unmarshaller um = context.createUnmarshaller();
Biblioteca biblio = (Biblioteca) um.unmarshal(new File("data/LibrosXML.xml"));     // XML → Java

biblio.getLlibres().add(new Libro("Cien años de soledad", "Gabriel García Márquez", 1967));

Marshaller m = context.createMarshaller();
m.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);                             // indentado
m.marshal(biblio, new File("data/LibrosXML_Escriptura.xml"));                      // Java → XML

P1 Práctica media-manager · estructura

Proyecto Maven, Java 21, paquete cat.institutmarianao.mediamanager. Aquí se aplica toda la teoría anterior: XML (DOM, SAX, StAX, JAXB), JSON (Gson, Jackson), exportaciones y fichero binario.

Estructura del proyectomodel/                      ← lo da la profe, NO se toca
  MediaContent (abstracta)  → code, title, director, genre, releaseDate (LocalDate), platform
  ├─ Movie   (tipo 'P')     → runtime (int, minutos)
  └─ Series  (tipo 'S')     → List<Season>
        Season              → number, List<Episode>
          Episode           → number, title, runtime
  Catalog                   → LinkedHashMap; addContent() asigna códigos 1, 2, 3…

persistence/                ← lo implementa el alumno (los TODO)
  xml/    DomMovieImporter, SaxMovieImporter (+ FilmSaxHandler), StaxSeriesImporter,
          JaxbCatalogImporter (+ xml/jaxb/CatalogXml), DomCatalogExporter
  json/   GsonCatalogImporter (+ json/gson/GsonContents),
          JacksonCatalogImporter (+ json/jackson/JacksonContents),
          ContentFactory (conversión común), JacksonCatalogExporter
  text/   TextCatalogExporter
  binary/ BinaryCatalogDao (RandomAccessFile), BinaryCatalogRecord

Main         ← lanzador: argumentos all, 1…6, 1-dom, 1-sax, 1-stax, 1-jaxb, 2-gson, 2-jackson
data/input/  ← entrada · data/output/ ← ficheros generados

P2 Reglas comunes de los importadores (Javadoc)

Plantilla general de un importadorpublic List<Movie> importMovies(File input) throws IOException {
    Objects.requireNonNull(input, "input");          // fuera del try
    List<Movie> movies = new ArrayList<>();
    try (InputStream in = new FileInputStream(input)) {
        // parser + recorrido + new Movie(...)
    } catch (Exception e) {
        throw new IOException("Error importando " + input + ": " + e.getMessage(), e);
    }
    return movies;
}

Conversiones: LocalDate.parse("2014-11-07") (formato yyyy-MM-dd) · Integer.parseInt("169").

P3 Práctica · importadores XML

Tarea 1-dom · DomMovieImporter (movies_dom.xml)

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(in);                 // o builder.parse(file)
doc.getDocumentElement().normalize();

NodeList movies = doc.getElementsByTagName("movie");
for (int i = 0; i < movies.getLength(); i++) {    // NodeList: for con índice, no for-each
    Element movie = (Element) movies.item(i);     // item() devuelve Node → cast
    String title = movie.getElementsByTagName("name").item(0).getTextContent().trim();
    String id    = movie.getAttribute("id");      // atributo (se ignora como código)
}

• getElementsByTagName("x") busca en todos los descendientes; getChildNodes() solo hijos directos incluidos los #text → filtrar con getNodeType() == Node.ELEMENT_NODE.
• getTextContent() · getAttribute("x") · getTagName().
• Excepciones: ParserConfigurationException, SAXException (XML mal formado, DOM la usa aunque se llame SAX), IOException.

Tarea 1-sax · SaxMovieImporter + FilmSaxHandler (films_sax.xml)

SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser parser = factory.newSAXParser();
FilmSaxHandler handler = new FilmSaxHandler();
parser.parse(in, handler);
return handler.getMovies();

public class FilmSaxHandler extends DefaultHandler {
    private final List<Movie> movies = new ArrayList<>();
    private final StringBuilder texto = new StringBuilder();
    private String seccion;                       // contexto: creators / classification / availability

    @Override public void startElement(String uri, String localName, String qName, Attributes atts) {
        texto.setLength(0);                       // vaciar buffer
        if (qName.equals("film")) { title = atts.getValue("name"); }   // <film name="Coco"> → atributo
        // guardar la sección padre
    }
    @Override public void characters(char[] ch, int start, int length) {
        texto.append(ch, start, length);          // puede llegar a trozos
    }
    @Override public void endElement(String uri, String localName, String qName) {
        // usar texto.toString().trim(); en </film> → new Movie(...) y add
    }
}

SAX no dice quién es el padre → guardas el contexto tú (String seccion o un boolean). El handler puede ser private static class interna o clase pública aparte.

Tarea 1-stax · StaxSeriesImporter (series_stax.xml)

Jerarquía: <show> → <details> → <season> → <episode>.

XMLInputFactory factory = XMLInputFactory.newInstance();
XMLStreamReader reader = factory.createXMLStreamReader(in);
while (reader.hasNext()) {
    int evento = reader.next();
    if (evento == XMLStreamConstants.START_ELEMENT) {
        switch (reader.getLocalName()) {
            case "season" -> season = new Season(Integer.parseInt(reader.getAttributeValue(null, "number")));
            case "title"  -> title = reader.getElementText().trim();
        }
    } else if (evento == XMLStreamConstants.END_ELEMENT) {
        switch (reader.getLocalName()) {
            case "season" -> series.addSeason(season);
            case "show"   -> lista.add(series);
        }
    }
}
reader.close();                                   // no es AutoCloseable (el FileInputStream sí va en el try)

• getElementText() lee el texto y mueve el cursor hasta el cierre → leer los atributos antes.
• getAttributeValue(null, "x"): null = sin namespace.
• La Series se crea al cerrar </details> (el constructor necesita el director).
• <title> aparece en serie y en episodio → flag dentroEpisodio.
• season.addEpisode(...) y series.addSeason(...).
• Escribir con StAX: XMLOutputFactory → XMLStreamWriter (writeStartElement, writeAttribute, writeCharacters, writeEndElement).

Tarea 1-jaxb · JaxbCatalogImporter + CatalogXml (catalog_jaxb.xml)

JAXBContext context = JAXBContext.newInstance(CatalogXml.SupplierCatalog.class);
Unmarshaller unmarshaller = context.createUnmarshaller();
CatalogXml.SupplierCatalog catalog = (CatalogXml.SupplierCatalog) unmarshaller.unmarshal(in);
// después: según category (movie / show) → new Movie(...) o new Series(...) + Season + Episode

• Regla: cada etiqueta con hijos = una clase; cada hijo simple = un campo. Etiquetas sin campo se ignoran (p. ej. sourceCode).
• Constructor sin argumentos; clases internas public static class.
• Fechas como String → LocalDate.parse (JAXB no convierte LocalDate solo).
• Java 21 / JAXB 4 → jakarta.xml.bind.* (no javax). Dependencias: jakarta.xml.bind-api + jaxb-runtime.
• Clases intermedias en persistence.xml.jaxb (separado del modelo). Excepción: JAXBException.
• @XmlValue = texto de la propia etiqueta · @XmlElementWrapper(name="entries") para <entries><entry/>…</entries>.

P4 Práctica · importadores JSON (Gson vs Jackson)

JSON ↔ Java: { } → clase (POJO) · [ ] → List<…> · "texto" → String · número → int/long/double · true/false → boolean · null → null.

GsonGson gson = new GsonBuilder().setPrettyPrinting().create();
try (Reader reader = new InputStreamReader(new FileInputStream(input), StandardCharsets.UTF_8)) {
    GsonContents.Root root = gson.fromJson(reader, GsonContents.Root.class);   // JSON → objeto
}

JacksonObjectMapper mapper = new ObjectMapper();
mapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
try (InputStream in = new FileInputStream(input)) {
    JacksonContents.Root root = mapper.readValue(in, JacksonContents.Root.class);
}

Otras anotaciones Jackson: @JsonPropertyOrder({...}) (orden), @JsonIgnore (excluir), @JsonInclude(JsonInclude.Include.NON_NULL) (no escribir nulos).

Clases intermedias

P5 Práctica · exportaciones (tareas 3, 4, 5)

OrdenaciónComparator<MediaContent> orden = Comparator
        .comparing(MediaContent::getTitle, String.CASE_INSENSITIVE_ORDER)
        .thenComparingInt(MediaContent::getCode);

Tarea 4 · escribir con DOMDocument doc = builder.newDocument();
Element catalog = doc.createElement("catalog");
doc.appendChild(catalog);
Element movies = doc.createElement("movies");
catalog.appendChild(movies);
Element movie = doc.createElement("movie");
movie.setAttribute("code", String.valueOf(m.getCode()));
Element title = doc.createElement("title");
title.setTextContent(m.getTitle());
movie.appendChild(title);
movies.appendChild(movie);

Transformer transformer = TransformerFactory.newInstance().newTransformer();
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
try (Writer writer = new OutputStreamWriter(new FileOutputStream(out), StandardCharsets.UTF_8)) {
    transformer.transform(new DOMSource(doc), new StreamResult(writer));
}

Tarea 5 · escribir con JacksonObjectMapper mapper = new ObjectMapper();
mapper.enable(SerializationFeature.INDENT_OUTPUT);
try (Writer writer = new OutputStreamWriter(new FileOutputStream(out), StandardCharsets.UTF_8)) {
    mapper.writeValue(writer, objetoDeSalida);   // clases de binding de salida
}

Nota: en los ejemplos de escritura DOM los nombres de etiquetas (movie, title, atributo code) son ilustrativos; usa los que pida el enunciado.

P6 Práctica · fichero binario (tarea 6)

BinaryCatalogDao con RandomAccessFile (modos "r" / "rw", seek). La búsqueda devuelve un BinaryCatalogRecord.

• Códigos únicos y seguidos desde 1; el registro va según su código, no según el orden de la colección.
• Título > 40 caracteres → se rechaza con excepción (nunca se recorta).
• Al leer se quitan los espacios de relleno: stripTrailing().
• Al crear se reemplaza entero: raf.setLength(0).
• Fichero inexistente o corrupto → IOException; código que no está → Optional.empty().

Esqueleto orientativoprivate static final int TITLE_CHARS = 40;
private static final int RECORD_SIZE = 4 + TITLE_CHARS * 2 + 2 + 8 + 4 + 4; // 102

// escribir
try (RandomAccessFile raf = new RandomAccessFile(file, "rw")) {
    raf.setLength(0);                                       // reemplazar
    for (MediaContent c : contents) {
        if (c.getTitle().length() > TITLE_CHARS) throw new IllegalArgumentException("Título demasiado largo");
        raf.seek((long) (c.getCode() - 1) * RECORD_SIZE);   // según código
        raf.writeInt(c.getCode());
        raf.writeChars(String.format("%-40s", c.getTitle())); // rellenar a 40
        raf.writeChar(c instanceof Movie ? 'P' : 'S');
        raf.writeLong(c.getReleaseDate().toEpochDay());
        raf.writeInt(temporadas);                           // 0 en películas
        raf.writeInt(episodiosTotales);
    }
}

// buscar
try (RandomAccessFile raf = new RandomAccessFile(file, "r")) {
    if (codigo < 1 || codigo > raf.length() / RECORD_SIZE) return Optional.empty();
    raf.seek((long) (codigo - 1) * RECORD_SIZE);
    int code = raf.readInt();
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < TITLE_CHARS; i++) sb.append(raf.readChar());
    String title = sb.toString().stripTrailing();
    char tipo = raf.readChar();
    LocalDate fecha = LocalDate.ofEpochDay(raf.readLong());
    int temporadas = raf.readInt(), episodios = raf.readInt();
    return Optional.of(new BinaryCatalogRecord(/* ... */));
}

El esqueleto es orientativo (nombres de getters y constructor de BinaryCatalogRecord según tu código; la excepción concreta para títulos largos, según el Javadoc).

P7 Práctica · conceptos y errores típicos

Conceptos

• Deserializar / unmarshal / parsear: documento → objetos. Serializar / marshal: objetos → documento.
• Clase intermedia (DTO de binding): copia la forma del fichero externo para no tocar el modelo; luego se convierte.
• XML bien formado: una sola raíz, etiquetas cerradas y bien anidadas, atributos entre comillas, distingue mayúsculas. Válido: además cumple DTD o XSD.
• Elemento vs atributo: <film name="Coco"> → atributo; <name>Coco</name> → elemento con texto.
• Puente bytes→texto: InputStreamReader / OutputStreamWriter con StandardCharsets.UTF_8.
• Encadenar excepciones: new IOException(mensaje, causa) conserva el error original (getCause()).

Errores típicos

1. getElementsByTagName("name") devuelve también el <name> del director.
2. Olvidar texto.setLength(0) en SAX → los textos se acumulan.
3. Leer atributos después de getElementText() en StAX.
4. Crear la Series antes de tener el director.
5. javax.xml.bind en vez de jakarta.xml.bind.
6. Clases internas JAXB sin static o sin constructor vacío.
7. Jackson sin FAIL_ON_UNKNOWN_PROPERTIES = false con campos extra (externalId, provider).
8. Gson sin UTF-8 en el Reader → acentos mal.
9. Usar los ids del fichero como códigos (los pone Catalog).
10. Dejar throw new ExerciseNotImplementedException o meterlo en el catch (Main mostraría NOT_IMPLEMENTED).
11. System.out dentro de importadores/exportadores.
12. requireNonNull dentro del try → el catch lo convierte en IOException.
13. Nombres de variables que no coinciden (movieEl vs movieE1, episodNumber vs episodeNumber).
14. Binario: tamaño de registro mal (char = 2 bytes) o posición mal ((codigo - 1) * 102).

13 Tablas resumen para el examen

Parsers: quién es quién

Anotaciones de binding

Lectura / escritura por API

14 Trampas típicas de examen

1. File no lee ni escribe contenido; es solo la ruta. Crear un File no crea el fichero.
2. delete() sobre un directorio solo funciona si está vacío. mkdirs() crea padres, mkdir() no.
3. getCanonicalPath() lanza IOException; getAbsolutePath() no limpia ...
4. El GC no cierra ficheros. try-with-resources (Java 7) cierra en orden inverso.
5. Excepciones de ficheros = checked. FileNotFoundException es subclase de IOException → en multi-catch van primero las más específicas.
6. "r" exige que exista; "rw" lo crea si no existe.
7. char ocupa 2 bytes en RandomAccessFile (writeChar). Un String de 15 chars = 30 bytes.
8. Leer en el mismo orden que se escribió. Para añadir: seek(length()).
9. transient y static no se serializan. Sin serialVersionUID coincidente → InvalidClassException. readObject también lanza ClassNotFoundException.
10. DOM XML: atributos ≠ nodos hijos; los textos sí son nodos #text (y los espacios también).
11. DOM JSON: no hay atributos ni nodos #text; espacios ignorados; comentarios no permitidos (Jackson puede activarlos con ALLOW_COMMENTS).
12. SAX = push (el parser manda, callbacks, DefaultHandler). StAX/Jackson Streaming = pull (el programa manda con next/nextToken).
13. characters() puede llegar troceado → StringBuilder.
14. JAXB no es un parser sino una especificación; desde Java 11 no está en el JDK; RI usa SAX por defecto.
15. JAXB: FIELD recomendado (explícito), PROPERTY por defecto. Marshaller = Java→XML.
16. DOM consume 5-10 veces el tamaño del fichero; recomendado hasta 10-50 MB.
17. XML se valida con XSD/DTD; JSON (opcional) con JSON Schema. JSON es más compacto; XML más verboso.
18. Binding sin parsing: imposible.

🎮 Quiz tipo Kahoot