JDBC ·
‹ Предыдущий Следующий ›
⏱ 5 минут чтения Обновлено: 2026-11-21

Транзакции в 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 не откатилась.

Практика по теме

Закрепите урок на задачах — у каждой есть уровень и оценка времени.

Все задачи модуля →

Комментарии

Зарегистрируйтесь или войдите, чтобы иметь возможность оставить комментарий.