Исключения в транзакциях и их обработка

Сегодня наша цель — разобраться с исключениями в контексте транзакций. Почему это важно? Потому что сбои случаются, и вам нужно уметь их обрабатывать, чтобы данные в вашей базе не превратились в хаос.

Исключения в мире транзакций

Как программисты, мы живём в мире исключений. Они поджидают нас буквально на каждом углу: от NullPointerException при вызове метода на ни в чём не повинном null до SQLException на ошибках в SQL-запросах. Когда дело доходит до транзакций, исключения становятся ещё более коварными, ведь ошибка может означать, что данные в базе окажутся в неконсистентном состоянии.

Основные виды исключений в транзакциях

В контексте транзакций исключения делятся на два больших лагеря:

1. Системные исключения. Это те неожиданности, которые мы не всегда можем предугадать: например, падение подключения к базе данных (JDBCException), ошибки сети или нехватка памяти в системе. Они приводят к тому, что транзакция должна быть отменена.
2. Прикладные исключения. Это те ошибки, которые мы можем и должны обрабатывать: нарушение бизнес-логики, скажем, превышение лимита на банковском счёте или попытка зарегистрировать пользователя с уже существующим email. Такие исключения могут как требовать отката транзакции, так и нет — в зависимости от контекста.

Как транзакции работают с исключениями в Spring?

В Spring за автоматизацию управления транзакциями отвечает аннотация @Transactional. И когда в рамках метода, аннотированного @Transactional, происходит ошибка, Spring берёт ситуацию под контроль: он либо откатывает транзакцию, либо оставляет изменения в базе данных, если правило таково.

Откат транзакции

Как правило, Spring автоматически откатывает транзакцию, если возникает необработанное исключение типа RuntimeException или Error. Это означает, что если ваш метод выбрасывает, например, NullPointerException или IllegalArgumentException, то все изменения, сделанные в базе, будут откатаны.

Однако checked-исключения (например, SQLException) не вызывают откат по умолчанию. Это связано с тем, что Spring придерживается концепции, что checked-исключения должны быть обработаны в коде вручную.

Примеры обработки исключений

Начнём с базового примера. Допустим, у нас есть сервис для работы с банковскими счетами. Мы хотим списать деньги с одного счёта и зачислить их на другой. В случае ошибки (например, если на исходном счёте недостаточно средств), транзакция должна быть откатана.

@Service
public class BankTransactionService {

    @Autowired
    private AccountRepository accountRepository;

    @Transactional
    public void transferMoney(Long fromAccountId, Long toAccountId, BigDecimal amount) {
        Account fromAccount = accountRepository.findById(fromAccountId)
                .orElseThrow(() -> new RuntimeException("Счёт отправителя не найден"));

        Account toAccount = accountRepository.findById(toAccountId)
                .orElseThrow(() -> new RuntimeException("Счёт получателя не найден"));

        if (fromAccount.getBalance().compareTo(amount) < 0) {
            throw new RuntimeException("Недостаточно средств на счёте отправителя");
        }

        fromAccount.setBalance(fromAccount.getBalance().subtract(amount));
        toAccount.setBalance(toAccount.getBalance().add(amount));

        accountRepository.save(fromAccount);
        accountRepository.save(toAccount);
    }
}

В этом примере, если баланс отправителя меньше запрашиваемой суммы, метод выбросит RuntimeException, и все изменения, внесённые в базу, автоматически откатятся.

Управление откатом через rollbackFor

Если вы хотите, чтобы checked-исключения (например, SQLException) тоже вызывали откат, вам нужно явно указать это с помощью параметра rollbackFor. Вот пример:

@Transactional(rollbackFor = {SQLException.class})
public void performDatabaseOperation() throws SQLException {
    // Действия с базой данных
    throw new SQLException("Ошибка в базе данных");
}

Теперь, если возникнет SQLException, транзакция будет откатана.

Исключения, которые не требуют отката

Иногда вам нужно, чтобы определённые исключения не приводили к откату транзакции, даже если это RuntimeException. Для этого используется параметр noRollbackFor:

@Transactional(noRollbackFor = {IllegalArgumentException.class})
public void processTransaction() {
    // Обработка данных
    throw new IllegalArgumentException("Это исключение не откатит транзакцию");
}

Как гарантировать откат транзакции?

Откат транзакции — это механизм защиты данных. Если метод выбрасывает исключение, Spring гарантирует откат, но есть нюансы:

1. Не оборачивайте транзакционные методы в try-catch, если хотите откат. Если вы ловите исключение и не выбрасываете его снова, Spring считает, что метод успешно завершился, и не откатывает транзакцию.

   
   @Transactional
   public void updateAccount() {
       try {
           // Действия с базой
       } catch (Exception e) {
           // Лог ошибки, но исключение не выбрасывается снова
       }
   }
   

   Здесь транзакция не откатится, даже если возникла ошибка.

2. Помните про внутренние вызовы. Если транзакционный метод вызывает изнутри другой транзакционный метод, то Spring не всегда увидит исключение. Пример неправильного вызова:

   
   @Service
   public class MyService {
   
       @Transactional
       public void methodA() {
           methodB(); // Вызов происходит внутри того же класса
       }
   
       @Transactional
       public void methodB() {
           // Логика
           throw new RuntimeException("Ошибка!");
       }
   }
   

   Здесь транзакция не откатится, потому что methodB() вызывался напрямую, а не через прокси-объект Spring.

Обработка исключений и их логирование

Обрабатывать исключения не только полезно, но и нужно. Вы обязаны как минимум логировать их, иначе во время отладки вы будете проводить больше времени, чем в самой разработке. Вот пример:

@Autowired
private Logger logger;

@Transactional
public void deleteAccount(Long accountId) {
    try {
        accountRepository.deleteById(accountId);
    } catch (DataAccessException e) {
        logger.error("Не удалось удалить запись с ID {}", accountId, e);
        throw e; // либо выбрасываем исключение дальше
    }
}

Типичные ошибки при работе с исключениями в транзакциях

1. Ловить и игнорировать исключения

Если вы обрабатываете исключение и не сигнализируете об ошибке (не выбрасываете исключение дальше), транзакция не откатится. Это может привести к неконсистентному состоянию данных.

2. Использовать транзакции для чтения

Если вы установили @Transactional(readOnly = true) и при этом вносите изменения в базу, это может привести к неожиданным результатам. Например, такие изменения могут быть проигнорированы.

Практическое применение

Транзакции и их обработка критически важны при разработке корпоративного ПО. Представьте себе интернет-магазин: пользователь добавляет товар в корзину, оформляет заказ — и в этот момент транзакция должна гарантировать, что товар зарезервирован, а на складе уменьшилось количество доступных единиц. Если что-то пойдёт не так — никаких частичных операций! Только откат.

На собеседованиях вопросы об обработке исключений и настройке @Transactional встречаются постоянно. Ваши знания помогут вам объяснить, как избегать ошибок, и показать, что вы понимаете тонкости работы системы.

Не забывайте, главное правило транзакций: или всё, или ничего!