Можно ли через Hibernate управлять уровнями транзакций?

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

Да, полностью можно. Hibernate предоставляет несколько способов управления уровнями изоляции транзакций (Transaction Isolation Levels). Это критическая часть работы с конкурентным доступом к данным.

Четыре уровня изоляции ACID

Все они определены в SQL стандарте:

Способ 1: Через конфигурацию Hibernate

В файле hibernate.cfg.xml

<hibernate-configuration>
    <session-factory>
        <!-- Уровень изоляции для всех подключений -->
        <property name="hibernate.connection.isolation">2</property>
        
        <!-- Или используй константы -->
        <!-- 0 = READ_UNCOMMITTED -->
        <!-- 1 = READ_COMMITTED -->
        <!-- 2 = REPEATABLE_READ -->
        <!-- 3 = SERIALIZABLE -->
    </session-factory>
</hibernate-configuration>

В application.properties (Spring Boot)

# REPEATABLE_READ
spring.jpa.properties.hibernate.connection.isolation=2

# Или конкретнее
spring.datasource.hikari.transaction-isolation=REPEATABLE_READ

В application.yml (Spring Boot)

spring:
  jpa:
    properties:
      hibernate:
        connection:
          isolation: 2  # REPEATABLE_READ
  datasource:
    hikari:
      transaction-isolation: REPEATABLE_READ

Способ 2: Через Java код (Session)

import org.hibernate.Session;
import java.sql.Connection;

public class TransactionService {
    
    public void performTransaction(Session session) {
        try {
            // Получаем underlying JDBC connection
            Connection connection = session.doReturningWork(c -> c);
            
            // Устанавливаем уровень изоляции
            connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);
            
            // Начинаем транзакцию
            Transaction tx = session.beginTransaction();
            
            // Наша логика
            User user = session.find(User.class, 1);
            user.setName("Updated");
            session.persist(user);
            
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Способ 3: Через Spring @Transactional

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

@Service
public class UserService {
    
    // READ_COMMITTED
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public User getUser(int id) {
        return userRepository.findById(id).orElse(null);
    }
    
    // REPEATABLE_READ (для критичных операций)
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public void updateUserBalance(int userId, double amount) {
        User user = userRepository.findById(userId).orElseThrow();
        user.setBalance(user.getBalance() + amount);
        userRepository.save(user);
    }
    
    // SERIALIZABLE (максимальная защита, но медленнее)
    @Transactional(isolation = Isolation.SERIALIZABLE)
    public void transferMoney(int fromId, int toId, double amount) {
        User from = userRepository.findById(fromId).orElseThrow();
        User to = userRepository.findById(toId).orElseThrow();
        
        from.setBalance(from.getBalance() - amount);
        to.setBalance(to.getBalance() + amount);
        
        userRepository.save(from);
        userRepository.save(to);
    }
}

Способ 4: Через Hibernate LockMode

Дополнительно к уровням изоляции можно использовать блокировки:

@Service
public class LockingService {
    
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void updateWithLock(int userId) {
        User user = entityManager.find(
            User.class, 
            userId, 
            LockModeType.PESSIMISTIC_WRITE  // Пессимистичная блокировка
        );
        
        // Теперь никто другой не может читать/писать эту строку
        user.setBalance(user.getBalance() + 100);
    }
}

Практический пример: Выбор уровня

@Service
public class OrderService {
    
    // Простое чтение - READ_COMMITTED достаточно
    @Transactional(isolation = Isolation.READ_COMMITTED, readOnly = true)
    public Order getOrder(int id) {
        return orderRepository.findById(id).orElse(null);
    }
    
    // Обновление счетчика - REPEATABLE_READ для защиты
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public void incrementViewCount(int orderId) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        order.setViewCount(order.getViewCount() + 1);
    }
    
    // Платеж - SERIALIZABLE для максимальной безопасности
    @Transactional(isolation = Isolation.SERIALIZABLE)
    public void processPayment(int orderId, BigDecimal amount) {
        Order order = orderRepository.findById(orderId).orElseThrow();
        Account account = order.getAccount();
        
        if (account.getBalance().compareTo(amount) < 0) {
            throw new InsufficientFundsException();
        }
        
        account.setBalance(account.getBalance().subtract(amount));
        order.setStatus("PAID");
        // Сохранить
    }
}

Константы Connection для уровней

Connection.TRANSACTION_NONE;              // 0
Connection.TRANSACTION_READ_UNCOMMITTED;  // 1
Connection.TRANSACTION_READ_COMMITTED;    // 2
Connection.TRANSACTION_REPEATABLE_READ;   // 4
Connection.TRANSACTION_SERIALIZABLE;      // 8

Рекомендации на практике

Для веб-приложений обычно используется READ_COMMITTED:

• Хороший баланс между безопасностью и производительностью
• Защищает от dirty reads
• Достаточен для 99% случаев

Используй REPEATABLE_READ когда:

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

Используй SERIALIZABLE только когда:

• Абсолютно необходима изоляция (платежи, финансы)
• Готов к снижению производительности

Помни о deadlock'ах:

@Transactional(isolation = Isolation.SERIALIZABLE)
public void complexOperation() {
    try {
        // ...
    } catch (DataAccessException e) {
        if (e.getCause() instanceof SQLException) {
            SQLException se = (SQLException) e.getCause();
            if (se.getErrorCode() == 1213) {  // Deadlock
                // Retry логика
                throw new RetryableException(e);
            }
        }
        throw e;
    }
}

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