Transacciones en Java con commit y rollback

Contenido del curso

No sé dónde empezar

JDBC

CRUD

Transacciones

Conexiones Pool

JPA y ORM

Próximos pasos

22
Clon de Netflix con JDBC o JPA
02:29 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0016:45

Transacciones en Java con commit y rollback

Curso de Java SE: SQL y Bases de Datos

Clase 16 de 22

Clase 16 / 22

Recursos

Implementar transacciones en Java con MySQL te permite garantizar que un conjunto de operaciones se ejecute como una unidad atómica: o todo se guarda, o nada se guarda. Aquí verás cómo aplicarlo modificando un EmployeeRepository, controlando el autocommit y manejando commit y rollback ante excepciones.

Este recorrido es útil si trabajas con JDBC y quieres evitar inconsistencias en tu base de datos cuando varias operaciones dependen entre sí.

¿Cómo preparar la base de datos para probar transacciones?

Antes de tocar el código Java, necesitas un escenario donde una operación pueda fallar de forma controlada. La idea es agregar un campo con restricción de unicidad para forzar errores y observar el comportamiento transaccional [00:14].

Desde MySQL Workbench, abre la tabla Employees con la opción Alter Table y añade un campo nuevo:

Nombre del campo: curp.
Longitud: 18 caracteres.
Restricción: UNIQUE, para que no se pueda repetir entre empleados.

Esa restricción de unicidad será la que dispare la excepción más adelante y te permita ver el rollback en acción.

¿Cómo refactorizar el EmployeeRepository para una sola conexión?

Una transacción debe vivir dentro de una única conexión. Si cada método abre la suya, no hay forma de confirmarlas o revertirlas en bloque. Por eso el primer paso es centralizar la conexión en el repositorio [01:14].

En lugar del clásico private Connection getConnection(), declara una conexión como atributo y recíbela por constructor:

Cambia private Connection getConnection por private Connection myCon.
Anota la clase o el constructor con @AllArgsConstructor (o crea el constructor manualmente).
Reemplaza todas las llamadas a getConnection() por myCon dentro de los métodos del repositorio.

¿Por qué usar una sola Connection en una transacción? Porque commit y rollback operan sobre la conexión activa. Si abres varias, cada una maneja su propio estado y pierdes la atomicidad.

¿Qué cambios hacer en el modelo Employee?

El nuevo campo curp debe reflejarse también en la entidad. En la clase Employee agrega:

Atributo private String curp.
Getter y setter correspondientes.
Parámetro String curp en el constructor con this.curp = curp.
Línea adicional en el método toString para incluirlo.

Luego, en el EmployeeRepository, ajusta los métodos save y createEmployees para que el PreparedStatement incluya el sexto parámetro con myStmt.setString(6, employee.getCurp()), y corre el índice de los parámetros siguientes si los hay.

¿Cómo controlar autocommit, commit y rollback en el main?

Por defecto, JDBC tiene el autocommit en true, lo que significa que cada sentencia se confirma de inmediato. Para una transacción real necesitas desactivarlo y decidir tú cuándo confirmar [04:30].

En el main, abre la conexión con try-with-resources y desactiva el autocommit:

Obtén la conexión: Connection myConn = DatabaseConnection.getInstance().
Verifica y desactiva: if (myConn.getAutoCommit()) myConn.setAutoCommit(false);.
Abre un try interno donde instancias EmployeeRepository repository = new EmployeeRepository(myConn);.
Ejecuta las operaciones, por ejemplo repository.save(employee);.
Confirma con myConn.commit();.
En el catch, ejecuta myConn.rollback(); para revertir cualquier cambio si algo falla.

Este patrón es la base del manejo transaccional en JDBC: tú decides el punto exacto en el que los cambios se vuelven permanentes.

¿Qué hace rollback en una transacción? Devuelve la base de datos al estado en que estaba antes de iniciar la transacción, descartando todas las operaciones pendientes que aún no fueron confirmadas con commit.

¿Cómo se ve una inserción exitosa?

El primer caso de prueba inserta un empleado válido [06:20]:

employ.setFirstName("América").
employ.setSurname("López").
employ.setMaSurname("Villa").
employ.setEmail("ame@example.com").
employ.setSalary(300f).
employ.setCurp("123456789012345678") con 18 caracteres.

Al ejecutar repository.save(employ) seguido de myConn.commit(), el registro queda guardado y aparece en la tabla. Todo el flujo se completó dentro de la transacción.

¿Cómo verificar que el rollback funciona ante una excepción?

Para comprobar el comportamiento transaccional, fuerza un error usando el mismo CURP en un segundo empleado [09:10]. Como el campo es UNIQUE, MySQL lanza una excepción de entrada duplicada.

El flujo esperado es:

La operación entra al bloque try.
Al ejecutar el save, se lanza la excepción por el CURP repetido.
El control salta al catch, que ejecuta myConn.rollback().
Ningún cambio queda registrado en la base de datos.

Al revisar la tabla, no aparece ningún registro nuevo. Esa es la unidad atómica funcionando: si una parte falla, todas las operaciones del bloque se descartan, incluso aquellas que en sí mismas habrían tenido éxito.

¿Qué es una unidad atómica en bases de datos? Es un conjunto de operaciones que se ejecutan como un todo: si una falla, ninguna se aplica; si todas tienen éxito, se confirman juntas con commit.

Este patrón se vuelve crítico cuando una transacción incluye varias acciones, como insertar, actualizar y eliminar registros relacionados. Si confiaras en el autocommit, podrías terminar con datos a medias y referencias rotas entre tablas.

Cuéntame en los comentarios cómo estás implementando transacciones en tu propio proyecto y qué escenarios de rollback has tenido que resolver.

Pablo Andrés Prado Diaz

Hace 2 años

Extendiendo un poco para los que creen que el ejercicio no es el adecuado.

El ejemplo no esta mal. En este caso esta inconclusa la explicación. Básicamente el try donde se hace la creación de un nuevo empleado es una transacción. En ella puedes hacer múltiples peticiones usando una sola conexión. Para que puedas comprobar que el principio atomic se cumple puedes crear dos nuevos empleados en el mismo try, el cual se maneja mediante una sola conexión.

En mi caso estoy creando un Usuario pero pueden replicar el ejemplo usando la clase Employee de la clase:

Crea dos empleados nuevos. En mi caso son usuarios. En mi base de datos tengo como valores unicos los correos que es la misma restricción del curp de la clase:

User user1 = new User(); user1.setNickname("Architect"); user1.setPassword("admin123"); user1.setLogin("logead"); user1.setEmail("correo8@correo.com"); user1.setNickname("DevOps");

User user2 = new User(); user2.setNickname("AWS"); user2.setPassword("admin123"); user2.setLogin("logead"); user2.setEmail("correo8@correo.com"); user2.setNickname("DevOps"); List<User> usersList;

Para ver los cambios dentro del try anidado intenta crear dos usuarios con el mismo curp. En primera instancia se crea el primer Employee pero el segundo tiene un error el roleBack elimina este cambio de la Base de datos. Que es el principio de atomicidad que se busca explicar con las transacciones.
Puedes comprobar su funcionamiento creando dos empleados validos para que notes que el cambio se guarda.
Este es mi código completo, modifícalo para enviar un Employee en lugar de Usuario:

import org.example.joseFrontend.model.User; import org.example.joseFrontend.repository.Repository; import org.example.joseFrontend.repository.UserRepository; import org.example.joseFrontend.util.DatabaseConnection;

import java.sql.*; import java.util.List;

public class Main { public static void main(String[] args) throws SQLException { try(Connection myConn = DatabaseConnection.``getInstance``()){ if(myConn.getAutoCommit()){ myConn.setAutoCommit(false); } User user1 = new User(); user1.setNickname("Architect"); user1.setPassword("admin123"); user1.setLogin("logead"); user1.setEmail("correo8@correo.com"); user1.setNickname("DevOps");

User user2 = new User(); user2.setNickname("AWS"); user2.setPassword("admin123"); user2.setLogin("logead"); user2.setEmail("correo8@correo.com"); user2.setNickname("DevOps"); List<User> usersList; try{ Repository<User> userRepository = new UserRepository(myConn); System.``out``.println("--------------Antes Cambio 1----------------"); usersList = userRepository.findAll(); usersList.forEach(System.``out``::println); userRepository.save(user1); System.``out``.println("--------------Después Cambio 1----------------"); usersList = userRepository.findAll(); usersList.forEach(System.``out``::println); System.``out``.println("--------------Antes Cambio 2----------------"); userRepository.save(user2); System.``out``.println("--------------Después Cambio 2----------------"); usersList = userRepository.findAll(); usersList.forEach(System.``out``::println); System.``out``.println("-------------------------------------");

myConn.commit(); }catch (SQLException exception){ myConn.rollback(); } } } }

Cid Emmanuel Esquivel González

Hace 2 años

@Andres_Pavel Intenta correr el codigo sin la linea del commit y el rollback junto con algun error en la CURP y veras que tampoco se hace la inserción. Por eso varios decimos que este ejemplo no es el mejor...

Comentarios (21)21 comentarios

Daniel Camacho

Hace 3 años

Omar Villada

Juan Marcelo Panasiti

Jefry Amador

Juan Sebastián Joya Rodríguez

Sergio Andrés Majé Franco

Daniel Esteban Pérez Bohórquez

Ana Fernanda Gutierrez Villanueva

Profesor

Tara Campos Padilla

Isay Humberto Lucas Hernandez

Héctor Salinas

Hace 4 meses

Milton Hernan Camacho Quitian

Hace 9 meses

Micael Abdias Rodriguez

Hace 10 meses

Xavier Armando Larios Alvarenga

Hace un año

Juan Ignacio Gonzalez Burnet

Fabiola Jacqueline Paz Alatorre

Juan Felipe Barahona Gonzalez

Pedro Nicolas Rios Vargas

Jaime Manuel Cutipa Calderón

Joselyn Pariansullca

Jose Carrillo Zenteno

Joahan Carlo Nuñez Soto

Jesús Sánchez

JDBC

Arquitectura y Funcionamiento de la API JDBC

Qué es JDBC y cómo conecta Java a bases de datos

Componentes y métodos clave de JDBC

Conexión a MySQL con JDBC en Java

Consultas SQL en Java con JDBC

Update y Delete en Java con JDBC

CRUD

Creación de Proyectos Java con Maven y Gestión de Dependencias

Try-with-resources para cerrar conexiones JDBC

Patrón DAO vs Repository en Java

Patrón Repository con Singleton en Java

Patrón Repository con JDBC en Java

Insertar datos en MySQL con PreparedStatement

Método delete en JDBC con PreparedStatement

Interfaz gráfica de CRUD con Java Swing

Transacciones

Transacciones en bases de datos y principios ACID

Transacciones en Java con commit y rollback

Conexiones Pool

Pool de conexiones a bases de datos

Implementación de Pool de Conexiones en Java con Apache Commons

JPA y ORM

Fundamentos de JPA y sus Anotaciones Principales

Configuración de JPA con Hibernate en Maven

Operaciones CRUD con JPA en Java

Próximos pasos

Clon de Netflix con JDBC o JPA

Transacciones en Java con commit y rollback

Progreso del curso

JDBC

CRUD

Transacciones

Conexiones Pool

JPA y ORM

Próximos pasos

Recursos

Recursos