Transacciones
Commit y rollback
Transacciones es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.
¿Qué es una transacción?
Una transacción agrupa varias operaciones SQL en una única unidad que se ejecuta completamente o no se ejecuta.
O bien todas las sentencias se ejecutan correctamente y los cambios se hacen permanentes (commit), o bien algo falla y todos se deshacen (rollback). Esto mantiene la coherencia de la base de datos.
ACID en un minuto
Las transacciones proporcionan las garantías ACID:
- Atomicidad — todo o nada.
- Consistencia — lleva la base de datos de un estado válido a otro.
- Aislamiento — las transacciones simultáneas no se corrompen entre sí.
- Durabilidad — una vez confirmados, los cambios sobreviven a un fallo.
Modo auto-commit
De forma predeterminada, las conexiones JDBC funcionan en modo auto-commit: cada sentencia constituye su propia transacción y se confirma de inmediato.
Esto está bien para sentencias individuales, pero no sirve cuando varias escrituras deben realizarse juntas. Para controlar las transacciones manualmente, desactive auto-commit.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class Main {
public static void main(String[] args) {
String url = "jdbc:postgresql://localhost:5432/bank";
try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
System.out.println("Default auto-commit: " + conn.getAutoCommit());
conn.setAutoCommit(false);
System.out.println("Now manual: " + conn.getAutoCommit());
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Commit y rollback
Con auto-commit desactivado, usted decide los límites:
conn.commit()hace permanentes todos los cambios pendientes.conn.rollback()los descarta.
El ejemplo clásico es una transferencia de dinero: retirar fondos de una cuenta y abonarlos en otra. Ambas operaciones deben realizarse, o ninguna de las dos.
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class Main {
public static void main(String[] args) {
String url = "jdbc:postgresql://localhost:5432/bank";
String debit = "UPDATE account SET balance = balance - ? WHERE id = ?";
String credit = "UPDATE account SET balance = balance + ? WHERE id = ?";
try (Connection conn = DriverManager.getConnection(url, "app", "secret")) {
conn.setAutoCommit(false);
try (PreparedStatement d = conn.prepareStatement(debit);
PreparedStatement c = conn.prepareStatement(credit)) {
d.setInt(1, 100); d.setInt(2, 1); d.executeUpdate();
c.setInt(1, 100); c.setInt(2, 2); c.executeUpdate();
conn.commit();
System.out.println("Transfer committed");
} catch (SQLException ex) {
conn.rollback();
System.out.println("Rolled back: " + ex.getMessage());
}
} catch (SQLException e) {
System.out.println(e.getMessage());
}
}
}Patrón de rollback en caso de fallo
Esta es la estructura que debe memorizar:
- Desactive auto-commit.
- Realice el trabajo dentro de un
tryinterno. - Si todo va bien, llame a
commit(). - En
catch, llame arollback()y vuelva a lanzar la excepción o regístrela.
Sin el rollback, un fallo podría dejar la base de datos actualizada solo parcialmente.
Simulación de la atomicidad
Aquí se modela la idea de todo o nada en Java básico para que se ejecute de forma independiente. Se aplican dos actualizaciones a una instantánea; si alguna falla, se restaura la instantánea.
public class Main {
public static void main(String[] args) {
int[] balances = {500, 300};
int[] backup = balances.clone();
try {
balances[0] -= 200;
if (balances[0] < 0) throw new IllegalStateException("insufficient funds");
balances[1] += 200;
System.out.println("Commit: " + balances[0] + ", " + balances[1]);
} catch (RuntimeException e) {
balances = backup;
System.out.println("Rollback: " + balances[0] + ", " + balances[1]);
}
}
}Puntos de guardado
Un punto de guardado es una marca dentro de una transacción. Puede hacer rollback hasta ese punto sin descartar toda la transacción.
Savepoint sp = conn.setSavepoint()conn.rollback(sp)deshace únicamente el trabajo posterior a ese punto.
Resulta útil para la recuperación parcial en transacciones largas.
Niveles de aislamiento
El aislamiento controla qué parte del trabajo no confirmado de una transacción puede ver otra. JDBC define los niveles mediante conn.setTransactionIsolation(...):
TRANSACTION_READ_COMMITTED— el valor predeterminado habitual.TRANSACTION_REPEATABLE_READTRANSACTION_SERIALIZABLE— el más estricto y lento.
Un mayor aislamiento evita anomalías, pero reduce la concurrencia.
Anomalías de lectura
Un nivel de aislamiento bajo puede permitir:
- Lectura sucia — ver un cambio no confirmado de otra transacción.
- Lectura no repetible — una fila cambia entre dos lecturas.
- Lectura fantasma — aparecen filas nuevas que coinciden con una consulta anterior.
Elija el nivel más bajo que evite las anomalías que su lógica no pueda tolerar.
Restaurar auto-commit
Si obtuvo la conexión de un pool, restaure su estado original antes de devolverla.
Después de una transacción manual, vuelva a establecer conn.setAutoCommit(true) (o restablezca el valor que observó al obtenerla) para que el siguiente usuario no se vea sorprendido por su configuración.
Mantener breves las transacciones
Una transacción mantiene los bloqueos hasta que se confirma o se revierte. Las transacciones largas bloquean otras operaciones y aumentan el riesgo de interbloqueo.
- No realice llamadas de red lentas ni solicite datos al usuario dentro de una transacción abierta.
- Recopile primero los datos; después, abra la transacción, escriba y confirme rápidamente.
Las transacciones breves y centradas escalan mucho mejor.
Comprobación rápida
¿Qué efecto tiene llamar a connection.rollback()?
Repaso
Las transacciones proporcionan seguridad de todo o nada:
- Desactive auto-commit con
setAutoCommit(false). - Llame a
commit()si todo va bien y arollback()si se produce un fallo. - Utilice puntos de guardado para hacer rollback parcial.
- Ajuste los niveles de aislamiento para equilibrar la corrección y la concurrencia.
- Restaure auto-commit antes de devolver una conexión del pool.
Preguntas frecuentes
¿La lección «Transacciones» es gratis?
Sí — el texto completo de «Transacciones» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Transacciones»?
Commit y rollback Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Java Academy?
No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «Transacciones»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Java Academy?
Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.