Files
2026-11-06 17:43:54 +01:00

314 lines
17 KiB
Markdown

# RedMetroDTA: Red de Metro con JDBC, patrón DAO, capa de servicios y ficheros CSV/XML (MySQL)
## Descripción
Proyecto en Java que gestiona información de la red de Metro de Madrid sobre la base de datos `red_metro_dta`, administrada por MySQL. Se utiliza el API JDBC, el patrón DAO (solo para el acceso a la base de datos) y una capa de servicios (Service Layer). Todas las sentencias SQL se ejecutan con `PreparedStatement`.
La aplicación pide por teclado la operación a realizar y ofrece cuatro casos de uso:
| Operación | Caso de uso |
|---|---|
| `A` | Consultar el color de una línea (el identificador se pide por teclado) |
| `B` | Tratar el fichero CSV de cocheras (insertar, modificar o borrar según el código de operación) |
| `C` | Cargar en la base de datos los trenes del fichero XML |
| `D` | Obtener todos los trenes de la base de datos y generar un fichero XML |
Características del proyecto:
- **Procesamiento de ficheros**: lectura de un CSV (cocheras) y de un XML con DOM (trenes), y generación de un XML con DOM y `Transformer`.
- **Fichero de configuración**: conexión a la base de datos, rutas de los ficheros y separador del CSV. No hay literales de configuración en el código.
- **Modelo orientado a objetos**: cuando hay clave foránea, la clase guarda una referencia al objeto, no su código (`Tren` guarda una `Cochera` y una `Linea`; `Linea` guarda un `Color`).
- **Excepción de aplicación** `RedMetroException` (checked), única excepción que sale de las capas de acceso a datos, ficheros y servicios.
Los datos de conexión y las rutas no están escritos en el código: se leen del fichero `app.properties` a través de la clase `GestorConfiguracion`.
## Estructura del proyecto
- `RedMetroDTA/`
- `src/es/madrid/redmetro/dta/`
- `AppPrincipal.java`: clase principal; pide la operación por teclado y la ejecuta
- `model/`
- `Color.java`, `Cochera.java`, `Linea.java`, `Tren.java`: clases del modelo usadas por los casos de uso
- `Estacion.java`, `Acceso.java`, `LineaEstacion.java`: clases del modelo de las restantes tablas (no intervienen en ningún caso de uso)
- `dao/`
- `ILineaDAO.java`, `ICocheraDAO.java`, `ITrenDAO.java`: interfaces de los DAO
- `LineaDaoJDBC.java`, `CocheraDaoJDBC.java`, `TrenDaoJDBC.java`: implementaciones JDBC con `PreparedStatement`
- `service/`
- `LineaService.java`: caso de uso A
- `CocheraService.java`: operaciones de cocheras (caso de uso B)
- `TrenService.java`: operaciones de trenes (casos de uso C y D)
- `util/`
- `ProcesadorFicheroCSV.java`: trata el CSV de cocheras
- `ProcesadorFicheroXML.java`: lee el XML de trenes y genera el XML de salida
- `excepciones/`
- `RedMetroException.java`: excepción de aplicación (checked)
- `gestores/`
- `GestorConfiguracion.java`: carga `app.properties` y expone sus valores
- `GestorConexionBBDD.java`: crea las conexiones a la base de datos
- `config/`
- `app.properties`: configuración (conexión a la BBDD, rutas de ficheros y separador)
- `ficheros/`
- `operaciones-cocherasRM.csv`: operaciones sobre cocheras
- `trenes_estaciones_accesos.xml`: trenes, estaciones y accesos (solo se usan los trenes)
- `red_metro_dta.xml`: fichero generado por la operación D
- `aadd-redmetro.sql`: script de creación de la base de datos
- `pom.xml`
- `README.md`
## Base de datos
El script SQL crea la base de datos con siete tablas:
| Tabla | Columnas |
|---|---|
| `T_COLOR` | `cod_color` (PK), `nombre`, `cod_hexadecimal` |
| `T_COCHERA` | `cod_cochera` (PK), `nombre`, `direccion`, `deposito` (1 o 0) |
| `T_ESTACION` | `cod_estacion` (PK), `nombre`, `direccion` |
| `T_ACCESO` | `cod_acceso` (PK), `nombre`, `acceso_discapacidad` (1 o 0), `cod_estacion` (FK a `T_ESTACION`) |
| `T_LINEA` | `cod_linea` (PK), `nombre_corto`, `nombre_largo`, `cod_color` (FK a `T_COLOR`), `kilometros` |
| `T_TREN` | `cod_tren` (PK), `modelo`, `empresa_constructora`, `fecha_incorporacion`, `cod_cochera` (FK a `T_COCHERA`), `cod_linea` (FK a `T_LINEA`) |
| `T_LINEA_ESTACION` | `cod_linea` y `cod_estacion` (PK compuesta, FK a `T_LINEA` y `T_ESTACION`), `orden` |
Tras ejecutar el script, la base de datos contiene los 13 colores, 7 líneas y 23 cocheras. No contiene trenes, estaciones ni accesos.
## Origen y destino de los datos
| Información | Origen | Destino |
|---|---|---|
| Color de una línea | Base de datos (`T_LINEA` y `T_COLOR`) | Consola |
| Cocheras | Fichero CSV | `T_COCHERA` |
| Trenes | Fichero XML | `T_TREN` |
| Trenes con su línea y color | Base de datos | Fichero XML generado |
## Arquitectura en capas
```
AppPrincipal → Service → DAO → Base de datos
│
└→ Procesadores de ficheros (util) → Service → DAO
│
└→ Ficheros (CSV y XML)
```
| Capa | Responsabilidad |
|---|---|
| `AppPrincipal` | Pide la operación por teclado, decide qué se ejecuta y captura `RedMetroException` en un único punto |
| Procesadores (`util`) | Leen y escriben los ficheros CSV y XML. Convierten su contenido en objetos del modelo y llaman a los servicios |
| Servicio | Abre y cierra la conexión y crea el DAO pasándosela. Representa los casos de uso sobre la base de datos |
| 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, con referencias a otros objetos cuando hay clave foránea |
El patrón DAO se usa **únicamente para el acceso a la base de datos**. Los ficheros se tratan en los procesadores, que no usan DAO.
## Componentes principales
- **`Color`, `Cochera`, `Linea`, `Tren`**: clases del modelo con constructor vacío, constructor completo, getters, setters y `toString`. `Linea` guarda un objeto `Color` y `Tren` guarda un objeto `Cochera` y un objeto `Linea`. `Tren.fechaIncorporacion` es un `LocalDate`.
- **`ILineaDAO`, `ICocheraDAO` e `ITrenDAO`**: interfaces con las operaciones de acceso a datos. Todos sus métodos declaran `throws RedMetroException`.
- **`LineaDaoJDBC`, `CocheraDaoJDBC` y `TrenDaoJDBC`**: implementaciones JDBC. Reciben la `Connection` por constructor y la guardan en un atributo `private final`. Las sentencias SQL son constantes de la clase y cada método crea un `PreparedStatement` con `try-with-resources`. Las `SQLException` se capturan y se relanzan envueltas en `RedMetroException`, conservando la causa original.
- **`LineaService`, `CocheraService` y `TrenService`**: cada método abre la conexión con `try-with-resources` (se cierra sola), crea el DAO pasándosela y delega en él. Los fallos al abrir o cerrar la conexión también se convierten en `RedMetroException`.
- **`ProcesadorFicheroCSV`**: lee el CSV con `Files.readAllLines` y, por cada línea, construye una `Cochera` y ejecuta la operación indicada mediante un `switch` con sintaxis de flecha.
- **`ProcesadorFicheroXML`**: carga el árbol DOM del XML de trenes e inserta cada tren a través de `TrenService` (operación C). También genera el XML de salida a partir de los trenes de la base de datos (operación D).
- **`RedMetroException`**: excepción checked con dos constructores (`mensaje` y `mensaje, causa`). Es la única que conocen las capas superiores.
- **`GestorConfiguracion`**: clase de utilidad (constructor privado) que carga `app.properties` en un bloque `static` y ofrece un getter por propiedad. Si el fichero no existe o no se puede leer, lanza una `RuntimeException`. Las rutas 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`**: pide por teclado la operación a realizar (A, B, C o D, sin distinguir mayúsculas) y delega su ejecución: la A en `LineaService` y las demás en los procesadores de ficheros. No conoce JDBC ni los ficheros. Captura `RedMetroException` en un único punto.
## Configuración
Fichero `app.properties`:
```properties
# Información relativa a la base de datos
sgbd.conexion.url=jdbc:mysql://192.168.1.62:3306/
bbdd.nombre=red_metro_dta
bbdd.usuario=myuser
bbdd.clave=mypass
# Información relativa a cocheras
cochera.ruta.fichero=ficheros/operaciones-cocherasRM.csv
cochera.csv.separador=;
# Información relativa a trenes
tren.ruta.fichero=ficheros/trenes_estaciones_accesos.xml
tren.ruta.fichero.salida=ficheros/red_metro_dta.xml
```
- La URL de conexión se forma concatenando `sgbd.conexion.url` y `bbdd.nombre`, es decir, `jdbc:mysql://192.168.1.62:3306/red_metro_dta`. Para ejecutar el proyecto en otro equipo hay que cambiar la IP (o usar `localhost`) y las credenciales.
- Las rutas son relativas al directorio de ejecución, por lo que el programa debe lanzarse desde la raíz del proyecto.
- La carpeta `config` debe estar en el classpath para que `getResourceAsStream` encuentre `app.properties`. Se declara como *source folder* en Eclipse.
## Ficheros de entrada
### CSV de cocheras
Fichero con cabecera y separador `;`:
```
OPERACION;COD_COCHERA;DEPOSITO;DENOMINACION;LOCALIZACION
```
Los códigos de operación son:
| Operación | Qué hace |
|---|---|
| `0` | No hacer nada |
| `1` | Insertar la cochera siempre que no exista en la base de datos |
| `2` | Modificar la cochera |
| `3` | Borrar la cochera |
Los campos se limpian con `trim()`, las líneas en blanco se ignoran (`isBlank()`) y cualquier otro código de operación se ignora. Un valor numérico incorrecto o una línea con menos campos de los esperados produce una `RedMetroException`.
### XML de trenes
Los elementos `tren` cuelgan de `trenes`. Correspondencia con la tabla `T_TREN`:
| XML | Columna |
|---|---|
| atributo `id` | `cod_tren` |
| `modelo` | `modelo` |
| `anyo_incorporacion` | `fecha_incorporacion` (1 de enero de ese año) |
| `empresa_constructora` | `empresa_constructora` |
| `cod_cochera` | `cod_cochera` |
| `id_linea` | `cod_linea` |
Las secciones `estaciones` y `accesos` del fichero no se procesan.
## Fichero XML generado
La operación D genera `ficheros/red_metro_dta.xml` con esta estructura:
```xml
<?xml version="1.0" encoding="UTF-8"?>
<info-trenes-linea-color>
<trenes>
<tren id="1">
<modelo>Serie 2000-A</modelo>
<anyo_incorporacion>2000</anyo_incorporacion>
<empresa_constructora>CAF</empresa_constructora>
<cod_cochera>15</cod_cochera>
<linea id_linea="5">
<nombre_l>Arguelles - Pinar de Chamartín</nombre_l>
<color cod_hex="#741013" id="4">
<descripcion>Marrón</descripcion>
</color>
</linea>
</tren>
</trenes>
</info-trenes-linea-color>
```
| XML | Origen |
|---|---|
| `tren/@id` | `T_TREN.cod_tren` |
| `anyo_incorporacion` | Año de `T_TREN.fecha_incorporacion` |
| `linea/@id_linea` | `T_LINEA.cod_linea` |
| `nombre_l` | `T_LINEA.nombre_largo` |
| `color/@id` y `color/@cod_hex` | `T_COLOR.cod_color` y `T_COLOR.cod_hexadecimal` |
| `descripcion` | `T_COLOR.nombre` |
El serializador DOM ordena los atributos alfabéticamente, por lo que `cod_hex` aparece antes que `id`.
## Métodos de los DAO
| DAO | Método | Sentencia SQL | Devuelve |
|---|---|---|---|
| `ILineaDAO` | `obtenerPorCodigo(int codLinea)` | `SELECT` con `JOIN` a `T_COLOR` | La línea con su color, o `null` si no existe |
| `ICocheraDAO` | `existe(int codCochera)` | `SELECT COUNT(*)` | `true` si existe |
| `ICocheraDAO` | `insertar(Cochera)` | `INSERT` con todos los campos | nada |
| `ICocheraDAO` | `modificar(Cochera)` | `UPDATE` de los campos no clave por código | nada |
| `ICocheraDAO` | `borrar(int codCochera)` | `DELETE ... WHERE cod_cochera = ?` | nada |
| `ITrenDAO` | `insertar(Tren)` | `INSERT` con todos los campos | nada |
| `ITrenDAO` | `obtenerTodos()` | `SELECT` con `JOIN` a `T_COCHERA`, `T_LINEA` y `T_COLOR` | `List<Tren>` con cochera, línea y color cargados |
Solo se incluyen las operaciones necesarias para los cuatro casos de uso.
## Casos de uso
### A: color de una línea
1. `AppPrincipal` pide el identificador de la línea y comprueba que sea un número.
2. `LineaService.obtenerLinea` obtiene la línea con su color a través de `ILineaDAO`.
3. Si no existe, se informa de ello. Si existe, se imprime el color junto a la línea.
Ejemplo con el identificador `13`:
```
El color de la Línea 13 (Metrour), que tiene una longitud de 10.75 Kilómetros, es Verde oliva (#7f7f01).
```
### B: tratamiento del CSV de cocheras
`ProcesadorFicheroCSV.realizarTratamientoCocheras()` recorre el fichero (sin la cabecera) y, según el código de operación, llama a `CocheraService`:
- **Insertar**: solo si `existeCochera` devuelve `false`.
- **Modificar** y **borrar**: se ejecutan directamente.
Con la base de datos recién creada, el tratamiento modifica la cochera `1` y borra la `13`. Las inserciones se omiten porque las cocheras ya existen.
### C: carga de trenes desde el XML
`ProcesadorFicheroXML.realizarTratamientoTrenes()` recorre los elementos `tren`, construye cada `Tren` con una `Cochera` y una `Linea` que solo llevan el código y lo inserta con `TrenService`. Con el fichero de ejemplo se insertan los cuatro trenes.
### D: generación del XML de trenes
`ProcesadorFicheroXML.generarFicheroTrenes()` obtiene todos los trenes con `TrenService`, construye el árbol DOM y lo escribe con `Transformer` en la ruta de salida configurada.
## Salida por consola
Ejemplo de la operación B con la base de datos recién creada:
```
Introduzca la operación a realizar:
B
Modificando la cochera: Cochera [codCochera=1, nombre=PUERTA DE ARGANDA, direccion=CARRETERA M-203 KM 2,300 (CAMINO DE VALLECAS A MEJORADA), deposito=1]
Borrando la cochera: Cochera [codCochera=13, nombre=PLAZA DE CASTILLA, direccion=SAN BENITO S/N, deposito=0]
```
Ejemplo de la operación C con la base de datos recién creada (una línea por cada tren del XML; se muestran el primero y el último):
```
Introduzca la operación a realizar:
C
Insertando el tren: Tren [codTren=1, modelo=Serie 2000-A, empresaConstructora=CAF, fechaIncorporacion=2000-01-01, cochera=Cochera [codCochera=15, nombre=null, direccion=null, deposito=0], linea=Linea [codLinea=5, nombreCorto=null, nombreLargo=null, kilometros=0.0, color=null]]
...
Insertando el tren: Tren [codTren=4, modelo=Serie 5000, empresaConstructora=CAF, fechaIncorporacion=2010-01-01, cochera=Cochera [codCochera=1, nombre=null, direccion=null, deposito=0], linea=Linea [codLinea=9, nombreCorto=null, nombreLargo=null, kilometros=0.0, color=null]]
```
La cochera y la línea solo muestran su código porque el XML no trae el resto de sus datos. En la base de datos se guardan únicamente esos códigos, que son las claves foráneas de `T_TREN`.
Ejemplo de la operación D:
```
Introduzca la operación a realizar:
D
Fichero generado: ficheros\red_metro_dta.xml
```
## Aspectos a tener en cuenta
- La operación C inserta los trenes sin comprobar si existen. Si se ejecuta dos veces seguidas, la segunda fallará con un error de clave duplicada. Para repetir la prueba hay que volver a ejecutar el script SQL.
- La operación D debe ejecutarse después de la C. Si no hay trenes en la base de datos, el XML generado queda vacío.
- Los DAO no abren ni cierran la conexión; lo hace el servicio. `AppPrincipal` no conoce JDBC.
- Se abre una conexión por operación de servicio, por lo que el tratamiento del CSV y del XML usa una conexión distinta por cada fila o tren. No hay transacción global.
- La fecha de incorporación del XML solo trae el año, por lo que se guarda como el 1 de enero de ese año. Al generar el XML solo se escribe el año.
- Hay una única excepción de aplicación, `RedMetroException`, que se propaga desde los DAO y los procesadores hasta `AppPrincipal`.
- La clase `GestorConfiguracion` lanza una `RuntimeException` desde su bloque `static`, porque un fichero de configuración ausente es un error de despliegue y no de acceso a datos.
## Ejecución
1. Ejecutar el script SQL en un cliente MySQL (DBeaver) sobre la base de datos `red_metro_dta`.
2. Crear el usuario con permisos sobre la base de datos:
```sql
CREATE USER 'myuser'@'%' IDENTIFIED BY 'mypass';
GRANT ALL PRIVILEGES ON red_metro_dta.* TO 'myuser'@'%';
FLUSH PRIVILEGES;
```
3. Ajustar `config/app.properties` a la IP y credenciales del servidor MySQL.
4. Comprobar que `ficheros/` contiene `operaciones-cocherasRM.csv` y `trenes_estaciones_accesos.xml`.
5. Ejecutar `AppPrincipal` como aplicación Java, desde la raíz del proyecto, y probar las operaciones en este orden: `A`, `B`, `C` y `D`.
6. Comprobar en la base de datos:
```sql
SELECT * FROM T_COCHERA ORDER BY cod_cochera; -- 22 filas: falta la cochera 13
SELECT * FROM T_TREN; -- 4 trenes tras la operación C
```
7. Para repetir las pruebas desde cero, volver a ejecutar el script SQL.