Skip to content

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í:

Image

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]:

-- creación de la base de datos [dbarticles] y de su tabla [articles]
-- ejecución: mysql -uroot < dbarticles.sql

-- el script está escrito en UTF-8
SET NAMES utf8mb4;

-- la base de datos se vuelve a crear en cada ejecución del script
DROP DATABASE IF EXISTS dbarticles;
CREATE DATABASE dbarticles CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;

-- elección de la base de datos actual
USE dbarticles;

-- creación de la tabla articles
CREATE TABLE articles (
    ID            INT PRIMARY KEY AUTO_INCREMENT,
    NAME          VARCHAR(30) NOT NULL,
    PRICE         DECIMAL(10,2) NOT NULL,
    CURRENTSTOCK  INT NOT NULL,
    MINIMUMSTOCK  INT NOT NULL,
    -- restricciones de integridad
    CONSTRAINT UNQ_NAME UNIQUE (NAME),
    CONSTRAINT CHK_NAME CHECK (NAME <> ''),
    CONSTRAINT CHK_PRICE CHECK (PRICE > 0),
    CONSTRAINT CHK_CURRENTSTOCK CHECK (CURRENTSTOCK >= 0),
    CONSTRAINT CHK_MINIMUMSTOCK CHECK (MINIMUMSTOCK >= 0)
);

-- inserción de datos en la tabla
INSERT INTO articles (NAME, PRICE, CURRENTSTOCK, MINIMUMSTOCK) VALUES
    ('bike', 500, 10, 5),
    ('pump', 10, 10, 2),
    ('bow', 600, 4, 1),
    ('arrows - set of 6', 100, 12, 20),
    ('diving suit', 300, 8, 2),
    ('diver''s oxygen tanks', 120, 10, 5);
  • 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á):

> mysql -uroot < dbarticles.sql

El comando no muestra nada si todo va bien. Puede comprobar la estructura y el contenido de la tabla con el mismo cliente:

> mysql -uroot --default-character-set=utf8mb4 -t dbarticles -e "describe articles; select * from articles"
+--------------+---------------+------+-----+---------+----------------+
| Field        | Type          | Null | Key | Default | Extra          |
+--------------+---------------+------+-----+---------+----------------+
| ID           | int           | NO   | PRI | NULL    | auto_increment |
| NAME         | varchar(30)   | NO   | UNI | NULL    |                |
| PRICE        | decimal(10,2) | NO   |     | NULL    |                |
| CURRENTSTOCK | int           | NO   |     | NULL    |                |
| MINIMUMSTOCK | int           | NO   |     | NULL    |                |
+--------------+---------------+------+-----+---------+----------------+
+----+----------------------+--------+--------------+--------------+
| ID | NAME                 | PRICE  | CURRENTSTOCK | MINIMUMSTOCK |
+----+----------------------+--------+--------------+--------------+
|  1 | bike                 | 500.00 |           10 |            5 |
|  2 | pump                 |  10.00 |           10 |            2 |
|  3 | bow                  | 600.00 |            4 |            1 |
|  4 | arrows - set of 6    | 100.00 |           12 |           20 |
|  5 | diving suit          | 300.00 |            8 |            2 |
|  6 | diver's oxygen tanks | 120.00 |           10 |            5 |
+----+----------------------+--------+--------------+--------------+
  • 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:

> mvn -q compile exec:java
JDBC URL of the database: [jdbc:mysql://localhost:3306/dbarticles], user: [root]

SQL query (nothing to stop): select id,name,price,currentstock,minimumstock from articles

---------------------------------------
id,name,price,currentstock,minimumstock
---------------------------------------

1 bike 500.00 10 5 
2 pump 10.00 10 2 
3 bow 600.00 4 1 
4 arrows - set of 6 100.00 12 20 
5 diving suit 300.00 8 2 
6 diver's oxygen tanks 120.00 10 5 

SQL query (nothing to stop): insert into articles(name,price,currentstock,minimumstock) values('x',100,10,1)
There were 1 row(s) modified

SQL query (nothing to stop): select * from articles

---------------------------------------
ID,NAME,PRICE,CURRENTSTOCK,MINIMUMSTOCK
---------------------------------------

1 bike 500.00 10 5 
2 pump 10.00 10 2 
3 bow 600.00 4 1 
4 arrows - set of 6 100.00 12 20 
5 diving suit 300.00 8 2 
6 diver's oxygen tanks 120.00 10 5 
7 x 100.00 10 1 

SQL query (nothing to stop): update articles set price=price*1.1 where name='x'
There were 1 row(s) modified

SQL query (nothing to stop): select id,name,price from articles where name='x'

-------------
id,name,price
-------------

7 x 110.00 

SQL query (nothing to stop): delete from articles where name='x'
There were 1 row(s) modified

SQL query (nothing to stop): select count(*) from articles

--------
count(*)
--------

6 

SQL query (nothing to stop): selectt * from articles
Invalid query. Use select, insert, update, delete or nothing to stop

SQL query (nothing to stop): select * from article
Database access error (Table 'dbarticles.article' doesn't exist)

SQL query (nothing to stop): insert into articles(name,price,currentstock,minimumstock) values('bike',100,10,1)
Database access error (Duplicate entry 'bike' for key 'articles.UNQ_NAME')

SQL query (nothing to stop): 
  • 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:

Image

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):

1
2
3
        Connection connection = DriverManager.getConnection(URL, "root", "");
        // ... trabajo con la conexión
        connection.close();

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:

        // apertura de la conexión
        Connection connection = DriverManager.getConnection(URL, "root", "");
        // creación de una sentencia SQL
        Statement statement = connection.createStatement();
        // ejecución de una sentencia select
        ResultSet result = statement.executeQuery("select ...");
        // ...
        // ejecución de una sentencia update, insert, delete
        int nbInsertedRows = statement.executeUpdate("insert ...");
        // ...
        // cierre de la conexión
        connection.close();

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:

        // apertura de la conexión
        Connection connection = DriverManager.getConnection(URL, "root", "");
        // ejecución de la sentencia select
        Statement statement = connection.createStatement();
        ResultSet result = statement.executeQuery("select ...");
        // uso de los resultados
        while (result.next()) {
            // usar la fila actual
            // ...
        }
        // cierre del resultado, de la sentencia y de la conexión
        result.close();
        statement.close();
        connection.close();

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:

        Connection connection = null;
        try {
            // apertura de la conexión
            connection = DriverManager.getConnection(URL, "root", "");
            // ejecución de la sentencia select
            Statement statement = connection.createStatement();
            ResultSet result = statement.executeQuery("select ...");
            try {
                // uso de los resultados
                while (result.next()) {
                    // ...
                }
            } finally {
                // cierre del resultado
                result.close();
            }
        } catch (SQLException e) {
            // manejo de la excepción
            // ...
        } finally {
            // cierre de la conexión (que también cierra sus sentencias)
            if (connection != null) {
                try {
                    connection.close();
                } catch (SQLException e) {
                    // ya no se puede hacer nada más
                }
            }
        }

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:

        // los tres recursos se cerrarán al salir del try, sea cual sea la forma de salida
        try (Connection connection = DriverManager.getConnection(URL, "root", "");
             Statement statement = connection.createStatement();
             ResultSet result = statement.executeQuery("select ...")) {
            // uso de los resultados
            while (result.next()) {
                // ...
            }
        } catch (SQLException e) {
            // manejo de la excepción
            // ...
        }
  • 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:

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.SQLIntegrityConstraintViolationException;
import java.sql.Statement;

// manejo de los errores de acceso a la base de datos
public class Jdbc02 {

    // los parámetros de conexión, al inicio del programa
    private static final String URL = "jdbc:mysql://localhost:3306/dbarticles";
    private static final String USER = "root";
    private static final String PASSWORD = "";

    // el número del error de MySQL "Duplicate entry"
    private static final int ER_DUP_ENTRY = 1062;

    public static void main(String[] args) {
        // operaciones que fallan, cada una por una razón distinta
        execute("missing database", "jdbc:mysql://localhost:3306/dbunknown", "select * from articles");
        execute("unreachable server", "jdbc:mysql://localhost:3399/dbarticles?connectTimeout=5000",
                "select * from articles");
        execute("syntax error", URL, "select * fromm articles");
        execute("missing table", URL, "select * from article");
        execute("duplicate name", URL,
                "insert into articles(name, price, currentstock, minimumstock) values('bike', 100, 10, 1)");
        execute("negative price", URL,
                "insert into articles(name, price, currentstock, minimumstock) values('canoe', -100, 10, 1)");
    }

    // ejecuta una sentencia SQL y muestra el posible error
    private static void execute(String title, String url, String query) {
        IO.println("--- " + title);
        try (Connection connection = DriverManager.getConnection(url, USER, PASSWORD);
             Statement statement = connection.createStatement()) {
            statement.execute(query);
            IO.println("no error");
        } catch (SQLException ex) {
            switch (ex) {
                // un error específico, reconocido por su clase y su número
                case SQLIntegrityConstraintViolationException e when e.getErrorCode() == ER_DUP_ENTRY ->
                        IO.println("this article already exists (" + e.getMessage() + ")");
                // los demás errores
                default -> {
                    IO.println(ex.getClass().getSimpleName() + " : ErrorCode=" + ex.getErrorCode()
                            + ", SQLState=" + ex.getSQLState());
                    IO.println("  " + ex.getMessage().lines().findFirst().orElse(""));
                }
            }
        }
    }
}

Resultados:

> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc02
--- missing database
SQLSyntaxErrorException : ErrorCode=1049, SQLState=42000
  Unknown database 'dbunknown'
--- unreachable server
CommunicationsException : ErrorCode=0, SQLState=08S01
  Communications link failure
--- syntax error
SQLSyntaxErrorException : ErrorCode=1064, SQLState=42000
  You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'fromm articles' at line 1
--- missing table
SQLSyntaxErrorException : ErrorCode=1146, SQLState=42S02
  Table 'dbarticles.article' doesn't exist
--- duplicate name
this article already exists (Duplicate entry 'bike' for key 'articles.UNQ_NAME')
--- negative price
SQLException : ErrorCode=3819, SQLState=HY000
  Check constraint 'CHK_PRICE' is violated.
  • 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]:

10-jdbc/
  sql/
    dbarticles.sql                  creation script of the database [dbarticles]
    dbtaxes.sql                     creation script of the database [dbtaxes] (Tax application)
  jdbc/                             the Maven project of the examples
    pom.xml
    dbarticles.properties           the connection parameters read by Jdbc01
    src/main/java/jdbc/
      Article.java                  the record of a row of the table [articles]
      Jdbc01.java ... Jdbc10.java   the programs of the chapter
      Models.java                   the code patterns from the beginning of the chapter
    src/main/resources/
      logback.xml                   logging configuration
  TaxV6/                            the Tax application, version 6

Su archivo [pom.xml] es el siguiente:

<?xml version="1.0" encoding="UTF-8"?>
<!-- los ejemplos del capítulo 10: acceso a bases de datos con JDBC -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.jdbc</groupId>
    <artifactId>jdbc</artifactId>
    <version>1.0</version>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- el programa ejecutado por defecto por mvn exec:java -->
        <exec.mainClass>jdbc.Jdbc01</exec.mainClass>
    </properties>

    <dependencies>
        <!-- el controlador JDBC de MySQL -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <version>9.7.0</version>
        </dependency>
        <!-- el grupo de conexiones HikariCP -->
        <dependency>
            <groupId>com.zaxxer</groupId>
            <artifactId>HikariCP</artifactId>
            <version>7.0.2</version>
        </dependency>
        <!-- Logback: el registro de eventos (logging) que usa HikariCP (a través de SLF4J) -->
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.5.38</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.15.0</version>
                <configuration>
                    <parameters>true</parameters>
                    <compilerArgs>
                        <arg>-Xlint:all</arg>
                    </compilerArgs>
                </configuration>
            </plugin>
            <!-- mvn exec:java ejecuta la clase ${exec.mainClass} -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <mainClass>${exec.mainClass}</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • 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:

<?xml version="1.0" encoding="UTF-8"?>
<!-- configuración de Logback: solo se muestran advertencias y errores -->
<configuration>
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%-5level %logger{0} - %msg%n</pattern>
        </encoder>
    </appender>
    <root level="WARN">
        <appender-ref ref="CONSOLE"/>
    </root>
</configuration>
  • 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:

1
2
3
4
# parámetros de conexión de la base de datos [dbarticles]
url=jdbc:mysql://localhost:3306/dbarticles
user=root
password=
  • 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&param2=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:

> mvn -q compile exec:java
> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc02

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):

package jdbc;

import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
import java.util.Set;

// aplicación de consola: ejecuta sentencias SQL escritas por teclado
// sobre una base de datos cuyos parámetros de conexión se leen de un archivo de configuración
public class Jdbc01 {

    // las sentencias SQL aceptadas
    private static final Set<String> SQL_COMMANDS = Set.of("select", "insert", "update", "delete");

    public static void main(String[] args) {
        // lectura de los parámetros de conexión desde [dbarticles.properties] (carpeta actual)
        Properties config = new Properties();
        try (Reader reader = Files.newBufferedReader(Path.of("dbarticles.properties"))) {
            config.load(reader);
        } catch (IOException e) {
            IO.println("Configuration error: " + e);
            return;
        }
        String url = config.getProperty("url");
        String user = config.getProperty("user", "");
        String password = config.getProperty("password", "");
        if (url == null) {
            IO.println("Configuration error: the [url] parameter is missing");
            return;
        }

        // visualización de los parámetros de conexión
        IO.println("JDBC URL of the database: [" + url + "], user: [" + user + "]");

        // bucle de entrada-ejecución de las sentencias SQL escritas por teclado
        while (true) {
            // solicitud de la consulta
            String input = IO.readln("\nSQL query (nothing to stop): ");
            String query = input == null ? "" : input.strip();
            // ¿terminado?
            if (query.isEmpty()) {
                break;
            }
            // la primera palabra de la consulta debe ser una de las cuatro sentencias aceptadas
            String firstWord = query.split("\\s+")[0].toLowerCase();
            if (!SQL_COMMANDS.contains(firstWord)) {
                IO.println("Invalid query. Use select, insert, update, delete "
                        + "or nothing to stop");
                continue;
            }
            // ejecución de la consulta
            if (firstWord.equals("select")) {
                executeSelect(url, user, password, query);
            } else {
                executeUpdate(url, user, password, query);
            }
        }
    }
  • 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:

    // ejecución de una sentencia select
    private static void executeSelect(String url, String user, String password, String query) {
        // la conexión, la sentencia SQL y el resultado se cerrarán al salir del try, en orden inverso
        try (Connection connection = DriverManager.getConnection(url, user, password);
             Statement statement = connection.createStatement();
             ResultSet result = statement.executeQuery(query)) {
            // visualización de los resultados
            displayResultSet(result);
        } catch (SQLException e) {
            IO.println("Database access error (" + e.getMessage() + ")");
        }
    }

    // visualización de las filas del resultado de un select
    private static void displayResultSet(ResultSet result) throws SQLException {
        // los nombres de las columnas, dados por los metadatos del resultado
        ResultSetMetaData metadata = result.getMetaData();
        int nbColumns = metadata.getColumnCount();
        String[] names = new String[nbColumns];
        for (int i = 1; i <= nbColumns; i++) {
            names[i - 1] = metadata.getColumnLabel(i);
        }
        String header = String.join(",", names);
        String dashes = "-".repeat(header.length());
        IO.println("\n" + dashes + "\n" + header + "\n" + dashes + "\n");
        // las filas, una tras otra
        while (result.next()) {
            StringBuilder row = new StringBuilder();
            for (int i = 1; i <= nbColumns; i++) {
                row.append(result.getObject(i)).append(' ');
            }
            IO.println(row);
        }
    }
  • 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-resources abre 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:

    // ejecución de una sentencia de actualización (insert, update, delete)
    private static void executeUpdate(String url, String user, String password, String query) {
        try (Connection connection = DriverManager.getConnection(url, user, password);
             Statement statement = connection.createStatement()) {
            // ejecución de la sentencia SQL
            int nbRows = statement.executeUpdate(query);
            // visualización del resultado
            IO.println("There were " + nbRows + " row(s) modified");
        } catch (SQLException e) {
            IO.println("Database access error (" + e.getMessage() + ")");
        }
    }

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:

Image

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:

package jdbc;

import com.mysql.cj.jdbc.MysqlDataSource;
import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import javax.sql.DataSource;

// JDBC es una abstracción: el código solo usa las interfaces de java.sql y javax.sql
// el controlador realmente usado lo elige la URL JDBC (1.er argumento)
public class Jdbc03 {

    public static void main(String[] args) {
        // la URL JDBC de la base de datos
        String url = args.length > 0 ? args[0] : "jdbc:mysql://localhost:3306/dbarticles";

        // 1 - los controladores JDBC encontrados en el classpath
        IO.println("Loaded JDBC drivers:");
        DriverManager.drivers().forEach(driver -> IO.println("  " + driver.getClass().getName()
                + " " + driver.getMajorVersion() + "." + driver.getMinorVersion()));

        // 2 - DriverManager elige el controlador que acepta la URL
        try (Connection connection = DriverManager.getConnection(url, "root", "")) {
            DatabaseMetaData metadata = connection.getMetaData();
            IO.println("DBMS: " + metadata.getDatabaseProductName() + " "
                    + metadata.getDatabaseProductVersion());
            IO.println("Driver: " + metadata.getDriverName() + " " + metadata.getDriverVersion()
                    + " (JDBC " + metadata.getJDBCMajorVersion() + "." + metadata.getJDBCMinorVersion()
                    + ")");
            displayArticles(connection);
        } catch (SQLException ex) {
            IO.println("Database access error (" + ex.getMessage() + ")");
            return;
        }

        // 3 - un origen de datos sin grupo: cada getConnection abre una conexión de red
        MysqlDataSource withoutPool = new MysqlDataSource();
        withoutPool.setURL(url);
        withoutPool.setUser("root");
        withoutPool.setPassword("");
        measure("MysqlDataSource (without pool)", withoutPool);

        // 4 - un origen de datos con un grupo de conexiones HikariCP
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(url);
        config.setUsername("root");
        config.setPassword("");
        config.setMaximumPoolSize(5);
        try (HikariDataSource withPool = new HikariDataSource(config)) {
            measure("HikariDataSource (pool)", withPool);
        }
    }

    // una consulta parametrizada ejecutada solo a través de las interfaces JDBC
    private static void displayArticles(Connection connection) throws SQLException {
        try (PreparedStatement statement = connection.prepareStatement(
                "select id, name, price from articles where price > ?")) {
            statement.setInt(1, 200);
            try (ResultSet result = statement.executeQuery()) {
                IO.println("Created objects: " + connection.getClass().getSimpleName() + ", "
                        + statement.getClass().getSimpleName() + ", " + result.getClass().getSimpleName());
                while (result.next()) {
                    IO.println("  " + result.getInt(1) + " " + result.getString(2) + " "
                            + result.getBigDecimal(3));
                }
            }
        }
    }

    // 100 aperturas / cierres de conexiones obtenidas de un origen de datos
    private static void measure(String title, DataSource source) {
        long start = System.nanoTime();
        String className = "";
        try {
            for (int i = 0; i < 100; i++) {
                try (Connection connection = source.getConnection()) {
                    className = connection.getClass().getSimpleName();
                }
            }
            long duration = (System.nanoTime() - start) / 1_000_000;
            IO.println(title + ": 100 connections " + className + " in " + duration + " ms");
        } catch (SQLException ex) {
            IO.println("Database access error (" + ex.getMessage() + ")");
        }
    }
}

Resultados con la URL de MySQL (valor predeterminado):

> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc03
Loaded JDBC drivers:
  com.mysql.cj.jdbc.Driver 9.7
DBMS: MySQL 8.0.46-0ubuntu0.24.04.4
Driver: MySQL Connector/J mysql-connector-j-9.7.0 (Revision: 0aade1f13bcc98faf7dda5c02e782481eb291f62) (JDBC 4.2)
Created objects: ConnectionImpl, ClientPreparedStatement, ResultSetImpl
  1 bike 500.00
  3 bow 600.00
  5 diving suit 300.00
MysqlDataSource (without pool): 100 connections ConnectionImpl in 5092 ms
HikariDataSource (pool): 100 connections HikariProxyConnection in 17 ms

Resultados con la URL de una base de datos PostgreSQL, cuyo controlador no está en el classpath:

1
2
3
4
> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc03 -Dexec.args="jdbc:postgresql://localhost:5432/dbarticles"
Loaded JDBC drivers:
  com.mysql.cj.jdbc.Driver 9.7
Database access error (No suitable driver found for jdbc:postgresql://localhost:5432/dbarticles)

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:

1
2
3
4
5
6
7
package jdbc;

import java.math.BigDecimal;

// un artículo: una fila de la tabla [articles]
public record Article(int id, String name, BigDecimal price, int currentStock, int minimumStock) {
}
  • 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:

package jdbc;

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

// consultas parametrizadas
public class Jdbc04 {

    private static final String URL = "jdbc:mysql://localhost:3306/dbarticles";
    private static final String USER = "root";
    private static final String PASSWORD = "";

    public static void main(String[] args) {
        IO.println("JDBC URL of the database: [" + URL + "]");

        // creación de una lista de 5 artículos
        List<Article> articles = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            articles.add(new Article(0, "article" + i, BigDecimal.valueOf(i * 100), i * 10, i));
        }

        try {
            // se eliminan los artículos existentes
            IO.println("There were " + executeUpdate("delete from articles") + " row(s) deleted");
            // se inserta la lista de artículos
            insertArticles(articles);
            // se muestran los artículos de la tabla
            getArticles("%").forEach(IO::println);
            // los artículos cuyo nombre termina en 3
            IO.println("Articles whose name ends with 3:");
            getArticles("%3").forEach(IO::println);
        } catch (SQLException ex) {
            IO.println("Database access error (" + ex.getMessage() + ")");
        }
    }

    // inserción de una lista de artículos con una consulta parametrizada
    private static void insertArticles(List<Article> articles) throws SQLException {
        // la consulta parametrizada: cada ? es un parámetro, numerado desde 1
        String query = "insert into articles(name, price, currentstock, minimumstock) values(?, ?, ?, ?)";
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement statement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS)) {
            // inserción de las filas: solo cambia el valor de los parámetros
            for (Article article : articles) {
                statement.setString(1, article.name());
                statement.setBigDecimal(2, article.price());
                statement.setInt(3, article.currentStock());
                statement.setInt(4, article.minimumStock());
                statement.executeUpdate();
                // la clave primaria generada por el SGBD
                try (ResultSet keys = statement.getGeneratedKeys()) {
                    keys.next();
                    IO.println("article [" + article.name() + "] inserted with id " + keys.getInt(1));
                }
            }
        }
    }

    // los artículos cuyo nombre coincide con el patrón [like]
    private static List<Article> getArticles(String pattern) throws SQLException {
        String query = "select id, name, price, currentstock, minimumstock from articles "
                + "where name like ? order by id";
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement statement = connection.prepareStatement(query)) {
            statement.setString(1, pattern);
            try (ResultSet result = statement.executeQuery()) {
                // cada fila del resultado se convierte en un objeto Article
                List<Article> list = new ArrayList<>();
                while (result.next()) {
                    list.add(new Article(result.getInt(1), result.getString(2),
                            result.getBigDecimal(3), result.getInt("currentstock"),
                            result.getInt("minimumstock")));
                }
                return list;
            }
        }
    }

    // ejecución de una sentencia de actualización
    private static int executeUpdate(String query) throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             Statement statement = connection.createStatement()) {
            return statement.executeUpdate(query);
        }
    }
}

Resultados:

> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc04
JDBC URL of the database: [jdbc:mysql://localhost:3306/dbarticles]
There were 6 row(s) deleted
article [article1] inserted with id 7
article [article2] inserted with id 8
article [article3] inserted with id 9
article [article4] inserted with id 10
article [article5] inserted with id 11
Article[id=7, name=article1, price=100.00, currentStock=10, minimumStock=1]
Article[id=8, name=article2, price=200.00, currentStock=20, minimumStock=2]
Article[id=9, name=article3, price=300.00, currentStock=30, minimumStock=3]
Article[id=10, name=article4, price=400.00, currentStock=40, minimumStock=4]
Article[id=11, name=article5, price=500.00, currentStock=50, minimumStock=5]
Articles whose name ends with 3:
Article[id=9, name=article3, price=300.00, currentStock=30, minimumStock=3]
  • 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:

        String query = "select id, name, price from articles where name = '" + name + "'";

(esta es la línea 30 del programa [Jdbc05] que aparece más abajo). Si el nombre es “bicicleta”, la consulta queda así:

select id, name, price from articles where name = 'bike'

Pero si el nombre es “tanques de oxígeno de buceo”, queda así:

select id, name, price from articles where name = 'diver's oxygen tanks'

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:

package jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.List;

// inyección SQL: por qué se deben usar consultas parametrizadas
public class Jdbc05 {

    private static final String URL = "jdbc:mysql://localhost:3306/dbarticles";
    private static final String USER = "root";
    private static final String PASSWORD = "";

    public static void main(String[] args) {
        // nombres de artículos, tal como podría escribirlos un usuario
        List<String> names = List.of("bike", "diver's oxygen tanks", "x' or '1'='1");

        IO.println("1 - query built by concatenation");
        names.forEach(Jdbc05::searchByConcatenation);
        IO.println("\n2 - parameterized query");
        names.forEach(Jdbc05::searchWithParameter);
    }

    // búsqueda de un artículo por su nombre: el nombre se inserta en el texto de la consulta
    private static void searchByConcatenation(String name) {
        String query = "select id, name, price from articles where name = '" + name + "'";
        IO.println("[" + name + "] -> " + query);
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             Statement statement = connection.createStatement();
             ResultSet result = statement.executeQuery(query)) {
            display(result);
        } catch (SQLException ex) {
            IO.println("   error: " + ex.getMessage());
        }
    }

    // búsqueda de un artículo por su nombre: el nombre es el valor de un parámetro
    private static void searchWithParameter(String name) {
        IO.println("[" + name + "]");
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement statement = connection.prepareStatement(
                     "select id, name, price from articles where name = ?")) {
            statement.setString(1, name);
            try (ResultSet result = statement.executeQuery()) {
                display(result);
            }
        } catch (SQLException ex) {
            IO.println("   error: " + ex.getMessage());
        }
    }

    // visualización del resultado de un select
    private static void display(ResultSet result) throws SQLException {
        int nbRows = 0;
        while (result.next()) {
            IO.println("   " + result.getInt(1) + " " + result.getString(2) + " "
                    + result.getBigDecimal(3));
            nbRows++;
        }
        IO.println("   " + nbRows + " row(s)");
    }
}

Resultados:

> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc05
1 - query built by concatenation
[bike] -> select id, name, price from articles where name = 'bike'
   1 bike 500.00
   1 row(s)
[diver's oxygen tanks] -> select id, name, price from articles where name = 'diver's oxygen tanks'
   error: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 's oxygen tanks'' at line 1
[x' or '1'='1] -> select id, name, price from articles where name = 'x' or '1'='1'
   1 bike 500.00
   2 pump 10.00
   3 bow 600.00
   4 arrows - set of 6 100.00
   5 diving suit 300.00
   6 diver's oxygen tanks 120.00
   6 row(s)

2 - parameterized query
[bike]
   1 bike 500.00
   1 row(s)
[diver's oxygen tanks]
   6 diver's oxygen tanks 120.00
   1 row(s)
[x' or '1'='1]
   0 row(s)
  • 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:

package jdbc;

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Savepoint;
import java.sql.Statement;
import java.util.List;

// transacciones
public class Jdbc06 {

    private static final String URL = "jdbc:mysql://localhost:3306/dbarticles";
    private static final String USER = "root";
    private static final String PASSWORD = "";

    public static void main(String[] args) {
        IO.println("JDBC URL of the database: [" + URL + "]");

        // dos artículos con el mismo nombre: la restricción de unicidad UNQ_NAME rechazará el segundo
        List<Article> articles = List.of(new Article(0, "article", new BigDecimal("100"), 10, 1),
                new Article(0, "article", new BigDecimal("200"), 20, 2));

        try {
            // 1 - inserción sin transacción explícita
            IO.println("\nInsertion without a transaction...");
            executeUpdate("delete from articles");
            try {
                insertArticlesOutOfTransaction(articles);
            } catch (SQLException ex) {
                IO.println("Database access error (" + ex.getMessage() + ")");
            }
            displayArticles();

            // 2 - lo mismo en una transacción
            IO.println("\nInsertion in a transaction...");
            executeUpdate("delete from articles");
            insertArticlesInTransaction(articles);
            displayArticles();

            // 3 - una transacción con un punto de guardado
            IO.println("\nInsertion in a transaction with a savepoint...");
            executeUpdate("delete from articles");
            insertArticlesWithSavepoint(articles);
            displayArticles();
        } catch (SQLException ex) {
            IO.println("Database access error (" + ex.getMessage() + ")");
        }
    }

    // inserción de una lista de artículos sin transacción explícita (modo autocommit)
    private static void insertArticlesOutOfTransaction(List<Article> articles) throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement statement = createInsertStatement(connection)) {
            for (Article article : articles) {
                insertArticle(statement, article);
            }
        }
    }

    // inserción de una lista de artículos en una transacción
    private static void insertArticlesInTransaction(List<Article> articles) throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD)) {
            // inicio de la transacción: se sale del modo autocommit
            connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
            connection.setAutoCommit(false);
            try (PreparedStatement statement = createInsertStatement(connection)) {
                for (Article article : articles) {
                    insertArticle(statement, article);
                }
                // todo salió bien: la transacción se confirma
                connection.commit();
                IO.println("transaction committed...");
            } catch (SQLException ex) {
                // una inserción falló: la transacción se revierte
                connection.rollback();
                IO.println("transaction rolled back (" + ex.getMessage() + ")");
            }
        }
    }

    // inserción en una transacción: el fallo de una inserción solo cancela lo que sigue
    // al último punto de guardado
    private static void insertArticlesWithSavepoint(List<Article> articles) throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD)) {
            connection.setAutoCommit(false);
            try (PreparedStatement statement = createInsertStatement(connection)) {
                for (Article article : articles) {
                    // un punto de guardado antes de cada inserción
                    Savepoint beforeInsertion = connection.setSavepoint();
                    try {
                        insertArticle(statement, article);
                    } catch (SQLException ex) {
                        // solo se deshace la inserción fallida
                        connection.rollback(beforeInsertion);
                        IO.println("insertion of [" + article.name() + ", " + article.price() + "] cancelled ("
                                + ex.getMessage() + ")");
                    }
                }
                connection.commit();
                IO.println("transaction committed...");
            } catch (SQLException ex) {
                connection.rollback();
                IO.println("transaction rolled back (" + ex.getMessage() + ")");
            }
        }
    }

    // la sentencia parametrizada que inserta un artículo
    private static PreparedStatement createInsertStatement(Connection connection) throws SQLException {
        return connection.prepareStatement(
                "insert into articles(name, price, currentstock, minimumstock) values(?, ?, ?, ?)");
    }

    // inserción de un artículo con la sentencia parametrizada
    private static void insertArticle(PreparedStatement statement, Article article) throws SQLException {
        statement.setString(1, article.name());
        statement.setBigDecimal(2, article.price());
        statement.setInt(3, article.currentStock());
        statement.setInt(4, article.minimumStock());
        statement.executeUpdate();
        IO.println("article [" + article.name() + ", " + article.price() + "] inserted");
    }

    // ejecución de una sentencia de actualización
    private static void executeUpdate(String query) throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             Statement statement = connection.createStatement()) {
            IO.println("There were " + statement.executeUpdate(query) + " row(s) modified");
        }
    }

    // visualización del contenido de la tabla
    private static void displayArticles() throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             Statement statement = connection.createStatement();
             ResultSet result = statement.executeQuery(
                     "select id, name, price, currentstock, minimumstock from articles")) {
            IO.println("Content of the [articles] table:");
            while (result.next()) {
                IO.println("  " + result.getInt(1) + " " + result.getString(2) + " "
                        + result.getBigDecimal(3) + " " + result.getInt(4) + " " + result.getInt(5));
            }
        }
    }
}

Resultados:

> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc06
JDBC URL of the database: [jdbc:mysql://localhost:3306/dbarticles]

Insertion without a transaction...
There were 6 row(s) modified
article [article, 100] inserted
Database access error (Duplicate entry 'article' for key 'articles.UNQ_NAME')
Content of the [articles] table:
  7 article 100.00 10 1

Insertion in a transaction...
There were 1 row(s) modified
article [article, 100] inserted
transaction rolled back (Duplicate entry 'article' for key 'articles.UNQ_NAME')
Content of the [articles] table:

Insertion in a transaction with a savepoint...
There were 0 row(s) modified
article [article, 100] inserted
insertion of [article, 200] cancelled (Duplicate entry 'article' for key 'articles.UNQ_NAME')
transaction committed...
Content of the [articles] table:
  11 article 100.00 10 1
  • 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:

package jdbc;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

// consultas que devuelven un único valor
public class Jdbc07 {

    private static final String URL = "jdbc:mysql://localhost:3306/dbarticles";
    private static final String USER = "root";
    private static final String PASSWORD = "";

    public static void main(String[] args) {
        try {
            // los valores únicos devueltos por los select, en el tipo elegido por el controlador
            Object averagePrice = singleValue("select avg(price) from articles");
            IO.println("Average price of the articles = " + averagePrice + " (type " + type(averagePrice) + ")");
            Object nbArticles = singleValue("select count(id) from articles");
            IO.println("Number of articles = " + nbArticles + " (type " + type(nbArticles) + ")");
            Object name = singleValue(
                    "select name from articles where price = (select max(price) from articles)");
            IO.println("Most expensive article = " + name + " (type " + type(name) + ")");
            Object missing = singleValue("select name from articles where price > 10000");
            IO.println("Article of more than 10000 euros: " + missing);
            Object empty = singleValue("select max(price) from articles where price > 10000");
            IO.println("Maximum price beyond 10000 euros: " + empty);

            // los mismos valores en el tipo solicitado: el controlador hace la conversión
            BigDecimal average = singleValue("select avg(price) from articles", BigDecimal.class);
            Integer number = singleValue("select count(id) from articles", Integer.class);
            IO.println("Rounded average = " + average.setScale(2, RoundingMode.HALF_UP)
                    + ", number = " + number);
            // una conversión directa falla: count devuelve un Long y no un Integer
            int n = (int) nbArticles;
            IO.println("n = " + n);
        } catch (SQLException | ClassCastException ex) {
            IO.println(ex.getClass().getSimpleName() + " : " + ex.getMessage());
        }
    }

    // ejecución de un select que devuelve un único valor: primera columna de la primera fila
    // el resultado es null si el select no devuelve ninguna fila o si el valor es NULL de SQL
    private static Object singleValue(String query) throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             Statement statement = connection.createStatement();
             ResultSet result = statement.executeQuery(query)) {
            return result.next() ? result.getObject(1) : null;
        }
    }

    // lo mismo, con el valor convertido por el controlador al tipo solicitado
    private static <T> T singleValue(String query, Class<T> type) throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             Statement statement = connection.createStatement();
             ResultSet result = statement.executeQuery(query)) {
            return result.next() ? result.getObject(1, type) : null;
        }
    }

    // el nombre simple de la clase de un objeto
    private static String type(Object object) {
        return object == null ? "null" : object.getClass().getSimpleName();
    }
}

Resultados:

1
2
3
4
5
6
7
8
> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc07
Average price of the articles = 271.666667 (type BigDecimal)
Number of articles = 6 (type Long)
Most expensive article = bow (type String)
Article of more than 10000 euros: null
Maximum price beyond 10000 euros: null
Rounded average = 271.67, number = 6
ClassCastException : class java.lang.Long cannot be cast to class java.lang.Integer (java.lang.Long and java.lang.Integer are in module java.base of loader 'bootstrap')
  • 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:

package jdbc;

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLTimeoutException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import javax.sql.DataSource;

// JDBC es bloqueante: consultas concurrentes ejecutadas por hilos virtuales
public class Jdbc08 {

    public static void main(String[] args) throws InterruptedException {
        // el origen de datos: un grupo de como máximo 4 conexiones a la base de datos [dbarticles]
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl("jdbc:mysql://localhost:3306/dbarticles");
        config.setUsername("root");
        config.setPassword("");
        config.setMaximumPoolSize(4);

        try (HikariDataSource dataSource = new HikariDataSource(config)) {
            // 1 - una sentencia de actualización, en una transacción
            try (Connection connection = dataSource.getConnection()) {
                connection.setAutoCommit(false);
                try (PreparedStatement statement = connection.prepareStatement(
                        "update articles set price = price * 1.1 where price < ?")) {
                    statement.setInt(1, 200);
                    int nbRows = statement.executeUpdate();
                    connection.commit();
                    IO.println(nbRows + " price(s) increased by 10 %");
                }
            }

            // 2 - seis consultas concurrentes, cada una en su hilo virtual
            long start = System.nanoTime();
            List<Future<Article>> tasks = new ArrayList<>();
            try (ExecutorService executor = Executors.newVirtualThreadPerTaskExecutor()) {
                for (int id = 1; id <= 6; id++) {
                    int articleId = id;
                    tasks.add(executor.submit(() -> getArticleSlowly(dataSource, articleId)));
                }
            } // el cierre del executor espera el fin de las seis tareas
            for (Future<Article> task : tasks) {
                IO.println(task.get());
            }
            IO.println("6 one-second queries executed in %.1f s with %d connections"
                    .formatted((System.nanoTime() - start) / 1e9, config.getMaximumPoolSize()));

            // 3 - un único valor
            try (Connection connection = dataSource.getConnection();
                 Statement statement = connection.createStatement();
                 ResultSet result = statement.executeQuery("select sum(price * currentstock) from articles")) {
                result.next();
                IO.println("Stock value: " + result.getBigDecimal(1) + " euros");
            }

            // 4 - una consulta bloqueada por otra transacción, abandonada tras un segundo
            // la transacción [blocking] modifica el artículo n.º 1 y no termina:
            // la fila permanece bloqueada
            try (Connection blocking = dataSource.getConnection()) {
                blocking.setAutoCommit(false);
                try (Statement statement = blocking.createStatement()) {
                    statement.executeUpdate("update articles set currentstock = currentstock - 1 where id = 1");
                }
                // otra conexión quiere modificar la misma fila: debe esperar el fin de [blocking]
                long chrono = System.nanoTime();
                try (Connection connection = dataSource.getConnection();
                     Statement statement = connection.createStatement()) {
                    statement.setQueryTimeout(1);
                    statement.executeUpdate("update articles set price = price * 2 where id = 1");
                } catch (SQLTimeoutException ex) {
                    IO.println(ex.getClass().getSimpleName() + " after "
                            + Math.round((System.nanoTime() - chrono) / 1e9) + " s: " + ex.getMessage());
                }
                // la transacción [blocking] no se confirmó: se revierte
                blocking.rollback();
            }
        } catch (SQLException | ExecutionException ex) {
            IO.println("Database access error (" + ex.getMessage() + ")");
        }
    }

    // un artículo leído por una consulta que dura un segundo (la función sleep de MySQL simula una consulta lenta)
    private static Article getArticleSlowly(DataSource dataSource, int id) throws SQLException {
        try (Connection connection = dataSource.getConnection();
             PreparedStatement statement = connection.prepareStatement("select id, name, price, currentstock, "
                     + "minimumstock, sleep(1) from articles where id = ?")) {
            statement.setInt(1, id);
            try (ResultSet result = statement.executeQuery()) {
                result.next();
                return new Article(result.getInt(1), result.getString(2), result.getBigDecimal(3),
                        result.getInt(4), result.getInt(5));
            }
        }
    }
}

Resultados:

> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc08
3 price(s) increased by 10 %
Article[id=1, name=bike, price=500.00, currentStock=10, minimumStock=5]
Article[id=2, name=pump, price=11.00, currentStock=10, minimumStock=2]
Article[id=3, name=bow, price=600.00, currentStock=4, minimumStock=1]
Article[id=4, name=arrows - set of 6, price=110.00, currentStock=12, minimumStock=20]
Article[id=5, name=diving suit, price=300.00, currentStock=8, minimumStock=2]
Article[id=6, name=diver's oxygen tanks, price=132.00, currentStock=10, minimumStock=5]
6 one-second queries executed in 2.4 s with 4 connections
Stock value: 12550.00 euros
MySQLTimeoutException after 1 s: Statement cancelled due to timeout or client request
  • 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í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:

package jdbc;

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Arrays;

// ejecución por lotes: varias sentencias SQL enviadas al SGBD en un único intercambio
public class Jdbc09 {

    private static final String URL = "jdbc:mysql://localhost:3306/dbarticles";
    private static final String USER = "root";
    private static final String PASSWORD = "";

    public static void main(String[] args) {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD)) {
            IO.println("The driver can execute batches: "
                    + connection.getMetaData().supportsBatchUpdates());

            // 1 - un lote de tres sentencias de actualización distintas
            try (Statement statement = connection.createStatement()) {
                statement.addBatch("insert into articles(name, price, currentstock, minimumstock) "
                        + "values('canoe', 800, 5, 1)");
                statement.addBatch("update articles set currentstock = currentstock + 10 "
                        + "where currentstock < minimumstock");
                statement.addBatch("delete from articles where name = 'pump'");
                int[] nbRows = statement.executeBatch();
                IO.println("Rows modified by each statement: " + Arrays.toString(nbRows)
                        + ", total: " + Arrays.stream(nbRows).sum());
            }

            // 2 - 1000 inserciones mediante un lote de la misma sentencia parametrizada, sin y luego con reescritura de lotes
            insertBatch(URL, 1000);
            insertBatch(URL + "?rewriteBatchedStatements=true", 1000);
        } catch (SQLException ex) {
            IO.println("Database access error (" + ex.getMessage() + ")");
        }

        // 3 - dos select enviados en un único intercambio: una sentencia, dos resultados sucesivos
        try (Connection connection = DriverManager.getConnection(URL + "?allowMultiQueries=true",
                USER, PASSWORD);
             Statement statement = connection.createStatement()) {
            statement.execute("select name, currentstock from articles where currentstock < minimumstock + 5;"
                    + "select count(*), sum(price * currentstock) from articles");
            IO.println("Articles to watch:");
            try (ResultSet result = statement.getResultSet()) {
                while (result.next()) {
                    IO.println("  " + result.getString(1) + " : " + result.getInt(2));
                }
            }
            // pasar al siguiente resultado
            statement.getMoreResults();
            try (ResultSet result = statement.getResultSet()) {
                result.next();
                IO.println(result.getLong(1) + " articles, stock value: " + result.getBigDecimal(2)
                        + " euros");
            }
        } catch (SQLException ex) {
            IO.println("Database access error (" + ex.getMessage() + ")");
        }
    }

    // inserción de n artículos mediante un lote, en una transacción, y luego eliminación de estos artículos
    private static void insertBatch(String url, int n) throws SQLException {
        try (Connection connection = DriverManager.getConnection(url, USER, PASSWORD)) {
            connection.setAutoCommit(false);
            long start = System.nanoTime();
            try (PreparedStatement statement = connection.prepareStatement(
                    "insert into articles(name, price, currentstock, minimumstock) values(?, ?, ?, ?)")) {
                for (int i = 1; i <= n; i++) {
                    statement.setString(1, "batch-" + i);
                    statement.setBigDecimal(2, BigDecimal.TEN);
                    statement.setInt(3, i);
                    statement.setInt(4, 0);
                    // los valores de los parámetros se agregan al lote
                    statement.addBatch();
                }
                int[] nbRows = statement.executeBatch();
                connection.commit();
                long duration = (System.nanoTime() - start) / 1_000_000;
                IO.println("%d insertions (%s) in %d ms: %s...".formatted(nbRows.length,
                        url.replaceFirst(".*/", ""), duration, Arrays.toString(Arrays.copyOf(nbRows, 3))));
            }
            // la tabla se devuelve a su estado anterior
            try (Statement statement = connection.createStatement()) {
                statement.executeUpdate("delete from articles where name like 'batch-%'");
                connection.commit();
            }
        }
    }
}

Resultados:

> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc09
The driver can execute batches: true
Rows modified by each statement: [1, 1, 1], total: 3
1000 insertions (dbarticles) in 2341 ms: [1, 1, 1]...
1000 insertions (dbarticles?rewriteBatchedStatements=true) in 207 ms: [-2, -2, -2]...
Articles to watch:
  bow : 4
  arrows - set of 6 : 22
  canoe : 5
6 articles, stock value: 17200.00 euros
  • 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:

package jdbc;

import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.rowset.CachedRowSet;
import javax.sql.rowset.RowSetFactory;
import javax.sql.rowset.RowSetProvider;

// modo desconectado: una copia en memoria de las filas, modificada sin conexión y luego enviada de vuelta a la base de datos
public class Jdbc10 {

    private static final String URL = "jdbc:mysql://localhost:3306/dbarticles";
    private static final String USER = "root";
    private static final String PASSWORD = "";

    public static void main(String[] args) {
        try {
            // la fábrica de RowSet de la plataforma Java
            RowSetFactory factory = RowSetProvider.newFactory();
            try (CachedRowSet articles = factory.createCachedRowSet()) {
                // los parámetros de conexión y la consulta
                articles.setUrl(URL);
                articles.setUsername(USER);
                articles.setPassword(PASSWORD);
                articles.setCommand("select id, name, price, currentstock, minimumstock from articles");
                // la tabla que se actualizará y su clave primaria (columna n.º 1)
                articles.setTableName("articles");
                articles.setKeyColumns(new int[]{1});
                // conexión, copia de las filas en memoria, desconexión
                articles.execute();
                IO.println(articles.size() + " rows copied into memory");

                // trabajo sin conexión: reabastecimiento de los artículos agotados
                while (articles.next()) {
                    int currentStock = articles.getInt("currentstock");
                    int minimumStock = articles.getInt("minimumstock");
                    if (currentStock < minimumStock) {
                        articles.updateInt("currentstock", minimumStock + 10);
                        articles.updateRow();
                        IO.println("[" + articles.getString("name") + "] : stock " + currentStock + " -> "
                                + articles.getInt("currentstock"));
                    }
                }
                // agregar una fila: id 0 pide a MySQL que genere uno
                articles.moveToInsertRow();
                articles.updateInt("id", 0);
                articles.updateString("name", "canoe");
                articles.updateBigDecimal("price", new BigDecimal("800"));
                articles.updateInt("currentstock", 5);
                articles.updateInt("minimumstock", 1);
                articles.insertRow();
                articles.moveToCurrentRow();
                // eliminación de la 2.ª fila
                articles.absolute(2);
                IO.println("deletion of [" + articles.getString("name") + "]");
                articles.deleteRow();

                // la base de datos aún no ha sido modificada
                displayArticles("Database before acceptChanges:");
                // conexión, envío de las modificaciones en una transacción, desconexión
                try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD)) {
                    connection.setAutoCommit(false);
                    articles.acceptChanges(connection);
                }
            }
            displayArticles("Database after acceptChanges:");
        } catch (SQLException ex) {
            IO.println("Database access error (" + ex.getMessage() + ")");
        }
    }

    // visualización del contenido de la tabla, leído en modo conectado
    private static void displayArticles(String title) throws SQLException {
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             Statement statement = connection.createStatement();
             ResultSet result = statement.executeQuery(
                     "select id, name, price, currentstock, minimumstock from articles")) {
            IO.println(title);
            while (result.next()) {
                IO.println("  " + result.getInt(1) + " " + result.getString(2) + " "
                        + result.getBigDecimal(3) + " " + result.getInt(4) + " " + result.getInt(5));
            }
        }
    }
}

Resultados:

> mvn -q compile exec:java -Dexec.mainClass=jdbc.Jdbc10
6 rows copied into memory
[arrows - set of 6] : stock 12 -> 30
deletion of [pump]
Database before acceptChanges:
  1 bike 500.00 10 5
  2 pump 10.00 10 2
  3 bow 600.00 4 1
  4 arrows - set of 6 100.00 12 20
  5 diving suit 300.00 8 2
  6 diver's oxygen tanks 120.00 10 5
Database after acceptChanges:
  1 bike 500.00 10 5
  3 bow 600.00 4 1
  4 arrows - set of 6 100.00 30 20
  5 diving suit 300.00 8 2
  6 diver's oxygen tanks 120.00 10 5
  7 canoe 800.00 5 1
  • 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:

Image

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]:

-- creación de la base de datos [dbtaxes] de la aplicación [Tax] (versión 6)
-- ejecución: mysql -uroot < dbtaxes.sql

-- el script está escrito en UTF-8
SET NAMES utf8mb4;

-- la base de datos se vuelve a crear en cada ejecución del script
DROP DATABASE IF EXISTS dbtaxes;
CREATE DATABASE dbtaxes CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
USE dbtaxes;

-- la tabla de los tramos del impuesto (escala de 2004 sobre los ingresos de 2003)
CREATE TABLE brackets (
    id      INT PRIMARY KEY AUTO_INCREMENT,
    limits  DECIMAL(10,2) NOT NULL,
    coeffr  DECIMAL(6,3) NOT NULL,
    coeffn  DECIMAL(10,2) NOT NULL
);
INSERT INTO brackets (limits, coeffr, coeffn) VALUES
    (4962, 0, 0),
    (8382, 0.068, 291.09),
    (14753, 0.191, 1322.92),
    (23888, 0.283, 2668.39),
    (38868, 0.374, 4846.98),
    (47932, 0.426, 6883.66),
    (0, 0.481, 9505.54);

-- un usuario propio de la aplicación, que solo tiene derechos sobre la base de datos [dbtaxes]
CREATE USER IF NOT EXISTS 'admtaxes'@'localhost' IDENTIFIED BY 'pwdtaxes';
GRANT ALL PRIVILEGES ON dbtaxes.* TO 'admtaxes'@'localhost';
  • 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:

> mysql -uroot < dbtaxes.sql

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):

> mysql -uadmtaxes -p -t dbtaxes -e "select * from brackets"
Enter password: 
+----+----------+--------+---------+
| id | limits   | coeffr | coeffn  |
+----+----------+--------+---------+
|  1 |  4962.00 |  0.000 |    0.00 |
|  2 |  8382.00 |  0.068 |  291.09 |
|  3 | 14753.00 |  0.191 | 1322.92 |
|  4 | 23888.00 |  0.283 | 2668.39 |
|  5 | 38868.00 |  0.374 | 4846.98 |
|  6 | 47932.00 |  0.426 | 6883.66 |
|  7 |     0.00 |  0.481 | 9505.54 |
+----+----------+--------+---------+

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:

java-oct-2026/
  06-architectures/TaxV5/               version 5, reused
    pom.xml                             parent project tax-v5
    tax-dao/                            entities, interface ITaxDao, implementations of version 5
    tax-business/                       layer [business]
    tax-ui/                             layer [ui] (class Dialog) and program of version 5
  10-jdbc/
    sql/
      dbtaxes.sql                       creation script of the database
    TaxV6/
      pom.xml                           parent project tax-v6
      tax-dao-mysql/                    the new layer [dao]
        pom.xml
        src/main/java/tax/dao/
          MySqlTax.java
        src/test/java/tax/dao/
          MySqlTaxTests.java            JUnit tests of the new layer [dao]
      tax-ui-mysql/                     integration of the layers
        pom.xml
        tax.properties
        tax-base.properties
        tax-password.properties
        tax-server.properties
        tax-query.properties
        tax-postgresql.properties
        src/main/java/tax/ui/mysql/
          Main.java

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:

> cd 06-architectures/TaxV5
> mvn install

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:

<?xml version="1.0" encoding="UTF-8"?>
<!-- proyecto padre de la aplicación [Tax], versión 6: la capa [dao] lee una base de datos -->
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>examples.tax</groupId>
    <artifactId>tax-v6</artifactId>
    <version>6.0</version>
    <packaging>pom</packaging>

    <!-- los dos nuevos módulos; los de la versión 5 son dependencias -->
    <modules>
        <module>tax-dao-mysql</module>
        <module>tax-ui-mysql</module>
    </modules>

    <properties>
        <maven.compiler.release>25</maven.compiler.release>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <!-- las versiones de las bibliotecas, comunes a todos los módulos -->
    <dependencyManagement>
        <dependencies>
            <!-- los módulos de la versión 5, instalados en el repositorio Maven local mediante [mvn install] -->
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-dao</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-business</artifactId>
                <version>5.0</version>
            </dependency>
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-ui</artifactId>
                <version>5.0</version>
            </dependency>
            <!-- el nuevo módulo [dao] -->
            <dependency>
                <groupId>examples.tax</groupId>
                <artifactId>tax-dao-mysql</artifactId>
                <version>6.0</version>
            </dependency>
            <dependency>
                <groupId>com.mysql</groupId>
                <artifactId>mysql-connector-j</artifactId>
                <version>9.7.0</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>7.0.9</version>
            </dependency>
            <dependency>
                <groupId>org.junit.jupiter</groupId>
                <artifactId>junit-jupiter</artifactId>
                <version>6.0.3</version>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <build>
        <pluginManagement>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-compiler-plugin</artifactId>
                    <version>3.15.0</version>
                    <configuration>
                        <parameters>true</parameters>
                        <compilerArgs>
                            <arg>-Xlint:all</arg>
                        </compilerArgs>
                    </configuration>
                </plugin>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-surefire-plugin</artifactId>
                    <version>3.5.6</version>
                </plugin>
                <plugin>
                    <groupId>org.codehaus.mojo</groupId>
                    <artifactId>exec-maven-plugin</artifactId>
                    <version>3.5.1</version>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>
  • 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:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- el proyecto padre proporciona las versiones y la configuración comunes -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v6</artifactId>
        <version>6.0</version>
    </parent>

    <artifactId>tax-dao-mysql</artifactId>

    <dependencies>
        <!-- las entidades y la interfaz ITaxDao de la versión 5 -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-dao</artifactId>
        </dependency>
        <!-- el controlador JDBC de MySQL: el código solo lo usa en tiempo de ejecución -->
        <dependency>
            <groupId>com.mysql</groupId>
            <artifactId>mysql-connector-j</artifactId>
            <scope>runtime</scope>
        </dependency>
        <!-- para las pruebas: la capa [business] de la versión 5 y JUnit -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-business</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>
  • 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]:

package tax.dao;

import tax.entities.TaxException;
import tax.entities.TaxBracket;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;

// una capa [dao] que lee los tramos del impuesto desde una base de datos MySQL
public class MySqlTax implements ITaxDao {

    // códigos de error específicos de esta implementación
    public static final int ACCESS = 101, DATA = 102;

    // la consulta por defecto: los tramos deben devolverse en orden ascendente de los límites
    public static final String DEFAULT_QUERY = "select limits, coeffr, coeffn from brackets order by id";

    // tramos del impuesto
    private final List<TaxBracket> taxBrackets;

    // constructor con la consulta por defecto
    public MySqlTax(String url, String user, String password) {
        this(url, user, password, DEFAULT_QUERY);
    }

    // constructor: los tramos se leen una vez por todas
    public MySqlTax(String url, String user, String password, String query) {
        List<TaxBracket> brackets = new ArrayList<>();
        try (Connection connection = DriverManager.getConnection(url, user, password);
             Statement statement = connection.createStatement();
             ResultSet result = statement.executeQuery(query)) {
            // un tramo por fila del resultado: limit, coeffR, coeffN
            while (result.next()) {
                brackets.add(readBracket(result));
            }
        } catch (SQLException e) {
            // error de acceso a la base de datos: se envuelve en una TaxException
            throw new TaxException("Error accessing the tax brackets database", e, ACCESS);
        }
        // una tabla vacía también es un error
        if (brackets.isEmpty()) {
            throw new TaxException("The database contains no tax bracket", DATA);
        }
        // se devuelve una copia no modificable de la lista
        taxBrackets = List.copyOf(brackets);
    }

    @Override
    public List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }

    // el tramo de la fila actual: tres columnas numéricas, sin valor NULL
    private static TaxBracket readBracket(ResultSet result) {
        try {
            BigDecimal limit = result.getBigDecimal(1);
            BigDecimal coeffR = result.getBigDecimal(2);
            BigDecimal coeffN = result.getBigDecimal(3);
            if (limit == null || coeffR == null || coeffN == null) {
                throw new TaxException("A tax bracket of the database has a NULL value", DATA);
            }
            return new TaxBracket(limit, coeffR, coeffN);
        } catch (SQLException e) {
            // una columna ausente o no numérica
            throw new TaxException("The tax brackets of the database are incorrect", e, DATA);
        }
    }
}
  • 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-resources del 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:

package tax.dao;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertInstanceOf;
import static org.junit.jupiter.api.Assertions.assertNotEquals;
import static org.junit.jupiter.api.Assertions.assertThrowsExactly;

import tax.entities.TaxException;
import tax.entities.TaxBracket;
import tax.business.ITaxBusiness;
import tax.business.TaxBusiness;
import java.sql.SQLException;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;

// pruebas de la capa [dao] MySqlTax (la base de datos [dbtaxes] debe existir)
class MySqlTaxTests {

    // la base de datos de prueba
    private static final String URL = "jdbc:mysql://localhost:3306/dbtaxes";
    private static final String USER = "admtaxes";
    private static final String PASSWORD = "pwdtaxes";

    // los tramos leídos de la base de datos son los de la versión "hardwired"
    @Test
    void sameBrackets() {
        List<TaxBracket> reference = new HardwiredTax().getTaxBrackets();
        List<TaxBracket> brackets = new MySqlTax(URL, USER, PASSWORD).getTaxBrackets();
        // equals también compara la escala de los BigDecimal: 4962.00 (base de datos) no es igual a 4962 (hardwired)
        assertNotEquals(reference, brackets);
        // compareTo solo compara los valores
        assertEquals(reference.size(), brackets.size());
        for (int i = 0; i < reference.size(); i++) {
            assertEquals(0, reference.get(i).limit().compareTo(brackets.get(i).limit()));
            assertEquals(0, reference.get(i).coeffR().compareTo(brackets.get(i).coeffR()));
            assertEquals(0, reference.get(i).coeffN().compareTo(brackets.get(i).coeffN()));
        }
    }

    // la capa [business] de la versión 5 con la nueva capa [dao]
    @ParameterizedTest
    @CsvSource({
        "true, 2, 60000, 4282",
        "true, 3, 60000, 2959",
        "false, 0, 60000, 11519"
    })
    void calculateTax(boolean married, int nbChildren, int salary, int tax) {
        ITaxBusiness business = new TaxBusiness(new MySqlTax(URL, USER, PASSWORD));
        assertEquals(tax, business.calculateTax(married, nbChildren, salary));
    }

    // base de datos inexistente (o prohibida para el usuario)
    @Test
    void missingDatabase() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new MySqlTax(URL.replace("dbtaxes", "dbtaxesunknown"), USER, PASSWORD));
        assertEquals(MySqlTax.ACCESS, e.getCode());
        assertInstanceOf(SQLException.class, e.getCause());
    }

    // contraseña incorrecta
    @Test
    void incorrectPassword() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new MySqlTax(URL, USER, "x"));
        assertEquals(MySqlTax.ACCESS, e.getCode());
    }

    // servidor inalcanzable
    @Test
    void unreachableServer() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new MySqlTax(URL.replace("3306", "3399"), USER, PASSWORD));
        assertEquals(MySqlTax.ACCESS, e.getCode());
    }

    // consulta que devuelve solo dos columnas
    @Test
    void incorrectQuery() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new MySqlTax(URL, USER, PASSWORD, "select limits, coeffr from brackets"));
        assertEquals(MySqlTax.DATA, e.getCode());
    }

    // consulta que no devuelve ninguna fila
    @Test
    void noBracket() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new MySqlTax(URL, USER, PASSWORD,
                        "select limits, coeffr, coeffn from brackets where id < 0"));
        assertEquals(MySqlTax.DATA, e.getCode());
    }

    // consulta en la que una columna es NULL
    @Test
    void nullValue() {
        TaxException e = assertThrowsExactly(TaxException.class,
                () -> new MySqlTax(URL, USER, PASSWORD,
                        "select limits, coeffr, null from brackets"));
        assertEquals(MySqlTax.DATA, e.getCode());
    }
}
  • 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):

╷
└─ JUnit Jupiter ✔
   └─ MySqlTaxTests ✔
      ├─ missingDatabase() ✔
      ├─ incorrectQuery() ✔
      ├─ incorrectPassword() ✔
      ├─ noBracket() ✔
      ├─ nullValue() ✔
      ├─ calculateTax(boolean, int, int, int) ✔
      │  ├─ [1] married=true, nbChildren=2, salary=60000, tax=4282 ✔
      │  ├─ [2] married=true, nbChildren=3, salary=60000, tax=2959 ✔
      │  └─ [3] married=false, nbChildren=0, salary=60000, tax=11519 ✔
      ├─ unreachableServer() ✔
      └─ sameBrackets() ✔
...
[        10 tests successful      ]
[         0 tests failed          ]

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:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <!-- el proyecto padre proporciona las versiones y la configuración comunes -->
    <parent>
        <groupId>examples.tax</groupId>
        <artifactId>tax-v6</artifactId>
        <version>6.0</version>
    </parent>

    <artifactId>tax-ui-mysql</artifactId>

    <dependencies>
        <!-- la nueva capa [dao] (y, de forma transitiva, el controlador JDBC de MySQL) -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-dao-mysql</artifactId>
        </dependency>
        <!-- las capas [business] y [ui] de la versión 5, sin cambios -->
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-business</artifactId>
        </dependency>
        <dependency>
            <groupId>examples.tax</groupId>
            <artifactId>tax-ui</artifactId>
        </dependency>
        <!-- el contenedor de inyección de dependencias de Spring -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <!-- mvn exec:java ejecuta la clase principal -->
            <plugin>
                <groupId>org.codehaus.mojo</groupId>
                <artifactId>exec-maven-plugin</artifactId>
                <configuration>
                    <mainClass>tax.ui.mysql.Main</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
  • 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:

1
2
3
4
5
6
# configuración de la aplicación [Tax], versión 6: la capa [dao] lee una base de datos
dao.implementation=MySqlTax
dao.url=jdbc:mysql://localhost:3306/dbtaxes
dao.user=admtaxes
dao.password=pwdtaxes
dao.query=select limits, coeffr, coeffn from brackets order by id
  • 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]:

package tax.ui.mysql;

import tax.dao.HardwiredTax;
import tax.dao.ITaxDao;
import tax.dao.MySqlTax;
import tax.entities.TaxException;
import tax.business.ITaxBusiness;
import tax.business.TaxBusiness;
import tax.ui.Dialog;
import java.io.IOException;
import java.io.Reader;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Properties;
import org.springframework.context.support.GenericApplicationContext;

// la aplicación [Tax], versión 6: la capa [dao] lee los tramos del impuesto desde una base de datos
public class Main {

    public static void main(String[] args) {
        // el archivo de configuración: tax.properties por defecto, o el pasado como argumento
        String configFile = args.length > 0 ? args[0] : "tax.properties";

        // integración de las capas
        ITaxBusiness business;
        try {
            // lectura de la configuración, en la carpeta actual
            Properties config = new Properties();
            try (Reader reader = Files.newBufferedReader(Path.of(configFile))) {
                config.load(reader);
            }
            String implementation = config.getProperty("dao.implementation", "MySqlTax");
            String url = config.getProperty("dao.url");
            if (url == null) {
                throw new TaxException("The [dao.url] parameter is missing from the configuration");
            }
            String user = config.getProperty("dao.user", "");
            String password = config.getProperty("dao.password", "");
            String query = config.getProperty("dao.query", MySqlTax.DEFAULT_QUERY);

            // el contenedor Spring: las capas se registran en él
            GenericApplicationContext context = new GenericApplicationContext();
            // la capa [dao]: la implementación se elige según la configuración
            context.registerBean(ITaxDao.class, () -> switch (implementation) {
                case "MySqlTax" -> new MySqlTax(url, user, password, query);
                case "HardwiredTax" -> new HardwiredTax();
                default -> throw new TaxException(
                        "Unknown implementation [" + implementation + "] of the [dao] layer");
            });
            // la capa [business] de la versión 5: el contenedor pasará la capa [dao] a su constructor
            context.registerBean(TaxBusiness.class);

            // inicio del contenedor: crea la capa [dao] y luego la capa [business]
            context.refresh();
            business = context.getBean(ITaxBusiness.class);
        } catch (IOException | RuntimeException e) {
            // visualización del error y fin del programa
            Dialog.displayError(e);
            System.exit(1);
            return;
        }

        // el diálogo con el usuario: la capa [ui] de la versión 5
        Dialog.run(business);
    }
}
  • 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:

1
2
3
4
> cd 10-jdbc/TaxV6
> mvn install
> cd tax-ui-mysql
> mvn -q exec:java

Ejecución con el archivo [tax.properties]:

1
2
3
4
5
6
7
8
> mvn -q exec:java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

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]:

> mvn -q exec:java -Dexec.args="tax-base.properties"
Oct 03, 2026 7:08:56 PM org.springframework.context.support.GenericApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
Exception chain:
----------------------------------------
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
----------------------------------------
tax.entities.TaxException: Error accessing the tax brackets database
----------------------------------------
java.sql.SQLSyntaxErrorException: Access denied for user 'admtaxes'@'localhost' to database '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:

> mvn -q exec:java -Dexec.args="tax-password.properties"
Oct 03, 2026 7:09:00 PM org.springframework.context.support.GenericApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
Exception chain:
----------------------------------------
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
----------------------------------------
tax.entities.TaxException: Error accessing the tax brackets database
----------------------------------------
java.sql.SQLException: Access denied for user 'admtaxes'@'localhost' (using password: YES)
----------------------------------------

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):

> mvn -q exec:java -Dexec.args="tax-server.properties"
Oct 03, 2026 7:09:02 PM org.springframework.context.support.GenericApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
Exception chain:
----------------------------------------
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
----------------------------------------
tax.entities.TaxException: Error accessing the tax brackets database
----------------------------------------
com.mysql.cj.jdbc.exceptions.CommunicationsException: Communications link failure

The last packet sent successfully to the server was 0 milliseconds ago. The driver has not received any packets from the server.
----------------------------------------
com.mysql.cj.exceptions.CJCommunicationsException: Communications link failure

The last packet sent successfully to the server was 0 milliseconds ago. The driver has not received any packets from the server.
----------------------------------------
java.net.ConnectException: Connection refused (connect failed)
----------------------------------------

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]:

> mvn -q exec:java -Dexec.args="tax-query.properties"
Oct 03, 2026 7:09:05 PM org.springframework.context.support.GenericApplicationContext refresh
WARNING: Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
Exception chain:
----------------------------------------
org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'tax.dao.ITaxDao': Instantiation of supplied bean failed
----------------------------------------
tax.entities.TaxException: The tax brackets of the database are incorrect
----------------------------------------
java.sql.SQLException: Column Index out of range, 3 > 2. 
----------------------------------------

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:
1
2
3
4
5
6
# la misma aplicación con una base de datos PostgreSQL (hay que agregar el controlador org.postgresql:postgresql a pom.xml)
dao.implementation=MySqlTax
dao.url=jdbc:postgresql://localhost:5432/dbtaxes
dao.user=admtaxes
dao.password=pwdtaxes
dao.query=select data1, data2, data3 from data order by id

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: