Index / Java / Transacciones con Java y MariaDB

Transacciones con Java y MariaDB

Autor jc mouse jueves, mayo 23, 2019

Se define como Transacción en base de datos a una «unidad lógica de trabajo» compuesta por un conjunto de operaciones que se aplicaran una después de otra, es decir, es una forma de agrupar un conjunto acciones en una única acción el cual se ejecuta de la forma «todo o nada».

Una transacción cuenta con 4 características conocidas como ACID:

Atomicidad (Atomicity): La atomicidad garantiza que cada transacción se trata como una «unidad», es decir, o bien tiene éxito completo o falla completamente.
Consistencia (Consistency): Garantiza que una transacción solo pueda llevar a la base de datos de un estado válido a otro, es decir, solo se ejecutan aquellas operaciones que no van a romper la reglas y directrices de integridad de la base de datos.
Aislamiento (Isolation): Garantiza que la ejecución simultánea de transacciones deje la base de datos en el mismo estado que se hubiera obtenido si las transacciones se ejecutaran de forma secuencial. El aislamiento es el objetivo principal del control de concurrencia.
Permanencia (Durability): Una vez que la transacción ha finalizado, los cambios realizados a la base de datos son permanentes.

La responsabilidad de asegurar el cumplimiento de ACID, es compartida tanto por el desarrollador como por el servido SQL.

Ejemplo transacción en Java

Primero creamos un par de tablas en nuestra base de datos «TutorialJava» como se ve en la siguiente imagen:

Implementamos en java un código para ejecutar 2 instrucciones SQL para insertar un registro en cada tabla. Pero no usaremos transacciones.

 1 import java.sql.Connection;
 2 import java.sql.DriverManager;
 3 import java.sql.PreparedStatement;
 4 import java.sql.SQLException;
 5 /**
 6  * @see https://www.jc-mouse.net/
 7  * @author mouse
 8  */
 9 public class Main {
10 
11     public static void main(String[] args) throws SQLException {
12         Connection connection = null;
13         PreparedStatement cantidadStatement = null;
14         PreparedStatement nombreStatement = null;
15         try {
16             connection = DriverManager.getConnection("jdbc:mariadb://localhost:3306/TutorialJava", "root", "");
17             System.out.println("> Conectado a la base de datos");
18 
19             //Instrucciones SQL para tabla1 y tabla2
20             String insertCantidad = "INSERT INTO tabla1(cantidad) VALUES(?)";
21             String insertNombre = "INSERT INTO tabla2(nombre) VALUES(?)";
22             
23             cantidadStatement = connection.prepareStatement(insertCantidad);
24             nombreStatement = connection.prepareStatement(insertNombre);
25 
26             //Datos para tabla1 y tabla2
27             cantidadStatement.setInt(1, 69);
28             nombreStatement.setString(1, "Mouse");
29 
30             //Ejecuta instrucciones SQL
31             System.out.println("> Ejecuta instrucciones SQL");
32             cantidadStatement.execute();
33             nombreStatement.execute();
34 
35             System.out.println("> Programa concluido con exito");
36 
37         } catch (SQLException ex) {            
38             System.err.println(ex.getMessage());            
39         } finally {
40             if (cantidadStatement != null) {
41                 cantidadStatement.close();
42             }
43             if (nombreStatement != null) {
44                 nombreStatement.close();
45             }
46         }
47     }
48 
49 }

Si se ejecuta este código obtendremos en pantalla lo siguiente:

Ahora modificaremos las lineas 27 y 28 con los datos «28» y «Rosa Melcacho«, este ultimo dato no cumple con la restricción de longitud de la tabla2 que es nombre: varchar(8). Ejecutemos para ver lo que pasa:

Como era de esperarse, obtenemos una excepción «Data too long for column ‘nombre’…», esto quiere decir que la instrucción SQL para la tabla2 se interrumpió, sin embargo la instrucción SQL para la tabla1 si finalizo correctamente, esto podemos apreciarlo si inspeccionamos las tablas donde vemos un nuevo registro para la tabla1 pero no para la tabla2.

Este tipo de errores elevados al rango de operaciones bancarias por ejemplo puede llegar a tener un gran impacto en la entidad financiera, para evitar estos contratiempos se debe utilizar transacciones.

Vamos a modificar un poco nuestro código:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
/**
 * @see https://www.jc-mouse.net/
 * @author mouse
 */
public class Main {

    public static void main(String[] args) throws SQLException {
        Connection connection = null;
        PreparedStatement cantidadStatement = null;
        PreparedStatement nombreStatement = null;
        try {
            connection = DriverManager.getConnection("jdbc:mariadb://localhost:3306/TutorialJava", "root", "");
            System.out.println("> Conectado a la base de datos");

            //Desactiva confirmación automática
            connection.setAutoCommit(false);
            
            String insertCantidad = "INSERT INTO tabla1(cantidad) VALUES(?)";
            String insertNombre = "INSERT INTO tabla2(nombre) VALUES(?)";

            cantidadStatement = connection.prepareStatement(insertCantidad);
            nombreStatement = connection.prepareStatement(insertNombre);

            //Datos para tabla1 y tabla2
            cantidadStatement.setInt(1, 28);
            nombreStatement.setString(1, "Rosa Melcacho");

            //Ejecuta instrucciones SQL
            System.out.println("> Ejecuta instrucciones SQL");
            cantidadStatement.execute();
            nombreStatement.execute();

            connection.commit();
            System.out.println("> Programa concluido con exito");            
        } catch (SQLException ex) {
            System.err.println(ex.getMessage());
            if (connection != null) {
                try {
                    System.err.println("> Transacción abortada");
                    System.err.println("> Valores restaurados");
                    System.out.println("> Programa concluido");      
                    connection.rollback();
                } catch (SQLException ex1) {
                    System.err.println(ex1.getMessage());
                }
            }
        } finally {
            if (cantidadStatement != null) {
                cantidadStatement.close();
            }
            if (nombreStatement != null) {
                nombreStatement.close();
            }
            connection.setAutoCommit(true);
        }
    }

}

En rojo las modificaciones más importantes, a saber:

setAutoCommit(false): Por defecto esta opción se encuentra como TRUE, Esto significa que cada instrucción SQL individual se trata como una transacción y se confirma automáticamente una vez que se ejecuta. Por eso en nuestro código anterior se inserto un nuevo registro en la tabla1 pero no en la tabla2, ambas instrucciones SQL fueron tratadas independientemente. Al deshabilitar esta opción estamos permitiendo agrupar varias instrucciones en una sola transacción.
commit(): Después de desactivar el modo de confirmación automática, todas las las sentencias de SQL no serán confirmadas hasta que se llame a este método de confirmación explícitamente.
rollback(): Deshace todos los cambios realizados en la transacción actual y libera los bloqueos de la base de datos que este objeto de conexión mantiene actualmente. Este método se debe utilizar solo cuando el modo de confirmación automática se haya desactivado.

es decir:

Volvemos a ejecutar nuestro programa y nuevamente vuelve a retornar la excepción, sin embargo en esta oportunidad al tener agrupado nuestras instrucciones SQL en una transacción, al producirse la excepción la operación es abortada y los cambios realizados en la base de datos son deshechos. Podemos verificar este hecho inspeccionando nuestra base de datos.