Транзакции в JDBC: setAutoCommit, commit и rollback
Перевод денег — это два запроса: списать сумму с одного счёта и зачислить на другой. Если выполнить их через JDBC «как есть», а во втором запросе окажется ошибка (например, счёта получателя нет), первый уже успеет сохраниться: у Анны было 1000, стало 900, а 100 никуда не пришли. Защита от такого исхода — транзакция.
Транзакция — это группа SQL-команд, которая выполняется как одно целое: либо все изменения фиксируются (commit), либо все отменяются (rollback). В JDBC транзакцией управляет объект Connection: по умолчанию каждая команда фиксируется сама, а вызов setAutoCommit(false) позволяет объединить несколько команд в одну транзакцию. Что такое ACID и как транзакции работают на стороне базы, разобрано в уроке Транзакции в SQL.
1. Режим автофиксации (autoCommit)
Новое соединение JDBC работает в режиме автофиксации: getAutoCommit() возвращает true, и каждая команда executeUpdate сразу фиксируется в базе как отдельная транзакция. Чтобы несколько команд выполнились как одно целое, автофиксацию выключают: connection.setAutoCommit(false).
Вот перевод денег без транзакции. Таблица счетов:
CREATE TABLE accounts (
id INT PRIMARY KEY,
owner VARCHAR(50) NOT NULL,
balance DECIMAL(10, 2) NOT NULL
);
INSERT INTO accounts (id, owner, balance) VALUES
(1, 'Анна', 1000.00),
(2, 'Борис', 500.00); Пример 1. Перевод без транзакции
static void transferWithoutTransaction(Connection connection, int fromId, int toId,
BigDecimal amount) throws SQLException {
try (PreparedStatement debit = connection.prepareStatement(
"UPDATE accounts SET balance = balance - ? WHERE id = ?");
PreparedStatement credit = connection.prepareStatement(
"UPDATE accounts SET balance = balance + ? WHERE id = ?")) {
debit.setBigDecimal(1, amount);
debit.setInt(2, fromId);
debit.executeUpdate(); // уже зафиксировано
credit.setBigDecimal(1, amount);
credit.setInt(2, toId);
if (credit.executeUpdate() != 1) {
throw new SQLException("Счёт " + toId + " не найден");
}
}
} Вызов transferWithoutTransaction(connection, 1, 99, new BigDecimal("100.00")) бросит исключение «Счёт 99 не найден», а в таблице останется:
Анна = 900.00, Борис = 500.00 Списание выполнилось и зафиксировалось сразу, отменить его уже нечем. В режиме автофиксации исключение в Java не откатывает то, что база успела сохранить.
Методы Connection, которые управляют транзакцией:
| Метод | Что делает |
|---|---|
setAutoCommit(boolean) | false — команды копятся в одной транзакции до commit() или rollback(). true — каждая команда фиксируется сама; если транзакция была открыта, она фиксируется в момент вызова |
getAutoCommit() | Текущий режим. У нового соединения — true |
commit() | Фиксирует все изменения текущей транзакции и снимает блокировки |
rollback() | Отменяет все изменения текущей транзакции |
setSavepoint(String) / rollback(Savepoint) | Ставит точку сохранения и откатывает транзакцию до неё, не трогая то, что было раньше |
setTransactionIsolation(int) | Задаёт уровень изоляции для следующих транзакций этого соединения |
2. Перевод денег: commit и rollback
Транзакция в JDBC строится так: setAutoCommit(false), затем все команды, затем commit(); если любая команда бросила исключение, в блоке catch вызывается rollback(), и база возвращается к состоянию до транзакции. Ниже тот же перевод, но атомарный.
Пример 2. Класс MoneyTransfer
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
public class MoneyTransfer {
private static final String DEBIT =
"UPDATE accounts SET balance = balance - ? WHERE id = ? AND balance >= ?";
private static final String CREDIT =
"UPDATE accounts SET balance = balance + ? WHERE id = ?";
public static void transfer(Connection connection, int fromId, int toId, BigDecimal amount)
throws SQLException {
boolean oldAutoCommit = connection.getAutoCommit();
connection.setAutoCommit(false);
try (PreparedStatement debit = connection.prepareStatement(DEBIT);
PreparedStatement credit = connection.prepareStatement(CREDIT)) {
debit.setBigDecimal(1, amount);
debit.setInt(2, fromId);
debit.setBigDecimal(3, amount);
if (debit.executeUpdate() != 1) {
throw new SQLException("Недостаточно средств на счёте " + fromId);
}
credit.setBigDecimal(1, amount);
credit.setInt(2, toId);
if (credit.executeUpdate() != 1) {
throw new SQLException("Счёт " + toId + " не найден");
}
connection.commit();
} catch (SQLException e) {
connection.rollback();
throw e;
} finally {
connection.setAutoCommit(oldAutoCommit);
}
}
} Условие AND balance >= ? делает проверку баланса частью самого UPDATE: если денег не хватает, запрос не изменит ни одной строки, executeUpdate() вернёт 0, и метод бросит исключение. Отдельный SELECT balance перед списанием так не работает: между проверкой и списанием другой поток может успеть потратить те же деньги.
Пример 3. Запуск переводов
MoneyTransfer.transfer(connection, 1, 2, new BigDecimal("300.00"));
printBalances(connection);
try {
MoneyTransfer.transfer(connection, 2, 1, new BigDecimal("5000.00"));
} catch (SQLException e) {
System.out.println("Откат: " + e.getMessage());
}
try {
MoneyTransfer.transfer(connection, 1, 99, new BigDecimal("100.00"));
} catch (SQLException e) {
System.out.println("Откат: " + e.getMessage());
}
printBalances(connection); Метод printBalances выводит owner и balance всех счетов. Вывод при начальных балансах 1000.00 и 500.00:
Анна = 700.00, Борис = 800.00
Откат: Недостаточно средств на счёте 2
Откат: Счёт 99 не найден
Анна = 700.00, Борис = 800.00 Первый перевод зафиксирован. Во втором списание не прошло по условию баланса. В третьем списание у Анны выполнилось, но rollback() его отменил, и у Анны снова 700.00, а не 600.00, как было бы без транзакции.
3. Как правильно написать транзакцию
У правильной транзакции в JDBC четыре обязательные части: выключить автофиксацию, вызвать commit() в конце успешной ветки, вызвать rollback() при любом исключении и вернуть соединению прежний режим в finally. Пропуск любой из них не даёт ошибки компиляции, но ломает данные.
- rollback() в catch. Если его забыть, незафиксированные изменения останутся на соединении. Следующий
commit()на этом же соединении, даже в совсем другом методе, зафиксирует их вместе со своими. - Пробросить исключение дальше.
MoneyTransferпосле отката делаетthrow e: вызывающий код должен узнать, что перевод не состоялся. «Проглоченное» исключение выглядит для пользователя как успешный перевод. - Восстановить autoCommit в finally. Метод запоминает прежнее значение и возвращает его. Это важно для пула соединений: соединение вернётся в пул и достанется коду, который рассчитывает на автофиксацию. HikariCP сбрасывает изменённый
autoCommitи откатывает незафиксированную транзакцию при возврате соединения, но полагаться на поведение конкретного пула не стоит. - Короткая транзакция. Пока транзакция открыта, база держит блокировки на изменённых строках. Не ждите внутри транзакции ответа пользователя или внешнего HTTP-сервиса.
Несколько изменений через batch тоже стоит выполнять внутри транзакции: тогда при ошибке в середине пакета откатятся и уже выполненные запросы, а не только упавший.
Вопрос с собеседования
«Что будет, если вызвать commit(), не выключив автофиксацию?» По спецификации JDBC — SQLException. Драйвер MySQL отвечает сообщением Can't call commit when autocommit=true. А setAutoCommit(true) посреди открытой транзакции, наоборот, ошибки не даёт: транзакция молча фиксируется.
4. Savepoint: откат части транзакции
Savepoint — это точка сохранения внутри транзакции. connection.setSavepoint("имя") её ставит, connection.rollback(savepoint) отменяет изменения, сделанные после неё, а то, что было до точки, остаётся в транзакции и фиксируется обычным commit().
Пример 4. Откат до точки сохранения
connection.setAutoCommit(false);
try (PreparedStatement update = connection.prepareStatement(
"UPDATE accounts SET balance = balance + ? WHERE id = ?")) {
update.setBigDecimal(1, new BigDecimal("50.00")); // бонус Анне
update.setInt(2, 1);
update.executeUpdate();
Savepoint afterBonus = connection.setSavepoint("after_bonus");
update.setBigDecimal(1, new BigDecimal("-900.00")); // ошибочное списание у Бориса
update.setInt(2, 2);
update.executeUpdate();
connection.rollback(afterBonus); // отменяем только списание
connection.commit();
} finally {
connection.setAutoCommit(true);
} При балансах 700.00 и 800.00 после этого кода в таблице:
Анна = 750.00, Борис = 800.00 Бонус Анны зафиксирован, списание у Бориса отменено. Обратите внимание: rollback(savepoint) не завершает транзакцию, после него всё равно нужен commit() или полный rollback(). Точки сохранения пригодятся при обработке длинного списка операций, где ошибку в одной операции можно пропустить, не теряя остальные. Поддерживает ли их драйвер, показывает connection.getMetaData().supportsSavepoints(); MySQL (InnoDB), PostgreSQL и Oracle поддерживают.
5. Уровни изоляции в JDBC
Уровень изоляции задаётся методом connection.setTransactionIsolation(int) с одной из констант интерфейса Connection. Он определяет, видит ли транзакция незафиксированные и параллельно зафиксированные изменения других транзакций. Какие аномалии (грязное, неповторяемое, фантомное чтение) допускает каждый уровень, разобрано в уроке Транзакции в SQL.
| Константа Connection | Значение | Уровень SQL | По умолчанию в |
|---|---|---|---|
TRANSACTION_NONE | 0 | Транзакции не поддерживаются | — |
TRANSACTION_READ_UNCOMMITTED | 1 | READ UNCOMMITTED | — |
TRANSACTION_READ_COMMITTED | 2 | READ COMMITTED | PostgreSQL, Oracle, SQL Server |
TRANSACTION_REPEATABLE_READ | 4 | REPEATABLE READ | MySQL (InnoDB) |
TRANSACTION_SERIALIZABLE | 8 | SERIALIZABLE | — |
System.out.println(connection.getTransactionIsolation()); // 4 для MySQL: REPEATABLE READ
connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
connection.setAutoCommit(false);
// ... запросы транзакции
connection.commit(); Уровень меняют до начала транзакции: спецификация JDBC не определяет, что произойдёт, если вызвать setTransactionIsolation посреди открытой транзакции, и драйверы ведут себя по-разному. Новый уровень действует для этого соединения, пока его не поменяют снова, поэтому в пуле его, как и autoCommit, стоит возвращать обратно. Проверить, поддерживает ли база нужный уровень, можно через getMetaData().supportsTransactionIsolationLevel(level).
6. Транзакция через несколько DAO
Транзакция в JDBC принадлежит одному объекту Connection. Если каждый метод DAO сам берёт соединение из пула, как UserDao в уроке DAO и пул соединений в JDBC, два вызова DAO окажутся в разных транзакциях, и откатить их вместе невозможно.
Например, оформление заказа — это orderDao.create(order) и accountDao.debit(userId, sum). Если списание упадёт, заказ уже сохранён своим соединением. Решение без фреймворков — открыть соединение и транзакцию на уровне сервиса и передать это соединение во все методы DAO:
public void placeOrder(Order order) throws SQLException {
try (Connection connection = dataSource.getConnection()) {
connection.setAutoCommit(false);
try {
orderDao.create(connection, order);
accountDao.debit(connection, order.getUserId(), order.getTotal());
connection.commit();
} catch (SQLException e) {
connection.rollback();
throw e;
}
}
} Методы DAO в этом варианте получают Connection параметром и не закрывают его: соединением и транзакцией владеет сервис. Метод setAutoCommit(true) здесь не нужен, если пул сам восстанавливает режим при возврате, как HikariCP; в остальных случаях добавьте finally, как в MoneyTransfer. В Spring ту же задачу решает аннотация @Transactional на методе сервиса: фреймворк привязывает одно соединение к текущему потоку, и все DAO внутри метода работают в одной транзакции.
7. Дедлок и повтор транзакции
Когда две транзакции ждут друг друга (дедлок), база откатывает одну из них, а драйвер бросает SQLTransactionRollbackException — подкласс SQLException с SQLState, начинающимся на 40. Такую транзакцию можно безопасно повторить: её изменения уже отменены целиком.
MySQL при дедлоке возвращает ошибку 1213 со SQLState 40001, и Connector/J бросает именно SQLTransactionRollbackException. Поскольку MoneyTransfer.transfer пробрасывает исходное исключение после отката, повтор пишется в вызывающем коде:
int attempts = 0;
while (true) {
try {
MoneyTransfer.transfer(connection, 1, 2, new BigDecimal("100.00"));
break;
} catch (SQLTransactionRollbackException e) {
if (++attempts == 3) {
throw e; // после трёх попыток сдаёмся
}
}
} Повторяют только транзакции, откатанные базой целиком. Ошибки вроде «недостаточно средств» повторять бессмысленно, поэтому ловится именно SQLTransactionRollbackException, а не любой SQLException. Почему возникают дедлоки и как блокирует строки InnoDB, разобрано в уроке Транзакции в SQL.
8. На чём чаще всего ошибаются
Большинство ошибок с транзакциями в JDBC не приводят к исключению: код работает, а данные сохраняются не тогда или не все. Ниже типичные промахи из код-ревью и вопросов на собеседованиях.
| Ошибка | Что произойдёт | Как исправить |
|---|---|---|
Нет setAutoCommit(false) | Каждый UPDATE фиксируется сразу, rollback() нечего откатывать, а commit() бросает SQLException | Выключать автофиксацию перед первой командой транзакции |
Нет rollback() в catch | Незафиксированные изменения остаются на соединении и фиксируются следующим commit() | rollback() в каждом catch и проброс исключения |
setAutoCommit(false) без commit() | При закрытии соединения MySQL откатывает транзакцию, изменения молча пропадают | commit() в конце успешной ветки |
Проверка баланса отдельным SELECT перед UPDATE | Два параллельных перевода оба видят достаточный баланс, и счёт уходит в минус | Условие в самом UPDATE (AND balance >= ?) или SELECT ... FOR UPDATE |
| Каждый DAO берёт своё соединение | Операции из разных DAO нельзя откатить вместе | Одно соединение на транзакцию, переданное во все DAO, или @Transactional |
CREATE, ALTER, DROP внутри транзакции в MySQL | DDL-команда неявно фиксирует транзакцию, и rollback() после неё уже ничего не отменит | Не смешивать DDL с изменением данных в одной транзакции |
Часто задаваемые вопросы
Начинается ли транзакция в момент вызова setAutoCommit(false)?
Нет. setAutoCommit(false) только меняет режим соединения. Транзакция начинается с первой SQL-команды после него и длится до commit() или rollback(), после которых следующая команда начинает новую транзакцию. Вызывать setAutoCommit(false) перед каждой транзакцией заново не нужно, пока режим не вернули в true.
Нужно ли вызывать commit() после SELECT?
Если автофиксация выключена, да: даже чтение открывает транзакцию, и на уровне REPEATABLE READ она продолжает видеть старый снимок данных, пока её не завершат. Для чтения удобно оставлять autoCommit = true или вызывать connection.setReadOnly(true), чтобы база могла оптимизировать транзакцию только на чтение.
Можно ли объединить в одну транзакцию две разные базы данных?
Обычной JDBC-транзакцией нельзя: она принадлежит одному Connection, то есть одной базе. Для двух баз нужна распределённая транзакция (XA) через менеджер транзакций JTA, например в сервере приложений или через Atomikos. На практике её часто заменяют паттернами вроде Saga, где каждая база фиксирует свою часть, а при ошибке выполняются компенсирующие операции.
Как это связано с @Transactional в Spring?
@Transactional делает те же вызовы JDBC за вас: перед методом берёт соединение и выключает автофиксацию, после успешного выхода вызывает commit(), а при непроверяемом исключении — rollback(). Проверяемые исключения по умолчанию транзакцию не откатывают, это настраивается атрибутом rollbackFor. Понимание ручного кода из этого урока помогает разбираться, почему транзакция в Spring не откатилась.
Практика по теме
Закрепите урок на задачах — у каждой есть уровень и оценка времени.
- Регистрация в одной транзакции: rollback и Savepoint
- DAO магазина на пуле HikariCP и транзакция оформления заказа
Комментарии