Что такое transaction management в Hibernate?

Что такое transaction management в Hibernate?

Transaction management в Hibernate — это механизм управления транзакциями для обеспечения консистентности данных в БД. Транзакция — это набор операций (INSERT, UPDATE, DELETE), который либо полностью завершается успешно (commit), либо полностью откатывается (rollback).

Это реализует принцип ACID (Atomicity, Consistency, Isolation, Durability).

ACID свойства

• Atomicity — все или ничего: либо все операции выполнены, либо ни одна
• Consistency — данные переходят из одного консистентного состояния в другое
• Isolation — одновременные транзакции не мешают друг другу
• Durability — после commit данные сохранены даже при сбое

Управление транзакциями в Hibernate

1. Программный подход (Manual)

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

public class TransactionManagement {
    private SessionFactory sessionFactory;
    
    public void saveUser(User user) {
        Session session = sessionFactory.openSession();
        Transaction transaction = null;
        
        try {
            // Начало транзакции
            transaction = session.beginTransaction();
            
            // Выполнение операций
            session.save(user);
            
            // Подтверждение транзакции
            transaction.commit();
            System.out.println("User saved successfully");
            
        } catch (Exception e) {
            // Откат при ошибке
            if (transaction != null) {
                transaction.rollback();
            }
            System.err.println("Error saving user: " + e.getMessage());
            
        } finally {
            session.close();
        }
    }
}

Transaction Propagation в Spring

В Spring используется аннотация @Transactional:

import org.springframework.transaction.annotation.Transactional;

public class UserService {
    
    @Transactional
    public void registerUser(User user) {
        // Транзакция автоматически создаётся и коммитится
        userRepository.save(user);
        emailService.sendWelcomeEmail(user.getEmail());
    }
    
    @Transactional(readOnly = true)
    public User getUserById(Long id) {
        // Read-only транзакция (оптимизация)
        return userRepository.findById(id).orElse(null);
    }
    
    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public void logAction(String action) {
        // Новая транзакция, независимо от внешней
        auditRepository.save(new AuditLog(action));
    }
}

Уровни изоляции (Isolation Levels)

Определяют, как одновременные транзакции видят изменения друг друга:

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Transactional;

public class IsolationExamples {
    
    // 1. READ_UNCOMMITTED — грязное чтение (dirty read)
    @Transactional(isolation = Isolation.READ_UNCOMMITTED)
    public void readUncommitted() {
        // Можно прочитать незакоммиченные данные от других транзакций
    }
    
    // 2. READ_COMMITTED — читать только закоммиченные данные
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void readCommitted() {
        // Стандартный уровень для большинства БД
    }
    
    // 3. REPEATABLE_READ — повторяемое чтение
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public void repeatableRead() {
        // Одно и то же значение прочитается одинаково в транзакции
    }
    
    // 4. SERIALIZABLE — полная изоляция
    @Transactional(isolation = Isolation.SERIALIZABLE)
    public void serializable() {
        // Транзакции выполняются последовательно
        // Медленно, но полная безопасность
    }
}

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

import org.springframework.transaction.annotation.Transactional;

public class ExceptionHandling {
    
    @Transactional(rollbackFor = Exception.class)
    public void processPayment(Payment payment) {
        // Откатит при ЛЮБОМ исключении
        accountRepository.debit(payment.getFromAccount(), payment.getAmount());
        accountRepository.credit(payment.getToAccount(), payment.getAmount());
    }
    
    @Transactional(noRollbackFor = InvalidAmountException.class)
    public void transferMoney(Account from, Account to, BigDecimal amount) {
        // Не откатывает при InvalidAmountException
        if (amount.compareTo(BigDecimal.ZERO) <= 0) {
            throw new InvalidAmountException("Amount must be positive");
        }
        
        from.withdraw(amount);
        to.deposit(amount);
    }
}

Transaction Manager

Hibernate работает с PlatformTransactionManager:

import org.springframework.context.annotation.Bean;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import javax.sql.DataSource;

public class TransactionConfig {
    
    @Bean
    public HibernateTransactionManager transactionManager(
            LocalSessionFactoryBean sessionFactory, DataSource dataSource) {
        HibernateTransactionManager tm = new HibernateTransactionManager();
        tm.setSessionFactory(sessionFactory.getObject());
        return tm;
    }
}

Lazy Loading и Транзакции

Частая проблема — LazyInitializationException:

@Entity
public class User {
    @OneToMany(fetch = FetchType.LAZY)
    private List<Order> orders;
}

// ❌ Проблема: orders инициализируется вне транзакции
@Transactional
public void loadUser(Long userId) {
    User user = userRepository.findById(userId);
    return user; // orders не загружены
}

public void processUser() {
    User user = loadUser(1L);
    // ❌ LazyInitializationException при доступе к orders!
    int orderCount = user.getOrders().size();
}

// ✅ Решение 1: Eager loading
@Query("SELECT u FROM User u LEFT JOIN FETCH u.orders WHERE u.id = :id")
User findUserWithOrders(@Param("id") Long id);

// ✅ Решение 2: Явная инициализация в транзакции
@Transactional
public User loadUserWithOrders(Long userId) {
    User user = userRepository.findById(userId);
    Hibernate.initialize(user.getOrders()); // Инициализирует
    return user;
}

Deadlocks и оптимистичные блокировки

import javax.persistence.Version;

@Entity
public class Account {
    @Id
    private Long id;
    
    private BigDecimal balance;
    
    @Version // Оптимистичная блокировка
    private Long version;
}

// Hibernate отслеживает версию и предотвращает конфликты
@Transactional
public void transfer(Long fromId, Long toId, BigDecimal amount) {
    Account from = accountRepository.findById(fromId);
    Account to = accountRepository.findById(toId);
    
    from.withdraw(amount);
    to.deposit(amount);
    
    // При save Hibernate проверит версию
    // Если кто-то изменил Account — выбросит OptimisticLockingFailureException
}

Batch операции

@Transactional
public void saveManyUsers(List<User> users) {
    for (int i = 0; i < users.size(); i++) {
        userRepository.save(users.get(i));
        
        // Flush каждые 20 записей для оптимизации памяти
        if (i % 20 == 0) {
            entityManager.flush();
            entityManager.clear();
        }
    }
}

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

1. Минимизируй scope транзакции — открывай её в самом узком месте
2. Избегай долгих транзакций — не держи блокировки долго
3. Используй read-only — для операций только чтения
4. Обрабатывай исключения — правильно откатывай на ошибках
5. Мониторь deadlocks — проверяй логи БД
6. Тестируй транзакции — используй @Transactional в тестах
7. Профилируй — проверяй, сколько времени занимают операции

Transaction management в Hibernate — критически важный механизм для надёжной работы приложения.