230 lines
12 KiB
Markdown
230 lines
12 KiB
Markdown
# aadd_conect03: Operaciones DML con JDBC, patrón DAO, capa de servicios y transacción (MySQL)
|
|
|
|
## Descripción
|
|
|
|
Proyecto en Java que realiza operaciones básicas de manipulación de datos (DML) sobre las tablas `T_CONTINENTE` y `T_PAIS` de la base de datos `Mapa_Mundi`, administrada por MySQL. Se utiliza el API JDBC, el patrón DAO y una capa de servicios. Todas las sentencias SQL se ejecutan con `PreparedStatement`.
|
|
|
|
Es la evolución de `aadd_conect02` con cuatro novedades:
|
|
|
|
- **`PreparedStatement`** en lugar de `Statement` (refactorización de la implementación JDBC de País y nueva implementación de Continente).
|
|
- **Capa de servicios** (`PaisService` y `ContinenteService`): `AppPrincipal` ya no abre conexiones, solo llama a los servicios.
|
|
- **Excepción de aplicación** `MapaMundiException` (checked), única excepción que sale de las capas de acceso a datos y servicios.
|
|
- **Transacción** en el borrado de un continente: se borran sus países y el propio continente, o no se borra nada.
|
|
|
|
Los datos de conexión no están escritos en el código: se leen del fichero `application.properties` a través de la clase `GestorConfiguracion`. Al usar una versión moderna de JDBC, ya no hace falta indicar la clase del driver.
|
|
|
|
## Estructura del proyecto
|
|
|
|
- `aadd_conect03/`
|
|
- `src/org/palomafp/aadd/dta/`
|
|
- `AppPrincipal.java`: clase principal que ejecuta los cinco pasos del enunciado a través del servicio
|
|
- `model/`
|
|
- `Pais.java`: clase del modelo (un país)
|
|
- `Continente.java`: clase del modelo (un continente)
|
|
- `dao/`
|
|
- `IPaisDAO.java`: interfaz del DAO de países
|
|
- `IContinenteDAO.java`: interfaz del DAO de continentes
|
|
- `impl/`
|
|
- `PaisDaoJDBC.java`: implementación JDBC con `PreparedStatement`
|
|
- `ContinenteDaoJDBC.java`: implementación JDBC con `PreparedStatement`
|
|
- `service/`
|
|
- `PaisService.java`: casos de uso de países
|
|
- `ContinenteService.java`: casos de uso de continentes (incluye la transacción)
|
|
- `excepciones/`
|
|
- `MapaMundiException.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 (datos de conexión a la BBDD)
|
|
- `MapaMundi.sql`: script de creación de la base de datos
|
|
- `pom.xml`
|
|
- `README.md`
|
|
|
|
## Base de datos
|
|
|
|
El script `MapaMundi.sql` crea la base de datos `Mapa_Mundi` con dos tablas:
|
|
|
|
| Tabla | Columnas |
|
|
|---|---|
|
|
| `T_CONTINENTE` | `codigo` (PK), `nombre_continente` |
|
|
| `T_PAIS` | `cod_continente` (FK a `T_CONTINENTE`), `identificador` (PK, autoincremental), `nombre_pais`, `capital` |
|
|
|
|
Contiene 5 continentes y 198 países (47 de ellos en Europa, código `04`).
|
|
|
|
Como `T_PAIS.cod_continente` es clave foránea de `T_CONTINENTE.codigo`, **no se puede borrar un continente que tenga países**. Por eso el borrado se hace en orden: primero los países (hijos) y después el continente (padre).
|
|
|
|
## Arquitectura en capas
|
|
|
|
```
|
|
AppPrincipal → Service → DAO → Base de datos
|
|
```
|
|
|
|
| Capa | Responsabilidad |
|
|
|---|---|
|
|
| `AppPrincipal` | Decide qué se ejecuta y qué se imprime. No conoce conexiones ni SQL |
|
|
| Servicio | Representa los casos de uso. Abre y cierra la conexión y controla la transacción |
|
|
| 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 |
|
|
|
|
## Componentes principales
|
|
|
|
- **`Pais` y `Continente`**: clases del modelo con sus atributos, getters, setters y `toString()`.
|
|
- **`IPaisDAO` e `IContinenteDAO`**: interfaces con las operaciones de acceso a datos. Todos sus métodos declaran `throws MapaMundiException`.
|
|
- **`PaisDaoJDBC` y `ContinenteDaoJDBC`**: 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 `MapaMundiException`, conservando la causa original.
|
|
- **`PaisService` y `ContinenteService`**: abren la conexión con `try-with-resources` (se cierra sola), crean el DAO pasándosela y delegan en él. Los fallos al abrir o cerrar la conexión también se convierten en `MapaMundiException`.
|
|
- **`MapaMundiException`**: 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 `application.properties` en un bloque `static` y ofrece un getter por propiedad.
|
|
- **`GestorConexionBBDD`**: clase de utilidad que monta la URL (`sgdb.conexion.url` + `bbdd.nombre`) y devuelve una `Connection` nueva. Quien la recibe es responsable de cerrarla.
|
|
- **`AppPrincipal`**: crea el `ContinenteService` y ejecuta los cinco pasos, cada uno en un método privado. Captura `MapaMundiException` en un único punto.
|
|
|
|
## Configuración
|
|
|
|
Fichero `application.properties`:
|
|
|
|
```properties
|
|
# Información relativa a la base de datos
|
|
sgdb.conexion.url=jdbc:mysql://192.168.1.62:3306/
|
|
bbdd.nombre=Mapa_Mundi
|
|
bbdd.usuario=myuser
|
|
bbdd.clave=mypass
|
|
```
|
|
|
|
La URL de conexión se forma concatenando `sgdb.conexion.url` y `bbdd.nombre`, es decir, `jdbc:mysql://192.168.1.62:3306/Mapa_Mundi`. Para ejecutar el proyecto en otro equipo hay que cambiar la IP (o usar `localhost`) y las credenciales.
|
|
|
|
## Métodos de `IPaisDAO` / `PaisDaoJDBC`
|
|
|
|
| Método | Sentencia SQL | Devuelve |
|
|
|---|---|---|
|
|
| `obtenerTodos()` | `SELECT` de todos los países | `List<Pais>` |
|
|
| `obtenerPorId(int identificador)` | `SELECT ... WHERE identificador = ?` | `Pais`, o `null` si no existe |
|
|
| `insertar(Pais pais)` | `INSERT` con los cuatro campos del país | nada |
|
|
| `actualizar(Pais pais)` | `UPDATE` de continente, nombre y capital por identificador | nada |
|
|
| `borrar(int identificador)` | `DELETE ... WHERE identificador = ?` | nada |
|
|
|
|
## Métodos de `IContinenteDAO` / `ContinenteDaoJDBC`
|
|
|
|
| Método | Sentencia SQL | Devuelve |
|
|
|---|---|---|
|
|
| `obtenerTodos()` | `SELECT` de todos los continentes | `List<Continente>` |
|
|
| `obtenerPorCodigo(String codigo)` | `SELECT ... WHERE codigo = ?` | `Continente`, o `null` si no existe |
|
|
| `insertar(Continente continente)` | `INSERT` con código y nombre | nada |
|
|
| `actualizar(Continente continente)` | `UPDATE` del nombre por código | nada |
|
|
| `borrar(String codigo)` | `DELETE ... WHERE codigo = ?` | nada |
|
|
|
|
## Métodos de los servicios
|
|
|
|
`PaisService` ofrece `obtenerTodos`, `obtenerPorId`, `insertar`, `actualizar` y `borrar`. `ContinenteService` ofrece:
|
|
|
|
| Método | Acción |
|
|
|---|---|
|
|
| `obtenerTodos()` | Devuelve todos los continentes |
|
|
| `obtenerPorCodigo(String codigo)` | Devuelve un continente, o `null` si no existe |
|
|
| `insertar(Continente continente)` | Inserta un continente |
|
|
| `actualizar(Continente continente)` | Actualiza el nombre de un continente |
|
|
| `borrarConPaises(String codigo)` | Borra los países del continente y después el continente, **dentro de una misma transacción** |
|
|
|
|
Las operaciones simples usan una conexión en modo *autocommit*: cada sentencia se confirma sola.
|
|
|
|
## Transacción en `borrarConPaises`
|
|
|
|
El enunciado exige que el borrado de los países y el del continente se ejecuten juntos: si una falla, se deshacen todas.
|
|
|
|
1. Se abre **una sola conexión** y se desactiva el *autocommit* (`setAutoCommit(false)`), lo que inicia la transacción.
|
|
2. Se crean `PaisDaoJDBC` y `ContinenteDaoJDBC` con **esa misma conexión**. Es imprescindible: una transacción vive dentro de una conexión, y por eso los DAO la reciben por constructor en lugar de abrirla ellos.
|
|
3. Se recorren los países y se borran uno a uno los del continente indicado.
|
|
4. Se borra el continente.
|
|
5. `commit()` confirma los dos borrados a la vez.
|
|
6. Si un DAO lanza `MapaMundiException`, se hace `rollback()` (los países vuelven) y se relanza la misma excepción hacia `main`.
|
|
7. Cualquier `SQLException` de abrir, confirmar o cerrar la conexión se convierte en `MapaMundiException`.
|
|
|
|
## Métodos de `AppPrincipal`
|
|
|
|
| Método | Acción |
|
|
|---|---|
|
|
| `main(String[] args)` | Crea el servicio y ejecuta los cinco pasos en orden. Si el continente 04 no existe, termina sin borrar nada. Captura `MapaMundiException` en un único punto |
|
|
| `obtenerContinentes(servicio)` | Paso 1. Consulta la lista de continentes y la imprime |
|
|
| `obtenerContinentePorCodigo(servicio)` | Paso 2. Consulta el continente 04, lo imprime y lo devuelve para los pasos 4 y 5 |
|
|
| `borrarContinente(servicio)` | Paso 3. Borra los países del continente y después el continente (transacción) y comprueba que ya no existe |
|
|
| `insertarContinente(servicio, continente)` | Paso 4. Inserta el continente obtenido en el paso 2 |
|
|
| `actualizarContinente(servicio, continente)` | Paso 5. Cambia el nombre a "Paneuropa" y actualiza el continente |
|
|
|
|
Los valores `"04"` y `"Paneuropa"` están definidos como constantes (`CODIGO_CONTINENTE` y `NUEVO_NOMBRE`).
|
|
|
|
## Pasos del programa
|
|
|
|
| Paso | Operación | Resultado esperado |
|
|
|---|---|---|
|
|
| 1 | Consultar e imprimir la lista de continentes | 5 continentes |
|
|
| 2 | Consultar e imprimir el continente 04 | `Continente [codigo=04, nombreContinente=Europa]` |
|
|
| 3 | Borrar los países del continente 04 y después el continente | `Consulta tras borrar: null` |
|
|
| 4 | Insertar el continente del paso 2 | La consulta devuelve Europa |
|
|
| 5 | Actualizar el nombre | La consulta devuelve `Paneuropa` |
|
|
|
|
## Salida por consola
|
|
|
|
Salida obtenida al ejecutar `AppPrincipal` con la base de datos recién restaurada:
|
|
|
|
```
|
|
=== 1. Lista de continentes ===
|
|
Continente [codigo=01, nombreContinente=África]
|
|
Continente [codigo=02, nombreContinente=América]
|
|
Continente [codigo=03, nombreContinente=Asia]
|
|
Continente [codigo=04, nombreContinente=Europa]
|
|
Continente [codigo=05, nombreContinente=Oceanía]
|
|
|
|
=== 2. Continente con código 04 ===
|
|
Continente [codigo=04, nombreContinente=Europa]
|
|
|
|
=== 3. Borrado ===
|
|
Consulta tras borrar: null
|
|
|
|
=== 4. Inserción ===
|
|
Consulta tras insertar: Continente [codigo=04, nombreContinente=Europa]
|
|
|
|
=== 5. Actualización ===
|
|
Consulta tras actualizar: Continente [codigo=04, nombreContinente=Paneuropa]
|
|
```
|
|
|
|
## Aspectos a tener en cuenta
|
|
|
|
- El continente insertado en el paso 4 es el mismo objeto `Continente` consultado en el paso 2, guardado en memoria antes de borrarlo. Por eso el paso 2 debe ir antes del 3.
|
|
- El paso 4 solo reinserta el continente, no sus países: tras la ejecución, `Paneuropa` queda **sin países** (`0` filas en `T_PAIS` con `cod_continente = '04'`).
|
|
- El borrado de países se hace listando todos y filtrando por continente en el servicio, de forma que los DAO se mantienen en los cinco métodos básicos y el servicio decide el orden y la transacción.
|
|
- `PreparedStatement` evita la inyección SQL y resuelve el problema de los textos con apóstrofo (por ejemplo `Nuku'alofa`), que con `Statement` rompían el `INSERT` o el `UPDATE`.
|
|
- Los DAO no abren ni cierran la conexión; lo hace el servicio. `AppPrincipal` no conoce JDBC.
|
|
- `PaisService` está completo, pero `AppPrincipal` solo usa `ContinenteService`, porque el enunciado solo pide operaciones sobre continentes.
|
|
- La carpeta `config` está configurada como *source folder* en Eclipse, por lo que `application.properties` está en el classpath.
|
|
- Tras la ejecución, Europa queda con el nombre `Paneuropa` y sin países. Para volver al estado original hay que ejecutar de nuevo `MapaMundi.sql`.
|
|
|
|
## Prueba del rollback
|
|
|
|
Para comprobar que la transacción deshace los cambios:
|
|
|
|
1. Restaurar los datos ejecutando `MapaMundi.sql`.
|
|
2. Añadir temporalmente en `ContinenteService.borrarConPaises`, justo antes de `continenteDao.borrar(codigo);`:
|
|
```java
|
|
if (true) {
|
|
throw new MapaMundiException("fallo de prueba");
|
|
}
|
|
```
|
|
3. Ejecutar `AppPrincipal`. Aparece `Error: fallo de prueba` y el programa termina.
|
|
4. Comprobar en la base de datos que los países siguen ahí:
|
|
```sql
|
|
SELECT COUNT(*) FROM T_PAIS WHERE cod_continente = '04';
|
|
```
|
|
Debe devolver `47`.
|
|
5. Eliminar el `throw` de prueba y restaurar los datos.
|
|
|
|
## Ejecución
|
|
|
|
1. Ejecutar `MapaMundi.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 Mapa_Mundi.* TO 'myuser'@'%';
|
|
FLUSH PRIVILEGES;
|
|
```
|
|
3. Ajustar `config/application.properties` a la IP y credenciales del servidor MySQL.
|
|
4. Ejecutar `AppPrincipal` como aplicación Java.
|
|
5. Comprobar en la consola la salida de los cinco pasos. |