10. Acceso a bases de datos con JDBC
Requisitos previos: la versión 6 de la aplicación [Tax], descrita al final de este capítulo, reutiliza los módulos [tax-dao], [tax-business] y [tax-ui] de la versión 5 (capítulo 6). Antes de compilar o abrir sus proyectos, debe haber instalado la versión 5 en el repositorio Maven local mediante el comando [mvn install] ejecutado en la carpeta [06-architectures/TaxV5] (consulte el capítulo 6, sección sobre [mvn install]).
10.1. El controlador JDBC
Retomemos la arquitectura en capas utilizada en varias ocasiones desde el capítulo 6. Hasta ahora, la capa [dao] de la aplicación [Tax] ha utilizado tres tipos de fuentes de datos:
- datos codificados directamente en el código ([HardwiredTax]);
- datos de un archivo de texto ([FileTax]);
- datos de un archivo JSON ([JsonTax]).
En este capítulo examinamos el caso en que los datos provienen de una base de datos. La arquitectura queda así:

En el diagrama anterior, la capa [dao] [1] se comunica con el SGBD (sistema de gestión de bases de datos) [3], que administra la base de datos [4], a través de una biblioteca de clases [2] específica del SGBD utilizado. Esta biblioteca implementa una API estándar de la plataforma Java, JDBC («Java DataBase Connectivity»), que forma parte del JDK desde la versión 1.1, en 1997. Se denomina controlador JDBC («JDBC driver»). Todos los SGBD habituales disponen de un controlador JDBC, distribuido como un archivo [.jar].
JDBC es, ante todo, un conjunto de interfaces, definidas en los paquetes [java.sql] y [javax.sql] del módulo [java.sql] del JDK: [Connection], [Statement], [PreparedStatement], [ResultSet], [DataSource]… Un controlador JDBC proporciona clases que implementan estas interfaces. El código de la aplicación, en cambio, solo interactúa con las interfaces: en general no contiene los nombres de las clases del controlador. Esto difiere de otras plataformas, donde el código suele usar directamente las clases propias de cada SGBD ([MySqlConnection], [SqlConnection]…): en Java, la abstracción ha sido la norma desde el principio, y cambiar a otro SGBD consiste esencialmente en cambiar el controlador y la dirección de la base de datos, como veremos. Sin embargo, cada SGBD tiene su propio dialecto de SQL: esta independencia tiene sus límites, que también examinaremos.
Utilizamos un único SGBD, MySQL 8, que el apéndice «El SGBD MySQL con Laragon» instala en Windows, junto con su controlador JDBC oficial, MySQL Connector/J, versión 9.7.0. Las bases de datos se crean mediante scripts SQL ejecutados con el cliente de línea de comandos [mysql]; el apéndice también muestra cómo crearlas con el cliente gráfico HeidiSQL incluido en Laragon.
10.2. Las dos formas de utilizar una fuente de datos
Se puede acceder a una base de datos de dos maneras distintas:
- modo conectado;
- modo desconectado.
En el modo conectado, la aplicación:
- abre una conexión con la fuente de datos;
- trabaja con la fuente de datos en modo de lectura/escritura;
- cierra la conexión.
En el modo desconectado, la aplicación:
- abre una conexión con la fuente de datos;
- recupera en memoria una copia de la totalidad o de parte de los datos de la fuente;
- cierra la conexión;
- trabaja con la copia de los datos en memoria, leyéndola y modificándola;
- cuando termina el trabajo, abre una conexión, envía los datos modificados a la fuente de datos para que se actualice y cierra la conexión.
El modo conectado es el de la interfaz [ResultSet] de JDBC: las filas del resultado de una consulta se leen mientras la conexión está abierta. El modo desconectado es el de la interfaz [CachedRowSet] del paquete [javax.sql.rowset] (Java 5): una tabla en memoria que se llena a partir de una consulta, se modifica sin conexión y luego envía sus cambios a la base de datos. Estos componentes «RowSet» siguen presentes en JDK 25, pero rara vez se utilizan en aplicaciones nuevas: trabajar sobre una copia de los datos en memoria, con guardado posterior de los cambios, corresponde hoy a un ORM («Object-Relational Mapper»), que manipula objetos Java ordinarios en lugar de filas de tablas. El ORM más utilizado en Java, Hibernate, es el tema del capítulo 11. Por ello nos centraremos principalmente en el modo conectado —en el que se basa Hibernate— y mostraremos el modo desconectado solo mediante un ejemplo al final del capítulo.
10.3. Los conceptos básicos de las operaciones con bases de datos
10.3.1. La base de datos de ejemplo
Explicaremos los principales conceptos del uso de una base de datos con una base de datos MySQL. Contiene una única tabla, [articles], en la que cada fila describe un artículo de una tienda:
- [ID]: un identificador único del artículo, que es la clave primaria de la tabla;
- [NAME]: el nombre del artículo, que también es único;
- [PRICE]: su precio;
- [CURRENTSTOCK]: su existencia actual;
- [MINIMUMSTOCK]: el nivel mínimo de existencias por debajo del cual debe reponerse el artículo.
La base de datos se crea mediante el siguiente script SQL: [sql/dbarticles.sql]:
- Línea 5: el script es un archivo de texto codificado en UTF-8. [SET NAMES utf8mb4] se lo indica al servidor; de lo contrario, los caracteres acentuados de las líneas 31–36 podrían ser interpretados incorrectamente por el cliente [mysql];
- Líneas 8–9: la base de datos se elimina si existe y luego se vuelve a crear. Así, el script puede ejecutarse varias veces para restablecer la base de datos a su estado inicial. [utf8mb4] es la codificación Unicode completa de MySQL (la codificación heredada [utf8] de MySQL solo codifica caracteres de hasta tres bytes);
- línea 12: [dbarticles] pasa a ser la base de datos actual: los comandos SQL siguientes se ejecutarán sobre ella;
- líneas 15–27: la definición de la tabla [articles]:
- línea 16: la columna [ID] es la clave primaria de la tabla ([PRIMARY KEY]). El atributo [AUTO_INCREMENT], específico de MySQL, indica que el propio SGBD genera su valor al insertar una fila: 1, 2, 3… Los demás SGBD tienen conceptos equivalentes, pero con una sintaxis distinta ([IDENTITY] para SQL Server, [GENERATED … AS IDENTITY] para PostgreSQL y Oracle);
- Línea 18: el precio es un número decimal exacto de 10 dígitos con 2 decimales. Conviene evitar los tipos de punto flotante para los importes, como [DOUBLE] (véase la diferencia entre [double] y [BigDecimal] en el capítulo 3). El tipo SQL [DECIMAL] corresponde a la clase Java [BigDecimal];
- Líneas 22–26: restricciones de integridad. [UNQ_NAME] impide que dos artículos tengan el mismo nombre; las restricciones [CHECK] impiden un nombre vacío, un precio negativo o igual a cero y una existencia negativa. MySQL ignoraba silenciosamente las restricciones [CHECK] hasta la versión 8.0.16; desde entonces las aplica;
- Líneas 30–36: inserción de seis filas. La columna [ID] no se inicializa: el SGBD le asigna un valor.
El script se ejecuta con el cliente de línea de comandos [mysql], en la carpeta [sql] (el usuario [root] de MySQL no tiene contraseña en la instalación del apéndice; de lo contrario, agregue la opción [-p] y el cliente la solicitará):
El comando no muestra nada si todo va bien. Puede comprobar la estructura y el contenido de la tabla con el mismo cliente:
- Línea 1: la opción [-t] especifica una visualización en forma de tabla; la opción [-e] especifica los comandos SQL que se ejecutarán, y la opción [--default-character-set=utf8mb4] garantiza que los caracteres acentuados se muestren correctamente en un terminal UTF-8;
- líneas 3–9: la estructura de la tabla, obtenida mediante el comando de MySQL [describe];
- líneas 12–19: el contenido de la tabla. Los valores de la columna [ID] fueron generados por el SGBD.
Una nota sobre la distinción entre mayúsculas y minúsculas: los nombres de columna nunca distinguen mayúsculas de minúsculas ([name] y [NAME] designan la misma columna), pero los nombres de tabla son nombres de archivo del servidor. No distinguen mayúsculas de minúsculas en Windows, pero sí en Linux. Para que los ejemplos funcionen en todas partes, la tabla se llama [articles], en minúsculas, y las consultas la escriben así.
Los programas de este capítulo modifican la tabla [articles]. Los resultados mostrados aquí se obtuvieron volviendo a ejecutar el script [dbarticles.sql] antes de cada programa; los lectores que deseen reproducir exactamente los mismos resultados deben hacer lo mismo.
Ahora que disponemos de una base de datos, podremos utilizarla. Antes, repasemos algunos puntos sobre SQL.
10.3.2. Los cuatro comandos básicos del lenguaje SQL
SQL («Structured Query Language») es un lenguaje parcialmente estandarizado para consultar y actualizar bases de datos. Todos los dialectos de los SGBD respetan la parte estandarizada de SQL, pero agregan al lenguaje extensiones propias que aprovechan sus características específicas. Ya hemos visto dos ejemplos: la generación automática de claves primarias y los tipos de datos permitidos para las columnas de las tablas suelen depender del SGBD.
Los cuatro comandos básicos del lenguaje SQL que presentamos aquí están estandarizados y son aceptados por todos los SGBD:
Comando | Función |
[select col1, col2, … from table1, table2, … where condition order by expression] | La consulta que sirve para recuperar datos de una base de datos. Solo las palabras clave [select] y [from] son obligatorias. Se realiza una combinación (join) con todas las tablas que siguen a la palabra clave [from]; solo se conservan las columnas que siguen a la palabra clave [select] ; solo se conservan las filas que cumplen la condición de la palabra clave [where] ; las filas resultantes, ordenadas según la expresión de la palabra clave [order by], forman el resultado de la consulta. Este resultado es una tabla. |
[insert into table(col1, col2, …) values (val1, val2, …)] | Inserta una fila en [table]. [(col1, col2, …)] especifica las columnas de la fila que se inicializan con los valores [(val1, val2, …)]. |
[update table set col1=val1, col2=val2, … where condition] | Actualiza las filas de [table] según [condition] (todas las filas si no hay [where]). En esas filas, la columna [coli] toma el valor [vali]. |
[delete from table where condition] | Elimina todas las filas de [table] que cumplen [condition] (todas las filas si no hay [where]). |
Escribiremos una aplicación de consola que emite comandos SQL sobre [dbarticles]. A continuación se muestra un ejemplo de la salida. Se invita al lector a comprender los comandos SQL emitidos y sus resultados:
- línea 2: la URL de la base de datos y el usuario JDBC: son los parámetros utilizados para conectarse a la base de datos;
- línea 4: se recupera el contenido de la tabla [articles];
- línea 17: se inserta una nueva fila. Observe que la columna [id] no se inicializa en esta operación porque el SGBD generará su valor;
- línea 20: verificación. Línea 32: la fila se agregó efectivamente, con [id] 7. Con [select *], los nombres de las columnas son los de la tabla, en mayúsculas;
- Línea 34: aumentamos en un 10 % el precio del artículo que acabamos de agregar;
- Línea 43: el aumento de precio ha surtido efecto;
- línea 45: se elimina el artículo agregado anteriormente;
- línea 48: verificamos que solo quedan seis artículos;
- Línea 56: el programa solo acepta los cuatro comandos [select], [insert], [update], y [delete];
- línea 60: un error informado por el SGBD: la tabla [article] no existe;
- línea 63: la restricción de unicidad [UNQ_NAME] impide agregar un segundo artículo [bike]. Los mensajes de error de MySQL, al igual que los del controlador, están en inglés.
10.3.3. Las interfaces básicas de JDBC para el modo conectado
Volvamos al diagrama de una aplicación que accede a una base de datos a través de un controlador JDBC:

En el modo conectado, la aplicación:
- abre una conexión con la fuente de datos;
- trabaja con la fuente de datos en modo de lectura/escritura;
- cierra la conexión.
En estas operaciones intervienen principalmente tres tipos de objetos:
- la conexión ([Connection]), que encapsula las propiedades y los métodos de la conexión con la base de datos;
- el comando SQL ([Statement], o [PreparedStatement] para un comando parametrizado), que encapsula las propiedades y los métodos del comando SQL ejecutado;
- el resultado ([ResultSet]), que encapsula las propiedades y los métodos del resultado de un comando SQL [select].
Son interfaces del paquete [java.sql]. El controlador de MySQL las implementa mediante clases de sus propios paquetes ([com.mysql.cj.jdbc.ConnectionImpl], [ClientPreparedStatement], [ResultSetImpl]…), que la aplicación no necesita conocer: obtiene sus objetos mediante métodos que devuelven interfaces. La conexión se obtiene de la clase [DriverManager] (o de una fuente de datos [DataSource], de la que hablaremos más adelante), el comando SQL lo crea la conexión y el resultado lo devuelve el comando SQL.
10.3.3.1. La interfaz Connection
Sirve para administrar la conexión con la base de datos. Una conexión se obtiene mediante el método estático [DriverManager.getConnection(url, user, password)], que recibe la URL de la base de datos y JDBC —por ejemplo, [jdbc:mysql://localhost:3306/dbarticles]— y las credenciales del usuario. La conexión devuelta ya está abierta. Los métodos de la interfaz [Connection] que utilizaremos son los siguientes:
Método | Función |
[createStatement] | Crea un comando SQL asociado a esta conexión. |
[prepareStatement] | [prepareStatement(sql)] crea un comando SQL configurado como [PreparedStatement] asociado a esta conexión. |
[prepareCall] | [prepareCall("{call name(?, ?)}")] crea un comando [CallableStatement] que ejecuta un procedimiento almacenado en la base de datos. |
[setAutoCommit] | [setAutoCommit(false)] inicia una transacción (véase más adelante). |
[commit], [rollback] | confirma o revierte la transacción actual. |
[getMetaData] | devuelve un objeto [DatabaseMetaData] que describe el SGBD y el controlador. |
[isValid] | [isValid(seconds)] comprueba que la conexión sigue siendo utilizable. |
[close] | cierra la conexión, junto con los comandos SQL y los resultados que produjeron. |
Abrir una conexión adopta la siguiente forma (los fragmentos de código de este apartado provienen de la clase [Models] del proyecto, que se compila pero no se ejecuta):
10.3.3.2. La interfaz Statement
Sirve para ejecutar un comando SQL. Los métodos de esta interfaz que utilizaremos son los siguientes:
Método | Función |
[executeQuery] | [executeQuery(sql)] ejecuta un comando SQL [select]. Produce un objeto [ResultSet] que representa el resultado de [select]. |
[executeUpdate] | [executeUpdate(sql)] ejecuta un comando SQL [update], [insert], [delete] (o un comando de definición como [create table]). Devuelve el número de filas afectadas por la operación (actualizadas, insertadas, eliminadas). [executeLargeUpdate] (Java 8) devuelve este número en forma de [long]. |
[execute] | [execute(sql)] ejecuta cualquier comando SQL. Devuelve [true] si el comando produjo un [ResultSet], que se obtiene entonces mediante [getResultSet], [false] si produjo un número de filas, que se obtiene mediante [getUpdateCount]. |
[addBatch], [executeBatch] | agregan un comando a un lote y ejecutan el lote (véase más adelante). |
[getGeneratedKeys] | devuelve las claves primarias generadas por el SGBD durante una ejecución de [insert]. |
[setQueryTimeout] | [setQueryTimeout(seconds)] establece el tiempo máximo de ejecución del comando. |
[close] | cierra el comando SQL, así como su [ResultSet]. |
La interfaz [PreparedStatement] deriva de [Statement]: es un comando SQL parametrizado, cuyo texto se fija al crearlo y cuyos parámetros reciben valores mediante los métodos [setXxx]. Lo examinaremos en la sección «Consultas parametrizadas». La ejecución de comandos SQL sin transacción adopta la siguiente forma:
10.3.3.3. La interfaz ResultSet
Encapsula los resultados de un comando SQL [select]. Un objeto [ResultSet] representa una tabla con filas y columnas, que se procesa de forma secuencial: primero la primera fila, luego la segunda, y así sucesivamente, sin posibilidad de retroceder (este es el tipo predeterminado, [TYPE_FORWARD_ONLY]; JDBC también admite resultados que se pueden recorrer en ambos sentidos, pero se usan muy poco). El [ResultSet] tiene un cursor posicionado inicialmente antes de la primera fila: hay que llamar a [next] para leer la primera fila. Los métodos de esta interfaz que utilizaremos son los siguientes:
Método | Función |
[next] | Pasa a la siguiente fila de la tabla de resultados. Devuelve [true] si la fila se leyó correctamente y [false] si no quedan más filas. |
[getInt] | [getInt(i)] devuelve el valor entero de la columna número i de la fila actual. Las columnas se numeran a partir de 1, no de 0. [getInt("name")] devuelve el valor de la columna llamada [name]. Otros métodos similares son [getBoolean], [getBigDecimal], [getDouble], [getLong], [getString]… |
[getObject] | [getObject(i)] devuelve el valor de la columna i en forma de [Object], del tipo elegido por el controlador; [getObject(i, LocalDate.class)] (Java 7) lo devuelve en el tipo solicitado. |
[wasNull] | devuelve [true] si la última columna leída no tenía valor, lo que se representa con el valor SQL [NULL]. Los métodos que devuelven un objeto ([getString], [getBigDecimal], [getObject]…) devuelven entonces [null]; los que devuelven un tipo primitivo ([getInt], [getDouble]…) devuelven 0: solo [wasNull] permite distinguir 0 de [NULL]. |
[getMetaData] | devuelve un objeto [ResultSetMetaData] que describe las columnas del resultado: [getColumnCount] (el número de columnas), [getColumnLabel(i)] (el nombre de la columna n.º i), [getColumnTypeName(i)] (su tipo SQL)… |
[close] | cierra el resultado. |
La consulta de un objeto [ResultSet] suele tener el siguiente aspecto:
Con MySQL Connector/J, las filas del resultado se transfieren por defecto, todas, del servidor a la memoria de la aplicación en cuanto se ejecuta la consulta; [next] las recorre luego. Para un resultado de varios millones de filas, se puede indicar al controlador que las reciba a medida que se leen (parámetro [useCursorFetch=true] de la URL y [setFetchSize(n)] en el comando SQL): es un ajuste específico del controlador que no utilizaremos.
10.3.4. Manejo de errores
La capa [dao] puede encontrar numerosos errores al operar la base de datos: servidor caído, base de datos inexistente, contraseña incorrecta, error de sintaxis SQL, violación de una restricción de integridad, etc. Se notifican como excepciones [SQLException]. [SQLException] es una excepción verificada (checked) (capítulo 3): todos los métodos de JDBC la declaran en su cláusula [throws], y el compilador exige que el código que los llama la capture o la declare a su vez. El código de la capa [dao] debe tratar estos errores y, en cualquier caso, liberar los recursos que ha adquirido: la conexión, el comando SQL y el resultado deben cerrarse. Antes de Java 7, el código mostrado arriba para procesar el resultado de un comando [select] tenía este aspecto:
Este código es prolijo: el cierre de la conexión puede provocar a su vez una [SQLException] (línea 24), que debe interceptarse en la cláusula [finally]. Desde Java 7, la instrucción try-with-resources (capítulo 3) automatiza estos cierres: los objetos [Connection], [Statement], y [ResultSet] implementan la interfaz [AutoCloseable], y los recursos declarados entre los paréntesis de [try] se cierran al salir del bloque, sea cual sea la forma de salir:
- líneas 2–4: se declaran tres recursos, separados por punto y coma. Cada uno puede utilizar los anteriores. Se cierran en el orden inverso al de su declaración: el resultado, luego el comando SQL y después la conexión. Una excepción lanzada por un cierre no oculta la que pudo haber provocado la salida del bloque: se le adjunta como excepción «suprimida» ([getSuppressed]);
- línea 9: la cláusula [catch] captura los errores de conexión y de ejecución, así como los de los cierres.
La ventaja de try-with-resources no es solo que ahorra líneas de código: evita que el desarrollador tenga que cerrar la conexión manualmente. Sin embargo, olvidar cerrar una conexión puede pasar inadvertido y hacer que la aplicación se «caiga» de manera aparentemente aleatoria cuando el SGBD (o el pool de conexiones, que veremos más adelante) alcanza el número máximo de conexiones abiertas que admite. En el resto de este curso, todo recurso JDBC se abre dentro de un bloque try-with-resources.
La clase [SQLException] proporciona tres datos sobre el error:
- [getMessage]: el mensaje de error;
- [getErrorCode]: el código de error específico del SGBD (números de error de MySQL: 1049, 1062…);
- [getSQLState]: un código de error de cinco caracteres definido por el estándar SQL («SQLSTATE»), común a todos los SGBD para los errores más habituales: la clase [42] denota un error de sintaxis o de acceso, [23] denota una violación de una restricción de integridad, [08] denota un error de conexión…
Desde Java 6 (JDBC 4.0), [SQLException] también tiene clases derivadas estándar, que los controladores lanzan según la naturaleza del error. Las principales son las siguientes:
Clase | Error |
[SQLSyntaxErrorException] | Error de sintaxis SQL, tabla o base de datos inexistente, permisos insuficientes (SQLSTATE, clase 42) |
[SQLIntegrityConstraintViolationException] | Violación de una restricción de integridad: clave duplicada, clave externa, columna [NOT NULL] (SQLSTATE, clase 23) |
[SQLDataException] | Datos no válidos: valor demasiado grande, conversión imposible (SQLSTATE, clase 22) |
[SQLTimeoutException] | Tiempo de espera agotado ([setQueryTimeout]) |
[SQLTransactionRollbackException] | Transacción revertida por el SGBD, por ejemplo debido a un interbloqueo |
[SQLNonTransientConnectionException], [SQLRecoverableException] | Problema de conexión |
El programa [Jdbc02.java] provoca diversos errores y los muestra:
Resultados:
- Líneas 13–15: los parámetros de conexión a la base de datos, especificados al inicio del programa;
- línea 18: el número de error de MySQL «Duplicate entry», tal como se nombra en la documentación de MySQL;
- líneas 22–30: seis operaciones que fallan: base de datos inexistente; servidor inaccesible (ningún servidor MySQL escucha en el puerto 3399, lo que produce el mismo error que un servidor detenido); error de sintaxis; tabla inexistente; nombre de artículo duplicado; precio negativo. El parámetro [connectTimeout=5000] de la URL de la línea 23 limita el tiempo de espera de la conexión a 5 segundos (5000 ms);
- línea 34: el método [execute] ejecuta el comando SQL [query] sobre la base de datos con la URL [url];
- Líneas 36–37: la conexión y el comando SQL se abren dentro de un bloque
try-with-resources; - línea 38: el método [execute] ejecuta cualquiera de los comandos SQL: [select] o [insert];
- línea 41: un [switch] sobre la excepción, con patrones de tipo (Java 21, capítulo 3);
- línea 43: un patrón con guarda ([when]) permite tratar por separado un error específico: una violación de una restricción de integridad ([SQLIntegrityConstraintViolationException]) con código de MySQL igual a 1062, es decir, una clave duplicada. En este caso, una aplicación mostraría un mensaje comprensible para el usuario;
- líneas 46–50: otros errores. Se muestran la clase de la excepción, el código de error de MySQL y el código SQLSTATE, seguidos de la primera línea del mensaje ([lines], Java 11, divide una cadena en líneas): algunos mensajes del controlador ocupan varias líneas.
Los resultados muestran que el controlador de MySQL utiliza las clases estándar: [SQLSyntaxErrorException] para una base de datos inexistente (1049), un error de sintaxis (1064) o una tabla inexistente (1146), todos ellos con SQLSTATE [42xxx]. Un servidor inaccesible genera una [CommunicationsException], una clase del controlador (derivada de [SQLRecoverableException]): no hay código de error de MySQL, ya que el servidor no respondió, pero el SQLSTATE [08S01] indica un fallo de conexión. La violación de una restricción [CHECK] (error 3819) es simplemente una [SQLException], con SQLSTATE [HY000] («error general»): MySQL no le asigna un SQLSTATE de la clase 23. Por lo tanto, no se puede confiar plenamente en las clases derivadas: el código de error y el SQLSTATE siguen siendo útiles.
Una capa [dao] que desee seguir siendo independiente del SGBD utiliza solo las clases estándar y el SQLSTATE; los códigos de error ([getErrorCode]) son específicos de cada SGBD.
10.3.5. Configuración del proyecto de ejemplo
El controlador JDBC de MySQL es una biblioteca publicada en Maven Central, el repositorio central de Maven (capítulo 2). Los programas de este capítulo forman un proyecto Maven, [jdbc], ubicado en la carpeta [10-jdbc/jdbc]:
Su archivo [pom.xml] es el siguiente:
- Líneas 8–10: los datos del proyecto;
- líneas 13–14: la versión de Java y la codificación de los archivos fuente, como en todos los proyectos de este curso;
- línea 16: la propiedad [exec.mainClass] especifica la clase ejecutada por [mvn exec:java] (línea 59). Su valor predeterminado es [jdbc.Jdbc01]; para ejecutar otro programa, redefina la propiedad en la línea de comandos: [mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc02];
- líneas 21–25: el controlador JDBC de MySQL, MySQL Connector/J, con las coordenadas [com.mysql:mysql-connector-j]. Hasta la versión 8.0.30 se publicaba con el identificador [mysql:mysql-connector-java], que todavía se encuentra en muchos proyectos;
- líneas 27–31: el pool de conexiones HikariCP, que utilizaremos desde el programa [Jdbc03];
- líneas 33–37: HikariCP escribe sus mensajes de registro mediante la API y SLF4J («Simple Logging Facade for Java»), que requiere una implementación: utilizamos Logback. Sin ella, SLF4J mostraría una advertencia al iniciar. El archivo [src/main/resources/logback.xml], que se muestra a continuación, solo muestra advertencias y errores;
- líneas 42–52: el compilador, configurado como en todos los proyectos del curso: nombres de los parámetros conservados en las clases compiladas ([parameters]) y todas las advertencias habilitadas ([-Xlint:all]);
- líneas 54–61: el complemento [exec-maven-plugin], que ejecuta la clase especificada por la propiedad [exec.mainClass].
El archivo de configuración de Logback es el siguiente:
- líneas 4–8: los mensajes se escriben en la consola con el formato «clase nivel - mensaje»;
- línea 9: solo se muestran los mensajes de nivel [WARN] (advertencia) o [ERROR] . Con el nivel [INFO], se verían los mensajes de inicio y cierre del pool HikariCP.
Hay dos controladores JDBC habituales para MySQL:
- [com.mysql:mysql-connector-j] («Connector/J»), publicado por Oracle, propietaria de MySQL, bajo la licencia GPL v2 con una excepción («Universal FOSS Exception») que permite usarlo con software distribuido bajo otras licencias libres; una licencia comercial cubre todos los demás casos. Es el controlador oficial, el que utilizamos;
- [org.mariadb.jdbc:mariadb-java-client], el controlador de MariaDB (una variante libre de MySQL), con licencia LGPL, que también funciona con MySQL.
Ambos controladores implementan las mismas interfaces JDBC: pasar de uno a otro solo requiere cambiar la dependencia en [pom.xml] y el inicio de la URL ([jdbc:mariadb:] en lugar de [jdbc:mysql:]).
Una nota histórica: hasta Java 5, había que cargar la clase del controlador antes de abrir una conexión, mediante una instrucción como [Class.forName("com.mysql.jdbc.Driver")], que todavía se encuentra en muchos ejemplos de Internet. Desde Java 6 (JDBC 4.0), esto ya no es necesario: cada archivo de controlador declara su clase en un archivo [META-INF/services/java.sql.Driver], y [DriverManager] carga automáticamente todos los controladores presentes en el classpath mediante el mecanismo de servicios ([ServiceLoader]).
Los parámetros de conexión no deben codificarse directamente en una aplicación real: dependen de la máquina en la que está instalada. El primer programa de este capítulo los lee de un archivo de propiedades (capítulo 6), [dbarticles.properties], ubicado en la carpeta del proyecto:
- Línea 2: la URL JDBC de la base de datos. Una URL JDBC tiene la forma [jdbc:subprotocol:details]. El subprotocolo identifica el controlador ([mysql]), y los detalles —cuyo formato depende del controlador— identifican la base de datos. Para MySQL, son:
- [//localhost]: el nombre de la máquina en la que se encuentra el SGBD; MySQL —en este caso, [localhost]— es la máquina en la que se ejecuta el programa;
- [:3306]: el puerto en el que el servidor MySQL escucha las conexiones; el valor predeterminado es 3306;
- [/dbarticles]: el nombre de la base de datos;
- Pueden seguir parámetros opcionales del controlador, después de un signo de interrogación, con la forma [?param1=value1¶m2=value2]. Encontraremos [connectTimeout], [rewriteBatchedStatements], y [allowMultiQueries];
- línea 3: el usuario de MySQL, aquí [root], el administrador del SGBD;
- línea 4: su contraseña, aquí vacía.
La documentación de Connector/J proporciona una lista completa de los parámetros de la URL: Connector/J Configuration Properties.
Los demás programas de este capítulo, más cortos, almacenan sus parámetros de conexión en constantes al inicio del programa, como [Jdbc02.java]: esto es más sencillo para los ejemplos, pero no debe hacerse en una aplicación real.
Para ejecutar los programas, vaya a la carpeta [jdbc] y escriba:
El primer comando ejecuta [Jdbc01], y el segundo ejecuta [Jdbc02]. La opción [-q] («quiet») suprime los mensajes de Maven: solo queda la salida del programa. Por supuesto, también puede ejecutar los programas desde el IDE. En las secciones siguientes, mostraremos únicamente la salida de los programas.
10.3.6. El programa de ejemplo
El programa [Jdbc01.java], del que ya vimos un ejemplo de ejecución, es el siguiente (programa principal):
- Líneas 7–12: las interfaces JDBC utilizadas, todas del paquete [java.sql]. El programa no contiene el nombre de ninguna clase del controlador de MySQL: solo la URL y JDBC, leídos de la configuración, hacen referencia a MySQL;
- línea 21: los cuatro comandos SQL aceptados, en un conjunto inmutable creado mediante [Set.of] (Java 9, capítulo 5);
- línea 23: el método [main]. Como en los demás proyectos Maven de este curso, tiene la forma estándar [public static void main(String[] args)], reconocida por todas las herramientas;
- líneas 25–31: lectura del archivo [dbarticles.properties], como en el capítulo 6. El archivo se busca en el directorio actual —aquel desde el que se lanza el programa—, que es el directorio del proyecto cuando se escribe [mvn exec:java];
- líneas 32–38: los tres parámetros de conexión. [getProperty(key, defaultValue)] devuelve un valor predeterminado si falta la clave; la URL, en cambio, es obligatoria;
- línea 44: el bucle de entrada de los comandos SQL escritos con el teclado y su ejecución sobre la base de datos;
- línea 46: [IO.readln] (Java 25) muestra el indicador y lee una línea escrita con el teclado. Devuelve [null] si la entrada estándar está cerrada;
- línea 53: la primera palabra de la consulta, obtenida dividiendo la consulta por los espacios (expresión regular [\s+], capítulo 5). Se convierte a minúsculas para compararla, pero la consulta en sí no se modifica: convertir toda la consulta a minúsculas impediría insertar un artículo llamado «Bike»;
- líneas 54–58: si la consulta no es válida, se muestra un mensaje de error y el programa pasa a la siguiente consulta;
- líneas 60–64: se ejecuta el comando SQL introducido. La ejecución adopta una forma distinta según se trate de un comando [select] o de un comando [insert], [update] o [delete] : en el primer caso, el comando recupera datos de la base de datos sin modificarla; en el segundo, actualiza la base de datos sin recuperar ningún dato. En ambos casos, la ejecución se delega en un método que recibe los parámetros de conexión y el comando SQL que se debe ejecutar.
10.3.7. Ejecución de una consulta SELECT
La ejecución de comandos SQL comprende los siguientes pasos:
- conectarse a la base de datos;
- enviar los comandos SQL a la base de datos;
- procesar los resultados de los comandos SQL;
- cerrar la conexión.
Los pasos 2 y 3 pueden repetirse; la conexión se cierra solo al final del procesamiento de la base de datos. Las conexiones abiertas son recursos limitados en un SGBD: hay que economizarlas y siempre se procura limitar la duración de una conexión abierta. En nuestro programa, la conexión se cierra después de cada comando SQL y se abre una nueva para el comando siguiente.
Sin embargo, abrir una conexión es costoso: requiere establecer una conexión de red con el servidor, posiblemente negociar el cifrado y autenticarse. [DriverManager] no hace nada para reducir este costo: cada llamada a [getConnection] abre una nueva conexión de red, y cada [close] la cierra realmente. Para una herramienta interactiva como esta, no es un problema. Una aplicación que ejecuta muchos comandos SQL —un servidor web, por ejemplo— utiliza en cambio un pool de conexiones: cuando la aplicación cierra una conexión, el pool no la cierra realmente, sino que la devuelve al pool; cuando la aplicación solicita una nueva conexión, recibe una de las conexiones del pool que ya están establecidas. La ventaja de este sistema es que es transparente para el desarrollador: el código que abre y cierra conexiones mediante un bloque try-with-resources no necesita modificarse. Veremos cómo utilizarlo en la sección «Fuentes de datos y pools de conexiones». Abrir una conexión al comienzo de cada operación y cerrarla al final es, por lo tanto, la mejor práctica.
Primero nos centraremos en la ejecución de los comandos SQL [select]. El método [executeSelect] de nuestro programa de ejemplo y el método [displayResultSet] que utiliza son los siguientes:
- línea 2: el método recibe los parámetros de conexión y el comando SQL [select] [query] que se debe ejecutar;
- Líneas 4–6: una instrucción
try-with-resourcesabre tres recursos:- línea 4: la conexión con la base de datos, obtenida de [DriverManager]. [DriverManager] consulta a cada controlador del classpath: el primero que reconoce la URL abre la conexión. Es aquí donde se utilizan los parámetros de conexión y donde se producen los errores de conexión. La conexión es del tipo definido por la interfaz [Connection]: el código no sabe que se trata de un objeto del controlador de MySQL;
- línea 5: el comando SQL, un objeto [Statement] creado por la conexión. El mismo tipo de objeto se utiliza para ejecutar un comando [select] y los comandos [update], [insert] y [delete] ;
- Línea 6: el comando [select] se ejecuta mediante el método [executeQuery], que devuelve un objeto [ResultSet];
- línea 8: los resultados se muestran mediante el método [displayResultSet];
- Líneas 9–11: cualquier operación sobre la base de datos puede provocar una [SQLException]. Aquí es aún más probable, porque los comandos SQL introducidos por el usuario pueden contener errores de sintaxis. Debemos poder informar de ello al usuario: se captura la excepción y se muestra su mensaje. Al salir de [try] —ya sea normalmente o mediante una excepción— se cierran el resultado, el comando SQL y la conexión;
- línea 15: el método recibe un objeto [ResultSet]. Declara la excepción verificada [SQLException] que pueden lanzar los métodos de [ResultSet]: el método que lo llama la trata;
- Líneas 17–25: se muestran los nombres de las columnas de la tabla de resultados de [select]. Son las columnas [coli] de la consulta [select col1, col2, … from table …]. Las proporcionan los metadatos del resultado, un objeto [ResultSetMetaData] (línea 17): [getColumnCount] devuelve el número de columnas, y [getColumnLabel(i)] devuelve el nombre de la columna número i, o su alias si la consulta lo define ([select count(*) as total …]). Observe el bucle de las líneas 20–22: las columnas se numeran a partir de 1, mientras que el arreglo [names] se numera a partir de 0. [String.join] concatena los nombres, separándolos con comas, y ["-".repeat(n)] (Java 11) produce una cadena de n guiones;
- Líneas 27–33: se recorre la tabla de resultados y se muestran los valores de cada fila;
- línea 30: el tipo de la columna i del resultado se desconoce porque no se conoce la consulta introducida por el usuario. Por lo tanto, no se puede usar la sintaxis [result.getXxx(i)], donde [Xxx] es el tipo de la columna. Utilizamos entonces [getObject(i)], que devuelve el valor en forma de [Object]; [StringBuilder.append(Object)] lo agrega mediante su método [toString]. Para la columna [PRICE], de tipo SQL [DECIMAL(10,2)], el objeto es un [BigDecimal] con dos decimales, que su método [toString] muestra con punto decimal ([500.00]): a diferencia de [String.format], [toString] no depende del idioma de la estación de trabajo. Una presentación «a la francesa» utilizaría [String.format("%.2f", price)] o la clase [NumberFormat] (capítulo 5).
10.3.8. Ejecución de una solicitud de actualización: INSERT, UPDATE, DELETE
El código del método [executeUpdate] es el siguiente:
La ejecución de un comando de actualización se diferencia de la de un comando [select] solo en el método utilizado para el comando SQL: [executeQuery] para [select], [executeUpdate] para [update], [insert], [delete]:
- líneas 3–4: esta vez solo hay dos recursos: la conexión y el comando SQL;
- línea 6: el comando [update], [insert], o [delete] se ejecuta mediante el método [executeUpdate]. Si tiene éxito, este método devuelve el número de filas actualizadas ([update]), insertadas ([insert]) o eliminadas ([delete]);
- Línea 8: se muestra este número de filas.
Se invita al lector a revisar el ejemplo de ejecución presentado en la sección «Los cuatro comandos básicos del lenguaje SQL».
10.4. JDBC e independencia del SGBD
10.4.1. Los controladores JDBC actuales
El código que hemos examinado no contiene el nombre de ninguna clase del controlador de MySQL: utiliza únicamente las interfaces de [java.sql]. Para que funcione con otro SGBD, en principio basta con agregar al proyecto el controlador de ese SGBD y cambiar la URL de JDBC. Estos son los principales controladores JDBC actuales, todos publicados en Maven Central:
SGBD | Dependencia Maven | URL JDBC | Notas |
MySQL | [com.mysql:mysql-connector-j] | [jdbc:mysql://host:3306/database] | El controlador oficial utilizado en este curso |
MariaDB, MySQL | [org.mariadb.jdbc:mariadb-java-client] | [jdbc:mariadb://host:3306/database] | |
PostgreSQL | [org.postgresql:postgresql] | [jdbc:postgresql://host:5432/database] | |
SQL Server, Azure SQL | [com.microsoft.sqlserver:mssql-jdbc] | [jdbc:sqlserver://host:1433;databaseName=database] | el controlador de Microsoft |
Oracle | [com.oracle.database.jdbc:ojdbc11] | [jdbc:oracle:thin:@//host:1521/service] | |
H2 | [com.h2database:h2] | [jdbc:h2:mem:database] o [jdbc:h2:./file] | un SGBD escrito en Java, integrado en la aplicación: en memoria o basado en archivos, sin servidor; muy utilizado para pruebas |
SQLite | [org.xerial:sqlite-jdbc] | [jdbc:sqlite:file.db] | Una base de datos en un archivo, sin servidor |
Observe que el formato de la URL, a continuación de [jdbc:], es específico de cada controlador.
La estructura es la siguiente:

La aplicación solo conoce las interfaces de JDBC. Los objetos concretos los crea el controlador, que [DriverManager] selecciona según la URL: cada controlador presente en el classpath declara su clase principal, una implementación de la interfaz [java.sql.Driver], cuyo método [connect(url, info)] devuelve [null] si la URL no está destinada a él ([acceptsURL(url)] también permite consultarlo). El programa [Jdbc03.java] lo demuestra. Recibe como argumento la URL JDBC de la base de datos:
Resultados con la URL de MySQL (valor predeterminado):
Resultados con la URL de una base de datos PostgreSQL, cuyo controlador no está en el classpath:
Aquí comentamos la primera parte del programa (líneas 1–39 y 59–73); la segunda parte se trata en la sección siguiente:
- Línea 20: la URL JDBC de la base de datos, pasada como argumento; el valor predeterminado es MySQL [dbarticles]. Con Maven, el argumento se pasa mediante la propiedad [exec.args];
- líneas 23–25: [DriverManager.drivers] (Java 9) devuelve un stream ([Stream], capítulo 5) de los controladores cargados. Solo hay un controlador en el classpath: el de MySQL, de clase [com.mysql.cj.jdbc.Driver], versión 9.7 (línea 3 de los resultados);
- línea 28: [DriverManager] busca un controlador que admita la URL. Si ninguno la admite, [getConnection] lanza una [SQLException] «No suitable driver found» (línea 4 del segundo conjunto de resultados). Es el error que se obtiene cuando se ha omitido la dependencia del controlador en el [pom.xml], o se ha cometido un error de escritura en la URL;
- líneas 29–34: los metadatos de la conexión, un objeto [DatabaseMetaData], describen el SGBD (nombre, versión), el controlador y la versión de JDBC que implementa: JDBC 4.2, la versión de Java 8. JDK 25 define JDBC 4.3 (Java 9), que incluye solo adiciones menores; [DatabaseMetaData] también describe las capacidades del SGBD (transacciones, lotes, etc.), sus tablas y sus columnas;
- línea 35: ejecución de una consulta parametrizada mediante el método [displayArticles];
- líneas 61–63: la consulta tiene un parámetro, indicado con [?], que recibe su valor mediante [setInt(1, 200)]. Las consultas parametrizadas se tratan con más detalle más adelante;
- líneas 65–66: los resultados muestran que los objetos manipulados a través de las interfaces son objetos del controlador de MySQL: [ConnectionImpl], [ClientPreparedStatement], [ResultSetImpl] (línea 6 de los resultados);
- Líneas 67–70: como se conocen los tipos de las columnas, se utilizan los métodos [getInt], [getString] y [getBigDecimal] , que devuelven directamente un valor del tipo esperado.
Para que este programa funcione con PostgreSQL, basta con agregar la dependencia [org.postgresql:postgresql] al [pom.xml] y crear la base de datos [dbarticles] en PostgreSQL: [DriverManager] encontraría entonces dos controladores y seleccionaría el de PostgreSQL para una URL [jdbc:postgresql:…]. En la máquina utilizada para escribir este curso solo está instalado MySQL: no lo hicimos.
10.4.2. Fuentes de datos y pools de conexiones
[DriverManager] es la forma tradicional de obtener una conexión. Desde JDBC 2.0, las aplicaciones prefieren utilizar una fuente de datos —un objeto que implementa la interfaz [javax.sql.DataSource]—. Una fuente de datos se configura una sola vez (URL, nombre de usuario, contraseña, ajustes del controlador) y luego proporciona conexiones mediante su método [getConnection()], sin ningún parámetro. El código que utiliza la fuente de datos desconoce tanto la URL como las credenciales: en una aplicación, es la propia fuente de datos la que se registra en el contenedor de inyección de dependencias (capítulo 6), y no los parámetros de conexión. Hay dos grandes familias de fuentes de datos:
- las proporcionadas por los controladores, como [com.mysql.cj.jdbc.MysqlDataSource] para MySQL. Al igual que [DriverManager], abren una nueva conexión de red cada vez que se llama a [getConnection];
- las que administran un pool de conexiones. La más utilizada es HikariCP, el pool de conexiones predeterminado de Spring Boot. Su [getConnection] devuelve una conexión del pool, y el [close] de esa conexión la devuelve al pool en lugar de cerrarla.
La segunda parte del programa [Jdbc03] compara ambas (líneas 41–56 y 75–90 del programa anterior):
- líneas 42–45: una fuente de datos [MysqlDataSource], configurada mediante sus métodos [setURL], [setUser] y [setPassword]. Es la única parte del programa que hace referencia a una clase del controlador de MySQL;
- línea 46: el método [measure] recibe la fuente de datos con el tipo de la interfaz [DataSource]: serviría para cualquier controlador;
- Líneas 49–53: un objeto llamado [HikariConfig] define la configuración del pool: URL y JDBC, junto con las credenciales del pool y su tamaño máximo (5 conexiones; el valor predeterminado es 10). HikariCP utiliza [DriverManager] para abrir sus conexiones: funciona con cualquier controlador JDBC;
- línea 54: la fuente de datos [HikariDataSource] se crea a partir de esta configuración. Abre inmediatamente sus primeras conexiones. Como tiene conexiones abiertas, debe cerrarse al final del programa, lo que aquí se hace mediante la instrucción
try-with-resources; - Líneas 76–90: el método [measure] solicita una conexión a la fuente de datos 100 veces y la cierra de inmediato, midiendo el tiempo total con [System.nanoTime]. Los resultados hablan por sí solos (líneas 10–11 de los resultados iniciales): sin pool, abrir una conexión toma unos 50 ms para la conexión de red y la autenticación; con el pool, la conexión se establece en una fracción de milisegundo. Los tiempos dependen de la máquina, pero la proporción se mantiene más o menos igual;
- línea 82: con HikariCP, la conexión devuelta es un objeto [HikariProxyConnection] —un «proxy» que envuelve la conexión del controlador y cuyo método [close] la devuelve al pool.
Por lo tanto, una aplicación que atiende a muchos usuarios siempre utiliza un pool de conexiones. Volveremos sobre un caso de uso en la sección sobre hilos virtuales.
10.4.3. ¿Qué nivel de abstracción elegir?
La independencia de JDBC respecto del SGBD parece ideal. En la práctica, JDBC no puede ocultar todas las características específicas de un SGBD:
- el propio SQL difiere de un SGBD a otro en cuanto se va más allá de las operaciones básicas: generación de claves primarias, limitación del número de filas devueltas ([limit 10] en MySQL y PostgreSQL, [top 10] o [offset … fetch] en SQL Server), tipos de columnas, funciones de fecha, etc.;
- los tipos Java devueltos por [getObject] pueden variar: veremos que [count(*)] de MySQL devuelve un [Long];
- los códigos de error ([getErrorCode]) son específicos de cada SGBD, y los códigos SQLSTATE no siempre se usan de la misma manera;
- la URL y los parámetros de configuración son específicos de cada controlador.
Los parámetros de las consultas, en cambio, son uniformes: JDBC impone la notación [?] (parámetros posicionales, sin nombre), que cada controlador traduce a la sintaxis de su SGBD.
Para superar estas limitaciones o simplificar la escritura del código JDBC, hoy se utiliza principalmente lo siguiente:
- un ORM —casi siempre Hibernate, como se verá en el capítulo 11—, donde la capa [dao] manipula objetos Java y escribe sus consultas en HQL, un lenguaje de consulta orientado a objetos; Hibernate genera el SQL específico de cada SGBD (su «dialecto»);
- bibliotecas que conservan el SQL pero eliminan el código repetitivo de JDBC: [JdbcTemplate] y [JdbcClient] de Spring (este último desde Spring Framework 6.1), que transforman directamente filas de [select] en objetos Java y convierten [SQLException] en excepciones no verificadas; jOOQ, que construye consultas SQL en Java con validación en tiempo de compilación; MyBatis, que asocia consultas SQL escritas en archivos XML o en anotaciones con métodos Java.
Todas estas herramientas se basan en JDBC: comprender JDBC sigue siendo útil para entender lo que hacen y diagnosticar sus problemas.
10.5. Consultas parametrizadas
10.5.1. El concepto
Una consulta parametrizada es un comando SQL en el que ciertos valores se reemplazan por parámetros, cuyos valores se proporcionan por separado del texto de la consulta. Con JDBC, un parámetro se indica con un signo de interrogación [?], y el comando SQL es un objeto [PreparedStatement], creado mediante [connection.prepareStatement(query)]. Los parámetros se designan por su posición en la consulta, comenzando por 1, y se les asignan valores mediante los métodos [setXxx] en el siguiente orden: [setString(1, "bike")], [setInt(2, 10)]…
Los siguientes programas representan una fila de la tabla [articles] mediante un objeto [Article], definido en el archivo [Article.java] del proyecto:
- Línea 6: un [record] (Java 16, capítulo 4): una clase no modificable cuyo encabezado define los campos, con un constructor, descriptores de acceso ([id()], [name()]…) y los métodos [equals], [hashCode] y [toString] generados por el compilador. El precio es un [BigDecimal], al igual que la columna correspondiente [DECIMAL].
El programa [Jdbc04.java] implementa las consultas parametrizadas: vacía la tabla [articles], inserta en ella cinco registros mediante una consulta parametrizada y luego los vuelve a leer mediante otra consulta parametrizada:
Resultados:
- Líneas 24–27: una lista de cinco artículos. El [id] 0 no tiene importancia: no se insertará en la base de datos;
- Línea 31: se eliminan todos los artículos de la tabla. El método [executeUpdate] (línea 87) devuelve esta vez el número de filas eliminadas;
- línea 35: [forEach(IO::println)] muestra cada artículo de la lista mediante una referencia a método (capítulo 7). Los resultados muestran el método [toString] generado para el record;
- línea 45: el método para insertar una lista de artículos:
- línea 47: la consulta para insertar un artículo. Tiene cuatro parámetros, representados por [?]: el nombre (parámetro n.º 1), el precio (n.º 2), el stock actual (n.º 3) y el stock mínimo (n.º 4);
- línea 49: [prepareStatement] crea la orden configurada. El segundo argumento, [Statement.RETURN_GENERATED_KEYS], indica al controlador que recupere las claves primarias generadas por el SGBD durante las inserciones;
- líneas 51–56: los artículos se insertan uno por uno. A cada uno de los cuatro parámetros se le asigna un valor mediante el método [setXxx] correspondiente a su tipo, y luego la consulta —ya completa— se ejecuta con [executeUpdate], esta vez sin argumentos: el texto de la consulta se especificó al crear la orden. Los valores de los parámetros se conservan de una ejecución a otra hasta que se modifican (o hasta que se llama a [clearParameters]);
- líneas 58–61: [getGeneratedKeys] devuelve, en forma de [ResultSet], la clave primaria generada por el SGBD para la fila insertada. Los resultados muestran los [id] del 7 al 11: MySQL no reutiliza los valores del 1 al 6 de las filas eliminadas. Así se determina el identificador de una fila que acaba de insertarse;
- línea 67: el método que devuelve los artículos cuyos nombres coinciden con un patrón [like] de SQL (el carácter [%] representa cualquier secuencia de caracteres: [%3] designa los nombres que terminan en 3):
- líneas 68–69: la consulta tiene un parámetro, el modelo;
- línea 72: se asigna un valor al parámetro;
- líneas 73–81: cada fila del resultado se convierte en un objeto [Article]. Se conocen los tipos de las columnas: se utilizan los métodos [getXxx]. Aceptan el número de la columna (líneas 77–78) o su nombre (líneas 78–79). Acceder por nombre es más legible y tolera mejor los cambios en la consulta; acceder por número es ligeramente más rápido.
El nombre [PreparedStatement] (instrucción “preparada”) proviene de que un SGBD puede “preparar” una consulta parametrizada, es decir, compilarla de una vez por todas. Cuando un SGBD ejecuta un comando SQL, realiza un análisis y una optimización antes de ejecutarlo (establece un “plan de ejecución”). Una consulta parametrizada está pensada para ejecutarse varias veces con parámetros distintos, pero su texto no cambia: este trabajo solo debe hacerse una vez. Con MySQL Connector/J, la preparación la simula el controlador de forma predeterminada: inserta los valores de los parámetros —debidamente escapados— en el propio texto de la consulta antes de enviarla. El parámetro [useServerPrepStmts=true] de la URL hace que utilice la preparación que ofrece el servidor MySQL. En ambos casos, el código Java es el mismo.
Las principales correspondencias entre los tipos SQL y MySQL, los métodos de JDBC y los tipos Java son las siguientes:
Tipo de columna MySQL | Métodos JDBC | Tipo Java |
[INT] | [setInt], [getInt] | [int] ([Integer] para [getObject]) |
[BIGINT] | [setLong], [getLong] | [long] ([Long]) |
[DECIMAL(p,d)] | [setBigDecimal], [getBigDecimal] | [BigDecimal] |
[DOUBLE] | [setDouble], [getDouble] | [double] ([Double]) |
[VARCHAR(n)], cadena de longitud variable | [setString], [getString] | [String] |
[DATETIME] | [setObject(i, value)], [getObject(i, LocalDateTime.class)] | [LocalDateTime] |
[DATE] | [setObject(i, value)], [getObject(i, LocalDate.class)] | [LocalDate] |
[BOOL] (sinónimo de [TINYINT(1)]) | [setBoolean], [getBoolean] | [boolean] ([Boolean]) |
Las fechas se representan mediante las clases de [java.time] (capítulo 5), que JDBC admite desde la versión 4.2 (Java 8) mediante [setObject] y [getObject]. Las clases más antiguas [java.sql.Date], [java.sql.Time] y [java.sql.Timestamp], derivadas de [java.util.Date], y los métodos [getDate] y [getTimestamp] que las implementan, ya no deben usarse en código nuevo. Para asignar el valor SQL [NULL] a un parámetro, se escribe [setNull(i, Types.INTEGER)], donde la clase [java.sql.Types] (o el enum [JDBCType], Java 8) especifica el tipo SQL del parámetro.
10.5.2. La inyección SQL
La preparación no es la única ventaja de las consultas parametrizadas, ni la más importante. Considere la búsqueda de un artículo por su nombre. Podría querer construir el texto de la consulta mediante programación, insertando en él el término de búsqueda:
(esta es la línea 30 del programa [Jdbc05] que aparece más abajo). Si el nombre es “bicicleta”, la consulta queda así:
Pero si el nombre es “tanques de oxígeno de buceo”, queda así:
y es sintácticamente incorrecta por el apóstrofo en el nombre. Peor aún: si el nombre proviene de una entrada del usuario, este podría introducir texto que cambie el sentido de la consulta. Esta es la inyección SQL, una de las vulnerabilidades de seguridad más extendidas y graves en las aplicaciones que usan una base de datos. El programa [Jdbc05.java] lo demuestra con la búsqueda de un artículo por su nombre:
Resultados:
- línea 20: tres nombres que un usuario podría escribir: un nombre normal, un nombre que contiene un apóstrofo y un texto malicioso;
- línea 29: el primer método de búsqueda inserta el nombre en el texto de la consulta (línea 30), ejecutada por un [Statement] estándar:
- fila 3 de los resultados: con un nombre normal, todo funciona bien;
- línea 6: el apóstrofo del nombre termina prematuramente la cadena SQL; la consulta no es válida (línea 7). No es posible encontrar un artículo cuyo nombre contenga un apóstrofo;
- línea 8: el usuario introdujo un texto con apóstrofos colocados de tal modo que producen una consulta válida, pero para la cual la condición [name = 'x' or '1'='1'] es verdadera para todas las filas: la consulta devuelve la tabla completa (línea 15). Si la consulta verificara un nombre de usuario y una contraseña, el mismo procedimiento permitiría al usuario iniciar sesión sin conocer la contraseña. Con un controlador que acepte varios comandos SQL en una sola consulta, el usuario incluso podría agregar un comando de su elección después de un punto y coma, como un [delete]. Connector/J lo rechaza de forma predeterminada (parámetro [allowMultiQueries=false]), lo que limita el alcance de la inyección sin eliminarla;
- Línea 42: el segundo método utiliza una consulta parametrizada (líneas 45–47). El valor del parámetro nunca se interpreta como "SQL"; es simplemente un dato, sea cual sea su contenido. Se encuentra el nombre con apóstrofo (línea 22 de los resultados), y el texto malicioso es simplemente el nombre de un artículo que no existe (línea 25).
Se podrían “neutralizar” los apóstrofos duplicándolos, pero las reglas dependen del SGBD y es fácil pasar por alto un caso. La regla es simple: los valores proporcionados por el usuario (o por cualquier fuente externa) nunca deben concatenarse con el texto de una solicitud SQL; siempre se usa un PreparedStatement y parámetros. El programa interactivo [Jdbc01.java] no sigue esta regla por su propia naturaleza: ejecuta los comandos SQL que escribe el usuario. Es una herramienta de administración, no un ejemplo a seguir.
10.6. Transacciones
10.6.1. Información general
Una transacción es una secuencia de comandos SQL ejecutados “de forma atómica”:
- o bien todas las operaciones tienen éxito;
- o bien una de ellas falla, en cuyo caso se revierten todas las operaciones anteriores.
En definitiva, o bien todas las operaciones de una transacción se aplican con éxito, o bien no se aplica ninguna. El ejemplo clásico es una transferencia bancaria: el débito de una cuenta y el crédito en otra deben completarse ambos o ninguno. Cuando la propia aplicación controla la transacción, la confirma con un comando [COMMIT] o la revierte con un comando [ROLLBACK].
En nuestros ejemplos anteriores no usamos ninguna transacción. Y sin embargo había transacciones, porque en un SGBD un comando SQL siempre se ejecuta dentro de una transacción. Si la aplicación no inicia por sí misma una transacción explícita, el SGBD utiliza una transacción implícita. Hay entonces dos casos:
- cada comando SQL forma parte de una transacción, abierta por el SGBD antes del comando y confirmada después. Esto se denomina modo autocommit. Se comporta como si la aplicación creara una transacción para cada comando SQL;
- el SGBD no está en modo autocommit: inicia una transacción implícita con el primer comando SQL emitido fuera de una transacción y deja que la aplicación la finalice. Todos los comandos SQL siguientes forman parte de esta transacción implícita, que puede terminar por diversos eventos (cierre de la conexión, inicio de una nueva transacción, etc.), según reglas propias de cada SGBD. Conviene evitar este modo.
JDBC impone el primer caso: una conexión JDBC está en modo autocommit al abrirse, sea cual sea la configuración del SGBD (MySQL, con el motor de almacenamiento InnoDB usado de forma predeterminada, también está en modo autocommit).
Los comandos SQL de distintos usuarios se ejecutan simultáneamente, dentro de transacciones que se ejecutan en paralelo. Las operaciones realizadas por una transacción pueden afectar a las realizadas por otra. Existen cuatro niveles de aislamiento entre transacciones de distintos usuarios:
- Read Uncommitted;
- Read Committed;
- Repeatable Read;
- Serializable.
Read Uncommitted
Este nivel de aislamiento también se conoce como “Dirty Read” (lectura sucia). Este es un ejemplo de lo que puede ocurrir en este modo:
- un usuario llamado U1 inicia una transacción sobre la tabla T;
- un usuario llamado U2 inicia una transacción sobre la misma tabla T;
- el usuario U1 modifica filas de la tabla T pero aún no ha confirmado los cambios;
- el usuario U2 “ve” estos cambios y toma decisiones basándose en lo que ve;
- el usuario U1 revierte su transacción con [ROLLBACK].
En el paso 4, el usuario U2 tomó una decisión basándose en datos que luego resultaron ser incorrectos.
Read Committed
Este nivel de aislamiento evita el problema anterior: en el paso 4, el usuario U2 no “ve” los cambios realizados por el usuario U1 en la tabla T. Solo los verá después de que U1 haya confirmado su transacción con un [COMMIT]. Sin embargo, en este modo puede darse la siguiente situación:
- un usuario U1 inicia una transacción sobre la tabla T;
- un usuario U2 inicia una transacción sobre la misma tabla T;
- el usuario U2 ejecuta un [select] para calcular el promedio de la columna C de las filas de T que cumplen cierta condición;
- el usuario U1 modifica ([update]) ciertos valores de la columna C de T y confirma los cambios ([commit]);
- el usuario U2 repite el mismo [select] del paso 3. Descubre que el promedio de la columna C ha cambiado debido a las modificaciones realizadas por U1.
El usuario U2 ahora ve solo los cambios confirmados por U1, pero, aun dentro de la misma transacción, dos operaciones idénticas producen resultados distintos. Esta situación se denomina “lectura no repetible”. Es problemática para quien desea una vista coherente de la tabla T.
Repeatable Read
En este nivel de aislamiento, a un usuario se le garantiza obtener los mismos resultados en las lecturas de la base de datos mientras permanezca dentro de la misma transacción. Trabaja sobre una “instantánea” de los datos que no refleja los cambios realizados por otras transacciones, aunque estos hayan sido confirmados. Solo verá esos cambios una vez que haya finalizado su propia transacción.
Este nivel de aislamiento aún no es perfecto en teoría: otra transacción puede agregar ([insert]) filas que cumplan la condición del paso 3, lo que modificaría el resultado de una lectura posterior. Estas filas se denominan “lecturas fantasma”. Este es el nivel de aislamiento predeterminado de MySQL (InnoDB), que además evita las lecturas fantasma en las lecturas simples.
Serializable
En este modo de aislamiento, las transacciones están completamente aisladas entre sí: el resultado de dos transacciones ejecutadas simultáneamente es el mismo que si se hubieran ejecutado una tras otra. Para lograrlo, el SGBD bloquea los datos leídos y hace que las transacciones que intentan modificarlos esperen (o fallen). Este nivel reduce el paralelismo y, en consecuencia, el rendimiento.
No todos los SGBD ofrecen los cuatro niveles de aislamiento. El nivel de aislamiento predeterminado suele ser Read Committed (SQL Server, PostgreSQL, Oracle) o Repeatable Read (MySQL). La aplicación puede especificar explícitamente el nivel de aislamiento deseado.
10.6.2. Gestión de transacciones (API)
Con JDBC, las transacciones las gestiona la conexión. No existe un objeto “transacción”: una conexión tiene como máximo una transacción activa, y todos los comandos SQL ejecutados en esa conexión forman parte de ella. Los métodos pertinentes de la interfaz [Connection] son los siguientes:
Método | Función |
[setAutoCommit] | [setAutoCommit(false)] sale del modo autocommit: los comandos SQL siguientes forman parte de una transacción, que comienza con el primero de ellos y termina con [commit] o [rollback]. Con el siguiente comando comienza entonces una nueva transacción. [setAutoCommit(true)] vuelve al modo autocommit, confirmando la transacción en curso. |
[commit] | confirma la transacción: los resultados de los comandos SQL emitidos dentro de la transacción pasan a ser definitivos y visibles para otras transacciones. |
[rollback] | revierte la transacción: se deshacen los resultados de los comandos SQL emitidos en la transacción. |
[setSavepoint] | establece un punto de restauración (un objeto [Savepoint]) en la transacción en curso. |
[rollback(Savepoint)] | revierte los comandos SQL ejecutados desde el punto de restauración, sin revertir los que lo precedieron: la transacción continúa. |
[setTransactionIsolation] | establece el nivel de aislamiento de las transacciones de la conexión. Debe llamarse antes del inicio de una transacción. |
El nivel de aislamiento es una de las constantes de la interfaz [Connection]:
Valor | Significado |
[TRANSACTION_READ_UNCOMMITTED] | La transacción puede leer datos escritos por otra transacción que esta aún no ha confirmado. Debe evitarse. |
[TRANSACTION_READ_COMMITTED] | La transacción no puede leer datos escritos por otra transacción que esta aún no ha confirmado. Sin embargo, los datos leídos dos veces seguidas dentro de la transacción pueden cambiar, porque otra transacción pudo haberlos modificado entretanto; otra transacción también pudo haber agregado filas (filas fantasma). |
[TRANSACTION_REPEATABLE_READ] | Los datos leídos por la transacción no cambian hasta que esta finaliza. En teoría, esto no impide que otra transacción agregue filas. |
[TRANSACTION_SERIALIZABLE] | Todo se comporta como si la transacción se ejecutara sola. Esto reduce el rendimiento porque las transacciones ya no se ejecutan en paralelo. |
Una conexión que ha salido del modo autocommit debe cerrarse después de que la transacción haya sido confirmada o revertida. Si se cierra mientras hay una transacción en curso, el resultado depende del controlador (MySQL Connector/J la revierte): siempre se debe confirmar explícitamente una transacción.
10.6.3. El programa de ejemplo
El programa [Jdbc06.java] demuestra el efecto de una transacción:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 | |
Resultados:
- Líneas 24–25: una lista de dos artículos con el mismo nombre, [article]. La restricción de unicidad [UNQ_NAME] sobre la tabla [articles] impide que ambos existan en la base de datos al mismo tiempo: insertar el segundo provocará una [SQLException]. Para demostrar el efecto de una transacción, los dos artículos se insertarán de tres maneras:
- primero, fuera de cualquier transacción explícita. Como la conexión está en modo autocommit, cada inserción se realiza en su propia transacción. El primer artículo se insertará, pero el segundo no;
- luego, dentro de una transacción que abarca ambas inserciones. Como la segunda inserción fallará, la primera se revertirá: al final, no se realizará ninguna de las dos inserciones;
- por último, dentro de una transacción con un punto de restauración antes de cada inserción: el fallo de la segunda inserción revertirá solo a esta, y la transacción se confirmará con la primera;
- líneas 28–36: se vacía la tabla y luego se insertan ambos artículos sin transacción explícita. Como sabemos que la segunda inserción lanzará una excepción, esta se captura con un [try] / [catch]; por último, se muestra la tabla;
- líneas 38–42: repetimos la misma secuencia, pero con una transacción. Esta vez, la excepción se gestiona en el método [insertArticlesInTransaction];
- líneas 44–48: lo mismo se aplica a los puntos de restauración;
- línea 55: el método de inserción sin transacción. Utiliza dos métodos: [createInsertStatement] (línea 113), que crea el comando de inserción parametrizado, e [insertArticle] (línea 119), que asigna valores a los parámetros y ejecuta el comando;
- línea 65: el método para insertar dentro de una transacción:
- línea 68: el nivel de aislamiento [TRANSACTION_READ_COMMITTED], establecido antes de que comience la transacción;
- línea 69: la conexión sale del modo autocommit; la transacción comenzará con la primera inserción;
- líneas 71–73: las inserciones;
- línea 75: todo salió bien: se confirma la transacción y las inserciones se agregan de forma permanente a la base de datos;
- líneas 77–80: una inserción falló: se revierte la transacción;
- línea 87: el método de inserción con puntos de restauración:
- línea 93: se establece un punto de restauración antes de cada inserción;
- línea 98: si la inserción falla, se revierte hasta el punto de restauración: solo se revierte la inserción fallida y el bucle continúa;
- Línea 103: se confirma la transacción, con las inserciones exitosas.
En los resultados:
- fila 5: mostrada por el comando [delete]: había seis filas en la tabla;
- fila 7: la excepción provocada por la segunda inserción. El mensaje indica que no se cumplió la restricción [UNQ_NAME] sobre la tabla [articles] ;
- fila 9: la tabla no está vacía: se insertó el primer registro;
- fila 12: mostrada por el comando [delete]: había una fila en la tabla;
- Línea 13: la primera inserción se realizó con éxito… dentro de la transacción;
- línea 14: el mensaje que se muestra cuando la transacción falla;
- línea 15: la tabla está vacía: el [rollback] de la transacción revirtió la primera inserción;
- líneas 19–21: gracias a los puntos de restauración, la segunda inserción se revirtió y la transacción se confirmó;
- línea 23: la tabla contiene el primer artículo. Su valor de [id] es 11, no 8: cada intento de inserción —incluso si se revirtió o fue rechazado— consumió un valor de la columna [AUTO_INCREMENT], y MySQL no reutiliza esos valores.
Con MySQL, el fallo de un comando SQL cancela solo ese comando, y la transacción puede continuar: por lo tanto, el punto de restauración no es esencial aquí. Esto no ocurre en todos los SGBD: con PostgreSQL, incluso el error más leve deja la transacción inutilizable hasta que se revierte o hasta que se alcanza un punto de restauración. El código con puntos de restauración funciona con ambos.
10.7. Consultas que devuelven un único valor
Algunas consultas devuelven un solo valor, como [select count(*) from articles]: una fila de una sola columna. JDBC no tiene un método específico para ellas: se ejecuta la consulta con [executeQuery] y se lee la primera columna de la primera fila del resultado. El programa [Jdbc07.java] implementa un método para ello y demuestra algunas formas de usarlo:
Resultados:
- Línea 48: el método [singleValue] ejecuta la consulta y devuelve la primera columna de la primera fila mediante [getObject(1)], o [null] si la consulta no devuelve filas (línea 52);
- línea 21: el precio promedio de los artículos. El tipo Java del resultado depende del tipo SQL del valor: el promedio de una columna [DECIMAL] es un [BigDecimal], en este caso con seis decimales (línea 2 de los resultados);
- línea 23: el número de artículos. MySQL devuelve un entero de tipo [BIGINT], que en Java se convierte en un [Long] (línea 3);
- líneas 25–26: el nombre del artículo más caro, una cadena. La consulta contiene una subconsulta, encerrada entre paréntesis;
- línea 28: si la consulta no devuelve filas, el método devuelve [null] (línea 5);
- línea 30: si la consulta devuelve una fila cuyo valor es SQL [NULL] (el máximo de un conjunto vacío), [getObject] también devuelve [null] (línea 6). Por lo tanto, nuestro método no distingue entre los dos casos —ninguna fila o un valor [NULL]—; si la distinción importa, hay que probar uno mismo el resultado de [next];
- línea 57: una segunda versión genérica del método (capítulo 4) recibe el tipo deseado en forma de un objeto [Class<T>] y devuelve un valor de ese tipo. [getObject(1, type)] (línea 61) indica al controlador que convierta el valor a ese tipo;
- líneas 34–35: el propio controlador convierte el valor al tipo solicitado: el promedio a [BigDecimal], y el número de artículos ([BIGINT]) a [Integer]. [setScale(2, RoundingMode.HALF_UP)] redondea el promedio a dos decimales (línea 7);
- Línea 39: una conversión directa falla porque el objeto es un [Long]: la conversión [(int)] de un [Object] requiere un [Integer], que luego se "desempaqueta", y un [Long] no es un [Integer]. Se lanza una [ClassCastException] (línea 8). Este código funcionaría con un SGBD cuyo [count] devolviera un entero de tipo [INT], pero falla con MySQL: es un ejemplo de las peculiaridades de los SGBD que JDBC no oculta. Leer mediante [getInt], [getLong] o [getObject(i, type)], que deja la conversión al controlador, es más seguro;
- línea 41: una cláusula [catch] múltiple (Java 7) captura ambos tipos de excepciones.
10.8. JDBC es bloqueante: hilos virtuales
El capítulo 9 mostró que las operaciones de E/S no deben bloquear un hilo de la aplicación en aplicaciones que atienden a muchos usuarios (servidores, servicios web): mientras un comando SQL se ejecuta en el servidor, el hilo que lo emitió espera. Sin embargo, JDBC es una API bloqueante: [getConnection], [executeQuery], [next], [commit]… no devuelven el control hasta que el SGBD ha respondido. No existe una versión asíncrona de JDBC: un proyecto de API asíncrona (ADBA) se abandonó en 2019, y la API reactiva R2DBC —que existe fuera del JDK— no reemplazó a JDBC.
Desde Java 21, la solución de la plataforma Java es el hilo virtual (capítulo 8): un hilo ligero, gestionado por la JVM, del que pueden crearse miles. Cuando un hilo virtual espera una respuesta de la red, la JVM lo aparta y libera el hilo del sistema que lo ejecutaba, lo que permite que este ejecute otro hilo virtual. El código sigue siendo secuencial y bloqueante —sencillo de escribir y de leer—, pero la espera ya no genera sobrecarga. Los controladores JDBC recientes, incluido Connector/J 9, están escritos para funcionar con hilos virtuales, y desde Java 24 (JEP 491), un hilo virtual que espera en un bloque [synchronized] ya no monopoliza el hilo del sistema.
Queda una limitación: el número de conexiones. Mil hilos virtuales que consultan la base de datos no tienen mil conexiones; comparten las conexiones del pool y esperan a que una conexión quede disponible. El programa [Jdbc08.java] lo demuestra, usando un pool HikariCP de cuatro conexiones:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 | |
Resultados:
- líneas 24–28: configuración de un pool con un máximo de cuatro conexiones;
- línea 30: la fuente de datos [HikariDataSource], cerrada al final del programa por la instrucción
try-with-resources; - líneas 32–41: una instrucción de actualización dentro de una transacción, usando una conexión obtenida del pool. El [close] implícito de la línea 41 devuelve la conexión al pool. Los resultados muestran que los tres precios inferiores a 200 euros aumentaron un 10 % (línea 2 de los resultados);
- línea 93: el método [getArticleSlowly] lee un artículo en una consulta que tarda un segundo: la función de MySQL [sleep(1)] (líneas 95–96) espera un segundo antes de devolver 0. Esto simula una consulta lenta;
- líneas 44–56: seis lecturas de artículos, ejecutadas simultáneamente:
- línea 46: [Executors.newVirtualThreadPerTaskExecutor] (Java 21, capítulo 8) crea un ejecutor que lanza cada tarea en un nuevo hilo virtual. El ejecutor se cierra al final del bloque
try-with-resources(línea 51), y su método*[close]*(Java 19) espera a que todas las tareas terminen; - línea 49: cada tarea es una lambda que devuelve un [Article]: un
*[Callable<Article>]*, cuyo método*[call]*puede lanzar excepciones verificadas, en este caso la*[SQLException]de*[getArticleSlowly]*. [submit] devuelve un [Future<Article>]. La lambda usa la copia [articleId]* de la variable del bucle (línea 48), porque una lambda solo puede usar variables locales que no se modifican; - líneas 52–54: los artículos se muestran en el orden de las tareas. [Future.get] devuelve el resultado de la tarea; si la tarea lanzó una excepción, [get] lanza una [ExecutionException] que la encapsula (interceptada en la línea 87). [get] también puede lanzar una [InterruptedException], que [main] declara (línea 22);
- líneas 55–56: duración total. Seis consultas de un segundo ejecutadas una tras otra tardarían seis segundos; ejecutadas simultáneamente con seis conexiones, tardarían un segundo. Con cuatro conexiones, tarda aproximadamente dos segundos (línea 9 de los resultados): cuatro hilos virtuales obtienen una conexión y ejecutan sus consultas al mismo tiempo, mientras los otros dos esperan en [getConnection] a que se devuelva una conexión al pool, y luego ejecutan las suyas. El tiempo restante se emplea en abrir las conexiones del pool. Un hilo que espera demasiado una conexión (30 segundos de forma predeterminada, parámetro [connectionTimeout] en HikariCP) recibe una [SQLTransientConnectionException];
- línea 46: [Executors.newVirtualThreadPerTaskExecutor] (Java 21, capítulo 8) crea un ejecutor que lanza cada tarea en un nuevo hilo virtual. El ejecutor se cierra al final del bloque
- líneas 59–64: un único valor, el valor del stock;
- líneas 69–86: abandono de una consulta que tarda demasiado:
- líneas 69–73: una primera conexión sale del modo autocommit y modifica el artículo n.º 1 sin finalizar su transacción. El SGBD ha bloqueado la fila modificada hasta el final de la transacción;
- líneas 76–79: una segunda conexión intenta modificar la misma fila. Debe esperar a que la primera transacción termine… lo cual no ocurrirá. [setQueryTimeout(1)] (línea 78) limita el tiempo de ejecución del comando a un segundo: transcurrido un segundo, Connector/J indica al servidor que aborte la solicitud (comando MySQL [KILL QUERY]), y [executeUpdate] lanza una [SQLTimeoutException], en este caso de la clase [MySQLTimeoutException] del controlador (línea 11 de los resultados). Sin este tiempo de espera máximo, la consulta habría esperado al tiempo de espera de bloqueo de MySQL —50 segundos de forma predeterminada— y luego habría fallado;
- línea 85: la transacción [blocking] nunca se confirma; se revierte. La conexión se devuelve entonces al pool.
Los hilos virtuales no ofrecen ningún beneficio a un pequeño programa de consola que realiza una tarea a la vez: no hacen que una consulta sea más rápida. Pero permiten que una aplicación de servidor —como los servicios web Spring Boot del capítulo 13 (donde basta la propiedad [spring.threads.virtual.enabled=true])— atienda a muchos usuarios a la vez con código JDBC ordinario. El tamaño del pool de conexiones se convierte entonces en el verdadero control del paralelismo con respecto a la base de datos.
10.9. Ejecución por lotes
Cada ejecución de un comando SQL implica un viaje de ida y vuelta entre la aplicación y el servidor. Cuando hay que ejecutar varios comandos SQL, pueden enviarse al SGBD en un único intercambio, en forma de lote (batch). JDBC lo admite desde la versión 2.0:
- para un [Statement], [addBatch(sql)] agrega un comando SQL al lote;
- para un [PreparedStatement], [addBatch()] agrega al lote los valores actuales de los parámetros: el lote contiene el mismo comando SQL ejecutado con valores distintos;
- [executeBatch] ejecuta el lote y devuelve un arreglo de enteros: el número de filas modificadas por cada comando del lote. Si un comando falla, lanza una [BatchUpdateException], cuyo método [getUpdateCounts] devuelve los resultados de los comandos ejecutados.
El programa [Jdbc09.java] utiliza los siguientes lotes:
Resultados:
- líneas 21–22: el método [supportsBatchUpdates] de los metadatos de la conexión indica si el controlador puede ejecutar lotes;
- líneas 25–34: un lote de tres comandos de actualización distintos, agregados al lote de un [Statement] mediante [addBatch]:
- línea 31: se ejecutan los tres comandos. [executeBatch] devuelve el número de filas modificadas por cada uno: una inserción ([canoe]), una actualización (el stock de flechas, que está por debajo del stock mínimo) y una eliminación ([pump]);
- líneas 32–33: [Arrays.toString] muestra el arreglo, [Arrays.stream] lo convierte en un flujo de enteros ([IntStream]), y [sum] calcula la suma (línea 3 de los resultados);
- líneas 37–38: el método [insertBatch] se llama dos veces, con dos instancias distintas de URL;
- línea 68: el método [insertBatch] inserta [n] artículos con un lote:
- línea 70: las inserciones se realizan en una única transacción, lo que además es mucho más rápido que confirmar cada una individualmente;
- líneas 74–81: para cada artículo, se asignan los valores a los parámetros y luego [addBatch()] agrega esos valores al lote;
- líneas 82–83: se ejecuta el lote y luego se confirma la transacción;
- líneas 84–86: se muestran el número de inserciones, la duración y los tres primeros elementos del arreglo devuelto por [executeBatch];
- líneas 89–92: se eliminan los artículos insertados para devolver la tabla a su estado anterior;
- Línea 4 de los resultados: con la URL simple, el controlador de MySQL envía las 1000 inserciones una tras otra: el procesamiento por lotes casi no aporta ningún beneficio. Cada elemento del arreglo es 1;
- Línea 5 de los resultados: con el parámetro [rewriteBatchedStatements=true] de la URL del controlador, Connector/J reescribe el lote en varios comandos [insert into articles(…) values (…), (…), (…)…], cada uno de los cuales inserta numerosas filas. La ejecución es diez veces más rápida. Los elementos del arreglo valen entonces -2, el valor de la constante [Statement.SUCCESS_NO_INFO]: el comando tuvo éxito, pero el controlador no sabe cuántas filas modificó cada elemento del lote. Es un parámetro importante que conviene conocer: sin él, los lotes son de poca utilidad con MySQL;
- líneas 43–64: dos comandos [select] enviados en un único intercambio:
- líneas 44–45: la conexión se abre con el parámetro [allowMultiQueries=true], que permite varios comandos SQL separados por punto y coma en una sola solicitud. Como hemos visto, esto está desactivado de forma predeterminada para limitar el alcance de las inyecciones SQL;
- líneas 47–48: ambos comandos se ejecutan con [execute], que acepta cualquier comando;
- línea 50: [getResultSet] devuelve el resultado del primer comando;
- línea 56: [getMoreResults] pasa al siguiente resultado (cierra el resultado actual y devuelve [true] si el siguiente resultado es un [ResultSet]);
- línea 57: el resultado de la segunda consulta: una fila con dos columnas.
Los lotes son útiles para inserciones y actualizaciones a gran escala (como las importaciones de datos). Hibernate (capítulo 11) también los admite.
10.10. Modo desconectado: CachedRowSet
El modo desconectado de JDBC se basa en la interfaz [javax.sql.rowset.CachedRowSet], derivada de [ResultSet]: un [CachedRowSet] es un resultado de consulta copiado en memoria, que puede recorrerse en ambos sentidos y modificarse sin conexión, tras lo cual los cambios se envían de vuelta a la base de datos. El programa [Jdbc10.java] lo demuestra:
Resultados:
- líneas 23–24: [RowSetProvider.newFactory] (Java 7) devuelve una fábrica ([RowSetFactory]) de los diversos tipos de RowSet derivados del JDK, de los cuales [createCachedRowSet] crea un [CachedRowSet]. Un [CachedRowSet] es un recurso cerrado por la instrucción try-with-resources;
- líneas 26–29: el [CachedRowSet] recibe los parámetros de conexión y la consulta que lo poblará;
- líneas 31–32: para poder confirmar los cambios en la base de datos, debe conocer la tabla modificada y su clave primaria —en este caso, la columna 1—[id];
- línea 34: [execute] abre una conexión, ejecuta la consulta, copia todas las filas del resultado en memoria y cierra la conexión. El resto del trabajo se hace sin conexión;
- líneas 38–47: un [CachedRowSet] es un [ResultSet]: se recorre con [next], y las columnas se leen con [getXxx]. Los métodos [updateXxx] modifican una columna de la fila actual, y [updateRow] guarda el cambio… en la copia en memoria. El stock de flechas, que está por debajo del stock mínimo, se incrementa a 30 (fila 3 de los resultados);
- líneas 49–56: adición de una fila. [moveToInsertRow] coloca el cursor en una fila especial, la “fila de inserción”, cuyas columnas se especifican con [updateXxx]; [insertRow] la agrega al [CachedRowSet], y [moveToCurrentRow] devuelve el cursor a su posición anterior. [CachedRowSet] exige un valor para todas las columnas [NOT NULL], incluida [id]: un valor de 0, insertado en una columna [AUTO_INCREMENT], indica a MySQL que genere uno;
- líneas 58–60: [absolute(2)] coloca el cursor en la segunda fila, lo cual es posible gracias a [CachedRowSet]—un conjunto que puede recorrerse en cualquier sentido—, y [deleteRow] la elimina;
- línea 63: la base de datos aún no se ha modificado (líneas 5–11 de los resultados);
- líneas 65–68: [acceptChanges] confirma los cambios en la base de datos: un [update], un [insert] y un [delete], todos ejecutados dentro de una transacción que se confirma al final. Para cada fila modificada, la implementación del JDK verifica que la fila de la base de datos no haya sido modificada por otra persona desde que se leyó (una verificación “optimista”); de lo contrario, lanza una [SyncProviderException]. La versión sin parámetros de [acceptChanges] abre ella misma la conexión, pero la deja en modo autocommit y luego llama a [commit], algo que Connector/J rechaza; por eso se le pasa una conexión que ha salido del modo autocommit;
- línea 70: la base de datos se ha modificado (líneas 12–18 de los resultados).
[CachedRowSet] tiene la ventaja de ser una API estándar derivada del JDK, pero sus limitaciones son evidentes: manipula filas y números de columna, no objetos de negocio; las modificaciones las realiza una implementación cuyo SQL no comprendemos del todo. Por eso hoy se utiliza poco: trabajar con objetos en memoria y guardar después los cambios es el dominio de los frameworks ORM como Hibernate (capítulo 11).
10.11. Aplicación de ejemplo: versión 6
Retomaremos la aplicación de ejemplo [Tax]. La última versión, la versión 5, se trató en el capítulo 6. Era una aplicación de tres capas cuya capa [dao] obtenía sus datos de un archivo de texto, de un archivo JSON o de su propio código, y cuyas capas estaban integradas por el contenedor de inyección de dependencias de Spring. Escribimos una nueva capa [dao], que obtiene sus datos de una base de datos, MySQL:

Reutilizamos tal cual los módulos de la versión 5, mediante dependencias de Maven, y escribimos solo lo nuevo: la capa [dao] y el programa que integra las capas.
10.11.1. La base de datos
Los tramos del impuesto se almacenan en la tabla [brackets] de la base de datos MySQL [dbtaxes], creada por el script [sql/dbtaxes.sql]:
- líneas 13–18: la tabla [brackets] tiene cuatro columnas: la clave primaria [id], generada por el SGBD, seguida de las tres columnas [limits], [coeffr] y [coeffn], que representan un tramo del impuesto de tipo [DECIMAL]: son importes y coeficientes que deben ser exactos. Se leerán en Java como [BigDecimal], el tipo de los campos del record [TaxBracket];
- líneas 19–26: los siete tramos de la escala del impuesto de 2004 sobre los ingresos de 2003, utilizada desde el comienzo del curso (se trata de un ejercicio: la escala no está actualizada). Los tramos se listan en orden ascendente de sus umbrales, y la columna [id] refleja este orden;
- líneas 29–30: creación de un usuario MySQL [admtaxes], con la contraseña [pwdtaxes], a quien se le otorgan todos los permisos ([GRANT ALL PRIVILEGES]) sobre todos los objetos de la base de datos [dbtaxes] ([dbtaxes.*]), y únicamente sobre esos objetos. La aplicación se ejecutará con este usuario y no con el administrador [root]: si la contraseña del administrador llegara a verse comprometida, solo la base de datos [dbtaxes] estaría en riesgo. [IF NOT EXISTS] permite ejecutar el script varias veces.
El administrador ejecuta el script:
luego verificamos que el usuario [admtaxes] tiene acceso a los tramos (la opción [-p] sola solicita la contraseña, que no se muestra al escribirla):
10.11.2. El proyecto TaxV6
La versión 6 es un proyecto Maven formado por dos módulos, ubicados en la carpeta [10-jdbc/TaxV6], que utiliza tres módulos de la versión 5:
Los módulos de la versión 5 no forman parte del proyecto [TaxV6]: son dependencias, como el controlador JDBC o Spring. Para que Maven los encuentre, primero hay que instalarlos en el repositorio local de Maven (la carpeta [.m2/repository] del directorio personal del usuario), donde Maven almacena todas las bibliotecas que descarga. Esto es lo que hace el comando [mvn install], que se escribe una sola vez en la carpeta de la versión 5:
Compila los tres módulos, ejecuta sus pruebas, crea sus archivos [tax-dao-5.0.jar], [tax-business-5.0.jar] y [tax-ui-5.0.jar], y los copia, junto con el [pom.xml] del proyecto padre, en el repositorio local con los identificadores [examples.tax:tax-dao:5.0], [examples.tax:tax-business:5.0] y [examples.tax:tax-ui:5.0]. Cualquier proyecto Maven de la máquina puede entonces usarlos igual que cualquier biblioteca de Maven Central.
Esto demuestra el valor de una arquitectura en capas. Las capas [business] y [ui] solo conocen la interfaz [ITaxDao], definida en el módulo [tax-dao] de la versión 5; la nueva capa [dao] implementa esta interfaz en un módulo nuevo. No se modifica ninguna línea de código de la versión 5, y ni siquiera se recompilan sus archivos fuente.
El [pom.xml] del proyecto padre es el siguiente:
- líneas 8–11: el proyecto padre, empaquetado [pom]: no produce un archivo; agrupa módulos y les proporciona una configuración común;
- líneas 14–17: los dos módulos del proyecto;
- líneas 25–65: la sección [dependencyManagement] especifica las versiones de las dependencias de los módulos, que luego se declaran sin versión:
- líneas 28–42: los tres módulos de la versión 5, instalados en el repositorio local mediante [mvn install];
- líneas 44–48: el nuevo módulo [dao], del que depende el módulo [ui];
- líneas 49–63: el controlador JDBC para MySQL, Spring y JUnit;
- líneas 67–93: la configuración común de los plugins de compilación, pruebas y ejecución.
10.11.3. La capa [dao]
El archivo [pom.xml] del módulo [tax-dao-mysql] es el siguiente:
- líneas 8–12: el proyecto padre;
- líneas 18–21: el módulo [tax-dao] de la versión 5, que contiene las entidades ([TaxBracket], [TaxException]) y la interfaz [ITaxDao];
- líneas 23–27: el controlador JDBC para MySQL, con el alcance ([scope]) [runtime]: no se usa en tiempo de compilación, pero está presente en tiempo de ejecución y durante las pruebas. Esto ofrece una garantía: si el código usara por error una clase del controlador, no compilaría. La capa [dao] depende solo de JDBC;
- líneas 29–38: solo para pruebas (alcance [test]), la capa [business] de la versión 5 y JUnit.
La clase [MySqlTax] implementa la interfaz [ITaxDao]:
- línea 1: la clase está en el paquete [tax.dao], como las demás implementaciones de [ITaxDao], aunque se encuentra en un archivo distinto;
- línea 15: la clase [MySqlTax] implementa la interfaz [ITaxDao] de la versión 5: un método [getTaxBrackets] que devuelve la lista de tramos (línea 54);
- línea 18: códigos de error propios de esta implementación, siguiendo el modelo de los de [FileTax] y [JsonTax]: 101 para un error de acceso a la base de datos, 102 para datos incorrectos;
- línea 21: la consulta que devuelve los tramos. La cláusula [order by id] es importante: la capa [business] espera los tramos en orden ascendente de sus límites, y un [select] sin [order by] devuelve las filas en un orden que SQL no garantiza;
- líneas 27–29: un constructor que usa la consulta predeterminada, llamando al otro constructor mediante [this(…)];
- línea 32: el constructor recibe los parámetros de conexión y la consulta. Los tramos se leen una vez y para siempre dentro del constructor: la capa [dao] es un singleton en la aplicación, y la base de datos no vuelve a consultarse después. Por lo tanto, basta una conexión abierta por [DriverManager] ; un pool de conexiones no serviría de nada;
- líneas 34–36: la conexión, la consulta SQL y el resultado, como en los ejemplos anteriores;
- líneas 38–40: cada fila del resultado se convierte en un objeto [TaxBracket], construido por el método [readBracket];
- líneas 41–44: un error de acceso a la base de datos se encapsula en una [TaxException] con el código [ACCESS], igual que [FileTax] y [JsonTax] hacían con los errores de entrada/salida. [TaxException] es una excepción no verificada: la capa [ui] no necesita conocer las [SQLException], que son excepciones verificadas de JDBC;
- líneas 46–48: una tabla vacía es un error de datos;
- línea 50: la lista se hace de solo lectura mediante [List.copyOf] (Java 10);
- líneas 59–72: lectura de un tramo:
- líneas 61–63: [getBigDecimal(i)] lee la columna n.º i como un [BigDecimal];
- líneas 64–66: una columna con el valor [NULL] produce un [BigDecimal] [null]: es un error de datos;
- líneas 68–71: una consulta que devuelve menos de tres columnas, o una columna no numérica, produce una [SQLException] en [getBigDecimal]: también es un error de datos. La [TaxException] lanzada en la línea 65 no es una [SQLException]: atraviesa la cláusula [catch] de la línea 68 sin ser interceptada, y luego la de la línea 41; el bloque
try-with-resourcesdel constructor cierra de todos modos la conexión.
Observe que el nombre de la clase es el único lugar donde aparece MySQL: el código solo utiliza las interfaces de [java.sql]. Volveremos sobre esto.
10.11.4. Pruebas de la capa [dao]
Las pruebas de la capa [dao] se encuentran en la carpeta [src/test/java] del módulo:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 | |
- líneas 22–24: las pruebas utilizan la base de datos [dbtaxes], que debe haber sido creada con el script [dbtaxes.sql]. Por lo tanto, ya no son pruebas unitarias en sentido estricto —que probarían una clase de forma aislada—, sino pruebas de integración: verifican el funcionamiento de la capa [dao] con el SGBD. Para estas pruebas, a menudo se usa una base de datos H2 en memoria, creada al inicio de las pruebas, o una instancia de SGBD lanzada en un contenedor Docker mediante la biblioteca Testcontainers; aquí simplemente usaremos la base de datos MySQL de la máquina;
- líneas 28–40: los registros leídos de la base de datos son los de la versión “codificada en el código” [HardwiredTax]… ¡pero no en el sentido de [equals] (línea 32)! El método [equals] de un record compara sus campos con el método [equals] de cada uno, y el método [BigDecimal] compara el valor y la escala (el número de decimales): los valores [BigDecimal] leídos de la base de datos tienen dos decimales ([4962.00]), al igual que la columna [DECIMAL(10,2)], mientras que los de [HardwiredTax] no tienen ninguno ([4962]). [compareTo], en cambio, compara solo los valores (líneas 35–39). Es una trampa clásica de [BigDecimal] (capítulo 3);
- líneas 43–52: la capa [business] de la versión 5 calcula los impuestos esperados usando la nueva capa [dao]. [@CsvSource] proporciona los parámetros de las tres ejecuciones de la prueba;
- líneas 55–61: una base de datos inexistente provoca una [TaxException] con el código [ACCESS], que encapsula la [SQLException] original ([assertInstanceOf] acepta una clase derivada);
- líneas 64–69: lo mismo ocurre con una contraseña incorrecta;
- líneas 72–77: un servidor inaccesible (ningún servidor escucha en el puerto 3399) también provoca un error de acceso;
- los métodos [incorrectQuery] (línea 81), [noBracket] (línea 89) y [nullValue] (línea 98): una consulta que devuelve solo dos columnas, no devuelve filas o tiene una columna con el valor [NULL] provoca una [TaxException] con el código [DATA].
Las pruebas se ejecutan con [mvn test] en la carpeta del módulo (o con [mvn install] en la carpeta [TaxV6], que también ejecuta las pruebas). Maven muestra solo el resumen; el script del IDE y el lanzador de JUnit en modo consola muestran el siguiente árbol (el resumen que sigue al árbol está abreviado):
10.11.5. Integración de las capas
El módulo [tax-ui-mysql] contiene el programa que integra las capas. Su archivo [pom.xml] es el siguiente:
- líneas 18–21: la nueva capa [dao]. Por transitividad, el controlador JDBC para MySQL —una dependencia de alcance [runtime] en este módulo— forma parte de las bibliotecas de la aplicación;
- líneas 23–30: las capas [business] y [ui] de la versión 5. El módulo [tax-ui] contiene el programa principal de la versión 5, pero solo utilizamos su clase pública [Dialog];
- líneas 32–35: el contenedor de inyección de dependencias de Spring, como en la versión 5;
- líneas 41–47: la clase ejecutada por [mvn exec:java].
El archivo de configuración [tax.properties] es el siguiente:
- línea 2: la implementación de la capa [dao];
- líneas 3–5: la URL JDBC de la base de datos [dbtaxes] y las credenciales del usuario [admtaxes];
- línea 6: la consulta que devuelve los tramos. Incluirla en la configuración permite usar una base de datos distinta —incluso una con tablas o columnas de nombres diferentes— sin modificar el código.
La clase [Main] es la de la versión 5, salvo por el record de la capa [dao]:
- línea 1: la clase está en un paquete propio de la versión 6, [tax.ui.mysql], para evitar confusiones con la clase [tax.ui.Main] de la versión 5, que también está presente en el classpath;
- línea 22: el archivo de configuración, [tax.properties] de forma predeterminada, o el que se pasa como argumento;
- líneas 28–31: lectura del archivo de propiedades desde el directorio actual;
- líneas 32–39: los parámetros de la capa [dao]. La ausencia de URL es un error; la consulta tiene un valor predeterminado;
- líneas 44–49: la capa [dao] se registra en el contenedor de Spring bajo la interfaz [ITaxDao], con un [Supplier] que la crea según la configuración: un [MySqlTax] (línea 45) o, a modo de comparación, la versión “codificada en el código” de la versión 5 (línea 46). Las implementaciones [FileTax] y [JsonTax] de la versión 5 podrían agregarse de la misma manera: están en el classpath;
- línea 51: la capa [business] de la versión 5;
- línea 54: cuando el contenedor arranca, crea la capa [dao] y, por lo tanto, lee la base de datos, seguida de la capa [business];
- líneas 56–61: un error de configuración o de acceso a la base de datos lo muestra el método [displayError] de la versión 5, y el programa termina;
- línea 64: el cuadro de diálogo de la versión 5, sin cambios.
Para ejecutar la aplicación, primero se instalan los módulos de la versión 6 en el repositorio local (la capa [dao] debe estar disponible para el módulo [tax-ui-mysql]), y luego se ejecuta el programa desde la carpeta [tax-ui-mysql], que contiene los archivos de configuración:
Ejecución con el archivo [tax.properties]:
Los valores de referencia del curso son los siguientes: 4282 euros para una pareja con dos hijos, 2959 euros para una pareja con tres hijos y 11 519 euros para una persona sin hijos, con un salario anual de 60 000 euros.
Con el archivo [tax-base.properties], donde la URL se refiere a una base de datos [dbtaxesunknown]:
- líneas 2–3: un mensaje de registro de Spring escrito en la salida de error: el contenedor informa de que falló la creación de la capa [dao]. Esto ya ocurría en la versión 5;
- líneas 6–10: la cadena de excepciones mostrada por [Dialog.displayError]: el contenedor de Spring envolvió la excepción [TaxException] lanzada por la capa [dao] —que a su vez envuelve la excepción [SQLException] del controlador— en una excepción [BeanCreationException]. El usuario [admtaxes] solo tiene permisos sobre la base de datos [dbtaxes]: MySQL deniega el acceso a cualquier otra base de datos, exista o no (línea 10).
Con el archivo [tax-password.properties], que tiene una contraseña incorrecta:
Con el archivo [tax-server.properties], donde la URL especifica el puerto 3399, en el que no escucha ningún servidor (esto es lo que ocurriría si el servidor MySQL estuviera detenido):
La cadena de excepciones muestra aquí que la propia excepción del controlador encapsula otras excepciones, hasta llegar a la excepción de red [ConnectException]: se rechazó la conexión.
Con el archivo [tax-query.properties], cuya consulta solicita solo las columnas [limits] y [coeffr]:
En todos los casos, la capa [dao] encapsuló la excepción original en una [TaxException], que muestra el método [Dialog.displayError] de la versión 5, y el programa termina.
10.11.6. Cambiar de base de datos
La capa [dao] [MySqlTax] utiliza solo las interfaces de JDBC: a pesar de su nombre, no es específica de MySQL (un nombre como [JdbcTax] sería más apropiado). Para usar una base de datos PostgreSQL (o SQL Server, u Oracle), bastaría con:
- crear la tabla de tramos en una base de datos PostgreSQL —por ejemplo, una tabla llamada [data] con las columnas [data1], [data2] y [data3], para resaltar la ventaja de colocar la consulta en la configuración;
- agregar al [pom.xml] del módulo [tax-ui-mysql] la dependencia del controlador JDBC de PostgreSQL, [org.postgresql:postgresql] (o [com.microsoft.sqlserver:mssql-jdbc], [com.oracle.database.jdbc:ojdbc11]), con alcance [runtime];
- escribir un archivo de configuración similar a [tax.properties], como el archivo [tax-postgresql.properties] del módulo:
En la máquina utilizada para escribir este curso solo está instalado MySQL: no implementamos esta configuración. Las capas [business] y [ui], la clase [MySqlTax] y el programa [Main] no necesitan modificarse: solo cambian la configuración y el controlador en el classpath. Observe que la consulta de [MySqlTax] no tiene parámetros y utiliza solo SQL estándar: esto es lo que permite que cualquier SGBD la ejecute. Una capa [dao] con más funciones (búsquedas, actualizaciones) tropezaría rápidamente con las características específicas de cada SQL, como vimos antes: ahí es donde un ORM como Hibernate toma el relevo.
10.12. Conclusión
Este capítulo ha tratado el acceso a bases de datos mediante JDBC:
- JDBC es un conjunto de interfaces ([Connection], [Statement], [PreparedStatement], [ResultSet], [DataSource]…), de los paquetes [java.sql] y [javax.sql] , implementadas por un controlador propio de cada SGBD (MySQL Connector/J para MySQL), que [DriverManager] selecciona a partir de la URL JDBC de la base de datos;
- una conexión se abre lo más tarde posible y se cierra lo más pronto posible, mediante una instrucción
**try-with-resources; un pool de conexiones como HikariCP, a través de la interfaz [DataSource], hace rentable esta práctica; - [executeQuery] ejecuta un [select] y devuelve un [ResultSet], que se recorre fila por fila con [next], leyendo las columnas, numeradas a partir de 1, con los métodos [getXxx]; [executeUpdate] ejecuta un [insert], [update], o [delete] y devuelve el número de filas modificadas;
- los errores son [SQLException], excepciones verificadas, que devuelven un código de error propio del SGBD y un código SQLSTATE estandarizado;
- los valores externos siempre se pasan mediante los parámetros de un [PreparedStatement] y nunca se concatenan con el texto de la consulta, lo que protege contra la inyección SQL;
- las transacciones ([setAutoCommit(false)], [commit], [rollback], puntos de restauración) hacen atómica una secuencia de comandos SQL;
- JDBC es bloqueante: los hilos virtuales de Java 21 permiten atender a muchos usuarios con código JDBC estándar, dentro de los límites del tamaño del pool; los lotes ([addBatch], [executeBatch]) reducen el número de intercambios con el servidor;
- existe un modo desconectado ([CachedRowSet]), pero trabajar con objetos en memoria es hoy el dominio de los ORM.
La versión 6 de la aplicación [Tax] demostró que, gracias a la arquitectura en capas, pasar de un archivo a una base de datos solo requiere escribir una nueva capa [dao] y modificar la configuración. El próximo capítulo creará una séptima versión de esta capa usando Hibernate, que genera por sí mismo los comandos SQL.
Para saber más:
- el tutorial de JDBC de Oracle: JDBC Database Access (escrito para Java 8, pero la API apenas ha cambiado desde entonces);
- la documentación de MySQL Connector/J: MySQL Connector/J Developer Guide;
- la documentación de HikariCP: HikariCP;
- la inyección SQL, explicada por OWASP: SQL Injection Prevention Cheat Sheet.