Какие знаешь принципы транзакций?

Принципы транзакций: ACID и их реализация

Транзакция — это последовательность операций с базой данных, которые либо все выполняются успешно, либо откатываются полностью. Основные принципы определены аббревиатурой ACID.

ACID принципы

A — Atomicity (Атомарность)

Транзакция либо полностью выполняется, либо полностью откатывается. Невозможно состояние "половинного" выполнения.

// Пример: перевод денег со счёта на счёт
@Transactional
public void transferMoney(Account from, Account to, BigDecimal amount) {
    from.withdraw(amount);  // Операция 1
    to.deposit(amount);     // Операция 2
    // Обе операции либо выполнены, либо откачены
}

Если между операциями произойдёт ошибка, обе операции откатятся.

C — Consistency (Непротиворечивость)

База данных переходит из одного консистентного состояния в другое консистентное состояние. Все ограничения целостности (constraints) остаются выполненными.

ALTER TABLE orders ADD CONSTRAINT fk_user_id FOREIGN KEY (user_id) REFERENCES users(id);

I — Isolation (Изоляция)

Одновременные транзакции не должны влиять друг на друга. Используются уровни изоляции.

Уровни изоляции (от слабого к сильному)

1. READ UNCOMMITTED — самый слабый

   • Одна транзакция может читать грязные данные (uncommitted changes) другой
   • Проблема: dirty read

2. READ COMMITTED — по умолчанию в большинстве БД

   • Можно читать только закоммиченные данные
   • Проблема: non-repeatable read

3. REPEATABLE READ — повторное чтение гарантировано

   • Если прочитаешь данные дважды в одной транзакции — получишь одно и то же
   • Проблема: phantom read

4. SERIALIZABLE — самый сильный

   • Транзакции выполняются как если бы они выполнялись последовательно
   • Максимальная безопасность, минимальная производительность

D — Durability (Долговечность)

После успешного commit транзакции данные постоянно сохранены даже при сбое сервера.

@Transactional
public void saveUser(User user) {
    userRepository.save(user); // После commit сохранено навсегда
}

Реализация транзакций в Spring

// Простейший вариант
@Transactional
public void processPayment(Payment payment) {
    paymentRepository.save(payment);
    // Автоматический commit при успехе
}

// С явным управлением
@Transactional(propagation = Propagation.REQUIRED)
public void transferMoney(Account from, Account to, BigDecimal amount) {
    from.withdraw(amount);
    to.deposit(amount);
}

// С настройкой уровня изоляции
@Transactional(isolation = Isolation.READ_COMMITTED)
public Account getAccount(Long id) {
    return accountRepository.findById(id).orElseThrow();
}

Propagation (распространение транзакций)

• REQUIRED — использовать существующую или создать новую
• REQUIRES_NEW — всегда создать новую
• NESTED — вложенная транзакция (savepoint)
• NOT_SUPPORTED — выполнить без транзакции

Типичные проблемы

N+1 во время транзакции

// Плохо: Lazy loading в цикле
@Transactional
public void processUsers() {
    List<User> users = userRepository.findAll();
    for (User user : users) {
        List<Post> posts = user.getPosts(); // N дополнительных запросов
    }
}

// Хорошо: Eager loading
@Transactional(readOnly = true)
public void processUsers() {
    List<User> users = userRepository.findAllWithPosts();
}

Deadlock

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

Лучшие практики

• Транзакция должна быть как можно короче — минимизируй время блокировок
• Используй readOnly = true для операций чтения — оптимизация производительности
• Избегай вложенных транзакций — увеличивает сложность
• Логируй состояние транзакций — помогает в отладке
• Обработай исключения корректно — distinguish между recoverable и non-recoverable ошибками

Транзакции — это фундамент надёжности в приложениях с базами данных и обеспечивают консистентность данных.