# aadd_conect05: Procesamiento de ficheros JSON y XML con Jackson, JDBC, patrón DAO y Service Layer (MySQL) ## Descripción Proyecto en Java que procesa dos ficheros (un JSON de familias profesionales y un XML de ciclos formativos) y vuelca su información en la base de datos `Formacion_FP`, administrada por MySQL. Se utiliza el API JDBC, el patrón DAO (solo para el acceso a la base de datos) y el patrón Service Layer. Todas las sentencias SQL se ejecutan con `PreparedStatement` y están declaradas como constantes `private static final`. Es la evolución de `aadd_conect04` con tres novedades: - **Procesamiento con Jackson**: el fichero de familias profesionales pasa de CSV a **JSON** (`ObjectMapper`) y el de ciclos formativos se lee con **Jackson XML** (`XmlMapper`) en lugar del paquete DOM de Java. En ambos casos se recorre el contenido con la clase `JsonNode`. - **Una clase de servicio por entidad**: `FamiliaProfesionalService` y `CicloFormativoService`, que aplican las reglas de negocio y gestionan la conexión. - **Procesadores de ficheros**: `ProcesadorFicheroJSON` y `ProcesadorFicheroXML` leen los ficheros y llaman a los servicios. Los datos de conexión y las rutas de los ficheros no están escritos en el código: se leen del fichero `application.properties` a través de la clase `GestorConfiguracion`. ## Estructura del proyecto - `aadd_conect05/` - `src/org/palomafp/aadd/dta/` - `AppPrincipal.java`: clase principal que lanza el tratamiento de los dos ficheros - `model/` - `FamiliaProfesional.java`: clase del modelo (una familia profesional) - `TipoFormacion.java`: clase del modelo (un tipo de formación) - `CicloFormativo.java`: clase del modelo (un ciclo formativo, con su familia y su tipo) - `dao/` - `IFamiliaProfesionalDAO.java`: interfaz del DAO de familias profesionales - `ITipoFormacionDAO.java`: interfaz del DAO de tipos de formación - `ICicloFormativoDAO.java`: interfaz del DAO de ciclos formativos - `impl/` - `FamiliaProfesionalDaoJDBC.java`: implementación JDBC con `PreparedStatement` - `TipoFormacionDaoJDBC.java`: implementación JDBC con `PreparedStatement` - `CicloFormativoDaoJDBC.java`: implementación JDBC con `PreparedStatement` - `service/` - `FamiliaProfesionalService.java`: casos de uso de familias profesionales - `CicloFormativoService.java`: casos de uso de ciclos formativos - `util/` - `ProcesadorFicheroJSON.java`: lee el JSON de familias con Jackson y llama al servicio - `ProcesadorFicheroXML.java`: lee el XML de ciclos con Jackson y llama al servicio - `excepciones/` - `FormacionException.java`: excepción de aplicación (checked) - `gestores/` - `GestorConfiguracion.java`: carga `application.properties` y expone sus valores - `GestorConexionBBDD.java`: crea las conexiones a la base de datos - `config/` - `application.properties`: configuración (conexión a la BBDD y rutas de los ficheros) - `ficheros/` - `familias_pro.json`: familias profesionales a procesar - `catalogo_formacion.xml`: ciclos formativos a procesar - `Formacion_FP.sql`: script de creación de la base de datos - `pom.xml` - `README.md` ## Dependencias (Maven) | Dependencia | Uso | |---|---| | `mysql-connector-j` | Driver JDBC de MySQL | | `jackson-databind` | `ObjectMapper` y `JsonNode` (lectura del JSON) | | `jackson-dataformat-xml` | `XmlMapper` (lectura del XML) | ## Base de datos El script `Formacion_FP.sql` crea la base de datos `Formacion_FP` con tres tablas: | Tabla | Columnas | |---|---| | `T_FAMILIA_PROFESIONAL` | `codigo` (PK), `nombre` | | `T_TIPO_FORMACION` | `codigo` (PK), `nombre_corto`, `nombre_largo` | | `T_CICLO_FORMATIVO` | `codigo` (PK), `nombre_corto`, `nombre_largo`, `horas_duracion`, `codigo_familia` (FK a `T_FAMILIA_PROFESIONAL`), `codigo_tipo_formacion` (FK a `T_TIPO_FORMACION`) | Tras ejecutar el script, la base de datos contiene la familia `ADG` (con un nombre distinto al del JSON) y los cuatro tipos de formación: `CFGB`, `CFGM`, `CFGS` y `CE`. No contiene ciclos formativos. ## Origen y destino de los datos | Información | Origen | Destino | |---|---|---| | Familias profesionales | Fichero JSON | `T_FAMILIA_PROFESIONAL` | | Ciclos formativos | Fichero XML | `T_CICLO_FORMATIVO` | | Tipos de formación | Base de datos (`T_TIPO_FORMACION`) | Solo se consulta | ## Arquitectura en capas ``` AppPrincipal → Procesador (util) → Service → DAO → Base de datos ↓ Ficheros (JSON y XML) con Jackson ``` | Capa | Responsabilidad | |---|---| | `AppPrincipal` | Decide qué se ejecuta y captura la excepción de aplicación. No conoce conexiones, SQL ni ficheros | | Procesador | Lee el fichero con Jackson, convierte cada nodo en un objeto del modelo y llama al servicio | | Servicio | Representa los casos de uso. Abre y cierra la conexión y aplica las reglas de negocio | | DAO | Ejecuta las sentencias SQL de una tabla. Recibe la conexión por constructor y no la cierra | | Modelo | Clases que representan una fila de cada tabla | El patrón DAO se usa **únicamente para el acceso a la base de datos**. Los ficheros se leen con las clases procesadoras. ## Componentes principales - **`FamiliaProfesional`, `TipoFormacion` y `CicloFormativo`**: clases del modelo con sus atributos, constructores, getters, setters y `toString()`. `CicloFormativo` guarda un objeto `FamiliaProfesional` y un objeto `TipoFormacion`, no sus códigos. - **`IFamiliaProfesionalDAO`, `ITipoFormacionDAO` e `ICicloFormativoDAO`**: interfaces con las operaciones de acceso a datos. Todos sus métodos declaran `throws FormacionException`. - **`FamiliaProfesionalDaoJDBC`, `TipoFormacionDaoJDBC` y `CicloFormativoDaoJDBC`**: implementaciones JDBC. Reciben la `Connection` por constructor y la guardan en un atributo `private final`. Cada método crea un `PreparedStatement` con `try-with-resources`. Las `SQLException` se capturan y se relanzan envueltas en `FormacionException`, conservando la causa original. - **`FamiliaProfesionalService` y `CicloFormativoService`**: abren la conexión con `try-with-resources` (se cierra sola), crean los DAO pasándosela y aplican la lógica de cada caso de uso. Los fallos al obtener o cerrar la conexión se convierten en `FormacionException`. - **`ProcesadorFicheroJSON` y `ProcesadorFicheroXML`**: leen el fichero con `ObjectMapper` y `XmlMapper` respectivamente, recorren los nodos `JsonNode` y construyen los objetos del modelo. Obtienen la ruta de `GestorConfiguracion`. - **`FormacionException`**: excepción checked con dos constructores (`mensaje` y `mensaje, causa`). Es la excepción de aplicación que conocen las capas superiores. - **`GestorConfiguracion`**: clase de utilidad (constructor privado) que carga `application.properties` desde el classpath en un bloque `static` y ofrece un getter por propiedad. Las rutas de los ficheros se devuelven como `Path`. - **`GestorConexionBBDD`**: clase de utilidad que monta la URL (`sgbd.conexion.url` + `bbdd.nombre`) y devuelve una `Connection` nueva. Quien la recibe es responsable de cerrarla. - **`AppPrincipal`**: crea los dos procesadores y los ejecuta en orden. Captura `FormacionException` en un único punto. ## Configuración Fichero `application.properties`: ```properties # Información relativa a la base de datos sgbd.conexion.url=jdbc:mysql://192.168.1.62:3306/ bbdd.nombre=Formacion_FP bbdd.usuario=myuser bbdd.clave=mypass # Información relativa a familias profesionales familiaprofesional.ruta.fichero=ficheros/familias_pro.json # Información relativa a ciclos formativos cicloformativo.ruta.fichero=ficheros/catalogo_formacion.xml ``` - La URL de conexión se forma concatenando `sgbd.conexion.url` y `bbdd.nombre`, es decir, `jdbc:mysql://192.168.1.62:3306/Formacion_FP`. Para ejecutar el proyecto en otro equipo hay que cambiar la IP (o usar `localhost`) y las credenciales. - Las rutas de los ficheros son relativas al directorio de ejecución, por lo que el programa debe lanzarse desde la raíz del proyecto. ## Ficheros de entrada ### JSON de familias profesionales Fichero cuya raíz es un array de objetos: ```json [ { "id_registro": 1, "fecha_carga": "2026-01-15", "cod_tipo_fam": "ADG", "nombre_tf": "Administración y Gestión" } ] ``` Solo interesan los campos `cod_tipo_fam` y `nombre_tf`. Los demás se ignoran. Los valores se leen con `path(...).asText().trim()`. | JSON | Columna | |---|---| | `cod_tipo_fam` | `codigo` | | `nombre_tf` | `nombre` | ### XML de ciclos formativos Los elementos `ciclo` cuelgan de `catalogo_formacion/informacion_adicional/ciclos_formativos`. Jackson descarta el elemento raíz, por lo que se navega con `path("informacion_adicional").path("ciclos_formativos").path("ciclo")`. El atributo `cod_cf` aparece como un campo más del nodo. Los elementos `fecha_actualizacion` y `observaciones` se ignoran. Correspondencia con la tabla `T_CICLO_FORMATIVO`: | XML | Columna | |---|---| | atributo `cod_cf` | `codigo` | | `nomb_corto` | `nombre_corto` | | `nombrelargo` | `nombre_largo` | | `num_horas_duracion` | `horas_duracion` | | `codigo_familia` | `codigo_familia` | | `codigo_tipoestudio` | `codigo_tipo_formacion` | ## Métodos de los DAO | DAO | Método | Sentencia SQL | Devuelve | |---|---|---|---| | `IFamiliaProfesionalDAO` | `existe(String codigo)` | `SELECT 1 ... WHERE codigo = ?` | `true` si existe | | `IFamiliaProfesionalDAO` | `insertar(familia)` | `INSERT` con todos los campos | nada | | `IFamiliaProfesionalDAO` | `actualizar(familia)` | `UPDATE` del nombre por código | nada | | `ITipoFormacionDAO` | `existe(String codigo)` | `SELECT 1 ... WHERE codigo = ?` | `true` si existe | | `ICicloFormativoDAO` | `insertar(ciclo)` | `INSERT` con todos los campos | nada | ## Métodos de los servicios | Servicio | Método | Acción | |---|---|---| | `FamiliaProfesionalService` | `existeFamiliaProfesional(codigo)` | Comprueba si la familia existe en la BBDD | | `FamiliaProfesionalService` | `insertarFamiliaProfesional(familia)` | Inserta la familia | | `FamiliaProfesionalService` | `actualizarFamiliaProfesional(familia)` | Actualiza el nombre de la familia | | `CicloFormativoService` | `insertarCicloFormativo(ciclo)` | Inserta el ciclo solo si existen su familia profesional y su tipo de formación; si no, lanza `FormacionException` | ### Reglas del tratamiento **Familias (`ProcesadorFicheroJSON`)** 1. Lee el JSON y recorre el array de nodos. 2. Por cada familia, el servicio comprueba si existe en la BBDD. 3. Si existe, actualiza su nombre; si no, la inserta. 4. Cualquier error (fichero no encontrado, JSON mal formado, fallo SQL) se propaga hasta `AppPrincipal`. **Ciclos (`ProcesadorFicheroXML`)** 1. Lee el XML y recorre los nodos `ciclo`. 2. Por cada ciclo crea un `CicloFormativo` con objetos `FamiliaProfesional` y `TipoFormacion` que solo tienen el código. 3. `CicloFormativoService` comprueba que existen la familia y el tipo en la BBDD. 4. Si alguno no existe, lanza `FormacionException` con un mensaje descriptivo. El procesador lo captura **ciclo a ciclo**, informa del error y continúa con el siguiente, de modo que un ciclo erróneo no detiene el tratamiento de los demás. 5. Si existen ambos, inserta el ciclo. ## Métodos de `AppPrincipal` | Método | Acción | |---|---| | `main(String[] args)` | Crea y ejecuta `ProcesadorFicheroJSON` (familias) y después `ProcesadorFicheroXML` (ciclos). Captura `FormacionException` en un único punto | **El orden es obligatorio**: las familias `IFC`, `TMV` y `SAN` solo existen en la BBDD después de procesar el JSON. Si se procesaran antes los ciclos, saldrían menos de 10. ## Resultado del procesamiento ### Familias profesionales | Código | Acción | Motivo | |---|---|---| | `ADG` | Actualizada | Ya existía en la BBDD: su nombre pasa a `Administración y Gestión` | | `IFC` | Insertada | No existía | | `TMV` | Insertada | No existía | | `SAN` | Insertada | No existía | ### Ciclos formativos El XML contiene 14 ciclos, de los que se insertan 10: | Ciclo | Familia | Tipo | ¿Se inserta? | |---|---|---|---| | `ADGB01` | `ADG` | `CFBA` | No: el tipo de formación no existe | | `ADGM01` | `ADG` | `CFGM` | Sí | | `ADGS01` | `ADG` | `CFGS` | Sí | | `IFCB01` | `IFE` | `CFGB` | No: la familia profesional no existe | | `IFCM01` | `IFC` | `CFGM` | Sí | | `IFCS02` | `IFC` | `CFGS` | Sí | | `IFCS03` | `IFC` | `CFGS` | Sí | | `IFCES03` | `IFC` | `CFE` | No: el tipo de formación no existe | | `TMVB01` | `TMV` | `CFGB` | Sí | | `TMVM01` | `TMV` | `CFGM` | Sí | | `TMVS01` | `TMV` | `CFGS` | Sí | | `TMVES02` | `TMV` | `CE` | Sí | | `SANM01` | `SAN` | `CFME` | No: el tipo de formación no existe | | `SANS01` | `SAN` | `CFGS` | Sí | ## Salida por consola Salida obtenida al ejecutar `AppPrincipal` con la base de datos recién creada: ``` Familia profesional actualizada: ADG Familia profesional insertada: IFC Familia profesional insertada: TMV Familia profesional insertada: SAN ERROR en el ciclo ADGB01: No existe el tipo de formación CFBA del ciclo ADGB01 Ciclo formativo insertado: ADGM01 Ciclo formativo insertado: ADGS01 ERROR en el ciclo IFCB01: No existe la familia profesional IFE del ciclo IFCB01 Ciclo formativo insertado: IFCM01 Ciclo formativo insertado: IFCS02 Ciclo formativo insertado: IFCS03 ERROR en el ciclo IFCES03: No existe el tipo de formación CFE del ciclo IFCES03 Ciclo formativo insertado: TMVB01 Ciclo formativo insertado: TMVM01 Ciclo formativo insertado: TMVS01 Ciclo formativo insertado: TMVES02 ERROR en el ciclo SANM01: No existe el tipo de formación CFME del ciclo SANM01 Ciclo formativo insertado: SANS01 Ciclos formativos insertados: 10 de 14 ``` ## Aspectos a tener en cuenta - Se asume que **no hay ciclos formativos** en la base de datos. Si se ejecuta `AppPrincipal` dos veces seguidas, los ciclos ya insertados darán error de clave duplicada. Para repetir la prueba hay que volver a ejecutar `Formacion_FP.sql`. - Las familias sí se pueden procesar varias veces: si ya existen, solo se actualiza el nombre. - Los DAO no abren ni cierran la conexión; lo hacen los servicios. `AppPrincipal` no conoce JDBC ni los ficheros. - Cada método de servicio abre y cierra su propia conexión; no hay transacción compartida entre operaciones. - Hay una única excepción de aplicación, `FormacionException`, que se propaga desde los DAO, los servicios y los procesadores hasta `AppPrincipal`. - La carpeta `config` está configurada como source folder en Eclipse, por lo que el properties está en el classpath. ## Ejecución 1. Ejecutar `Formacion_FP.sql` en un cliente MySQL (por ejemplo DBeaver) para crear la base de datos. 2. Crear el usuario con permisos sobre la base de datos: ```sql CREATE USER 'myuser'@'%' IDENTIFIED BY 'mypass'; GRANT ALL PRIVILEGES ON Formacion_FP.* TO 'myuser'@'%'; FLUSH PRIVILEGES; ``` 3. Ajustar `config/application.properties` a la IP y credenciales del servidor MySQL. 4. Comprobar que `ficheros/` contiene `familias_pro.json` y `catalogo_formacion.xml`. 5. Actualizar las dependencias Maven (*Maven → Update Project* en Eclipse). 6. Ejecutar `AppPrincipal` como aplicación Java, desde la raíz del proyecto. 7. Comprobar en la consola la salida (`Ciclos formativos insertados: 10 de 14`). 8. Comprobar en la base de datos: ```sql SELECT * FROM T_FAMILIA_PROFESIONAL; -- ADG (nombre actualizado), IFC, SAN y TMV SELECT COUNT(*) FROM T_CICLO_FORMATIVO; -- 10 ```