Декларативное управление транзакциями через аннотации

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

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

Преимущества декларативного подхода

1. Повышение читаемости кода: код приложения становится чище, так как нам не нужно явно прописывать логику управления транзакциями.
2. Меньше ошибок: риск забыть закрыть транзакцию минимален, ведь этим управляет Spring.
3. Больше времени для важных вещей: вместо борьбы с транзакциями вы можете сосредоточиться на разработке бизнес-логики (или на пицце: решать вам).

Декларативное управление транзакциями в Spring

Теперь рассмотрим, как Spring обеспечивает декларативное управление транзакциями через аннотации. За кулисами работает AOP (аспектно-ориентированное программирование). Spring создаёт прокси-объекты ваших компонентов и добавляет логика управления транзакциями в точки входа методов. Этот подход называется "декларативный", так как мы заявляем (декларируем) параметры транзакции, а Spring делает всё остальное.

Как работает транзакция через @Transactional?

• Когда метод, помеченный аннотацией @Transactional, вызывается, создаётся прокси (заместитель), который управляет транзакцией.
• Прокси перехватывает вызов метода, открывает транзакцию и гарантирует, что в случае исключения транзакция будет откатана.
• Если метод успешно завершается, транзакция фиксируется (committed).

Примерно так выглядит под капотом взаимодействие:

Метод вызывается -> Прокси проверяет @Transactional -> Открывается транзакция ->
-> Выполняется метод -> Успех? commit() : rollback()

Настройка декларативного управления

1. Подключение управления транзакциями

Для включения транзакций в вашем проекте нужно сделать всего пару шагов:

1. Добавьте зависимость на spring-tx в ваш pom.xml или build.gradle (если вы используете Spring Boot, она уже там):

   
   <dependency>
     <groupId>org.springframework</groupId>
     <artifactId>spring-tx</artifactId>
   </dependency>
   

2. Включите поддержку аннотации @Transactional в вашем приложении. Для этого добавьте в конфигурационный класс аннотацию @EnableTransactionManagement:

   
   @Configuration
   @EnableTransactionManagement
   public class AppConfig {
       // Здесь можно настроить bean-ы вашего приложения
   }
   

2. Использование @Transactional в методах

После настройки можно помечать методы аннотацией @Transactional и управлять там транзакциями.

Вот пример:

@Service
public class OrderService {

    @Transactional
    public void createOrder(Order order) {
        // Шаг 1: Сохранение заказа
        orderRepository.save(order);

        // Шаг 2: Обновление баланса пользователя
        userAccountService.decreaseBalance(order.getUserId(), order.getTotalPrice());

        // Искусственно создадим ошибку (например, деление на ноль)
        int error = 1 / 0;

        // Если бы не @Transactional, изменения сохранились бы в базе,
        // но транзакция автоматически откатится из-за исключения.
    }
}

Здесь мы загадочно ломаем код, деля на ноль. Но благодаря аннотации @Transactional всё откатывается! Пользователь не потеряет деньги, а база данных останется в целости.

3. Гибкость настроек @Transactional

Параметры аннотации: @Transactional позволяет указать множество параметров:

• propagation: как транзакция должна вести себя в рамках "вызова методов друг друга".
• isolation: уровень изоляции транзакции (например, READ_COMMITTED, SERIALIZABLE).
• rollbackFor: исключения, при которых должен выполняться откат.
• timeout: тайм-аут транзакции.
• readOnly: если транзакция только читает данные, устанавливаем true.

Пример настройки параметров:

@Transactional(
    propagation = Propagation.REQUIRED,
    isolation = Isolation.SERIALIZABLE,
    timeout = 5,
    rollbackFor = {SQLException.class, CustomException.class},
    readOnly = false
)
public void processOrder(Order order) {
    // Ваш код
}

Пример с propagation

Spring поддерживает несколько типов поведения транзакций. Например:

• REQUIRED: использовать существующую транзакцию или создать новую.
• REQUIRES_NEW: всегда создавать новую транзакцию.
• NESTED: вложенные транзакции.

Пример разного поведения:

@Service
public class PaymentService {

    @Transactional(propagation = Propagation.REQUIRED)
    public void processPayment() {
        // Код для обработки платежа
    }

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logPayment() {
        // Код для логирования транзакции
    }
}

Как Spring реализует декларативное управление? (Под капотом)

Spring использует AOP и создаёт прокси-объект. Это значит, что когда вы вызываете метод с аннотацией @Transactional, реальный вызов происходит через прокси, который добавляет управление транзакцией. Например, метод оборачивается во что-то вроде:

transactionManager.begin();
try {
    method(); // Вызов реального метода
    transactionManager.commit();
} catch (Exception e) {
    transactionManager.rollback();
}

Эта магия позволяет нам избежать ручного управления транзакциями.

Практический пример: управление транзакциями в e-commerce приложении

Давайте создадим простой e-commerce сценарий, где пользователь оформляет заказ. Мы будем использовать @Transactional для управления всеми операциями: сохранение заказа, обновление баланса пользователя.

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    @Autowired
    private UserAccountService userAccountService;

    @Transactional
    public void placeOrder(Order order) {
        // Сохраняем заказ
        orderRepository.save(order);

        // Обновляем баланс пользователя
        userAccountService.decreaseBalance(order.getUserId(), order.getTotalPrice());

        // Искусственное создание ошибки
        if (order.getTotalPrice() > 10000) {
            throw new RuntimeException("Бюджет превышен!");
        }
    }
}

При превышении бюджета транзакция откатывается. Мы остаёмся с целыми данными и довольным пользователем.

Проверяем откат вручную

Вы можете написать тест, чтобы проверить, что данные откатываются при возникновении исключения:

@SpringBootTest
public class OrderServiceTest {

    @Autowired
    private OrderService orderService;

    @Autowired
    private OrderRepository orderRepository;

    @Test
    public void testTransactionRollback() {
        Order order = new Order(/* данные заказа */);

        try {
            orderService.placeOrder(order);
        } catch (RuntimeException e) {
            // Ловим RuntimeException
        }

        // Убеждаемся, что заказ НЕ сохранён в базе
        assertEquals(0, orderRepository.count());
    }
}

Типичные ошибки и подводные камни

1. Не работает @Transactional?
   • Проверьте, включили ли вы @EnableTransactionManagement. Без этого аннотация работать не будет.
   • Убедитесь, что метод с @Transactional вызывается через Spring Bean, иначе прокси не будет использоваться.
2. Не откатывается транзакция?
   • Spring по умолчанию откатывает только RuntimeException. Если вы хотите обработать другие исключения, используйте параметр rollbackFor.
3. Вложенные транзакции могут запутать:
   • Помните, что propagation = REQUIRES_NEW создаёт новую транзакцию, тогда как REQUIRED продолжает текущую.

На этом этапе вы готовы к управлению транзакциями с помощью аннотации @Transactional. Пусть ваши данные всегда будут согласованными, а системы — отказоустойчивыми!