Как можно закрыть транзацию в Hibernate?

Как можно закрыть транзакцию в Hibernate

В Hibernate транзакция является критическим элементом работы с БД. Существует несколько способов управления транзакциями и их закрытием.

1. Явное управление транзакцией (commit/rollback)

Самый базовый и явный способ:

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

public class TransactionExample {
    private SessionFactory sessionFactory;
    
    public void saveUser(User user) {
        Session session = sessionFactory.openSession();
        Transaction transaction = null;
        
        try {
            transaction = session.beginTransaction();
            session.save(user);
            transaction.commit();  // Фиксируем изменения
        } catch (Exception e) {
            if (transaction != null && transaction.isActive()) {
                transaction.rollback();  // Откатываем при ошибке
            }
            throw new RuntimeException("Ошибка сохранения пользователя", e);
        } finally {
            session.close();  // Закрываем сессию
        }
    }
}

2. Try-with-resources (автоматическое закрытие)

Морновнее и безопаснее (Java 7+):

public void updateUser(User user) throws Exception {
    try (Session session = sessionFactory.openSession()) {
        Transaction transaction = session.beginTransaction();
        try {
            session.merge(user);
            transaction.commit();
        } catch (Exception e) {
            transaction.rollback();
            throw e;
        }
        // session.close() вызывается автоматически
    }
}

3. Try-with-resources с обеими ресурсами

Закрытие сессии и транзакции одновременно:

public void processUsers(List<User> users) throws Exception {
    try (Session session = sessionFactory.openSession();
         Transaction transaction = session.beginTransaction()) {
        for (User user : users) {
            session.persist(user);
        }
        transaction.commit();
        // Обе переменные закрываются автоматически
    }
}

4. Spring Transactional (декоративный подход)

В Spring Framework рекомендуется использовать аннотацию:

import org.springframework.transaction.annotation.Transactional;

@Service
public class UserService {
    
    @Transactional
    public void saveUser(User user) {
        userRepository.save(user);
        // Транзакция автоматически коммитится в конце метода
    }
    
    @Transactional(rollbackFor = Exception.class)
    public void updateMultipleUsers(List<User> users) {
        for (User user : users) {
            userRepository.save(user);
        }
        // На исключение выполняется rollback
    }
    
    @Transactional(readOnly = true)
    public List<User> getAllUsers() {
        return userRepository.findAll();
        // Оптимизация для только-читающих операций
    }
}

5. Flush и commit

Разница между flush и commit:

public class FlushCommitExample {
    public void demonstrateDifference() {
        try (Session session = sessionFactory.openSession();
             Transaction transaction = session.beginTransaction()) {
            
            User user = new User("John");
            session.save(user);
            
            // flush() — отправляет SQL в БД, но не коммитит транзакцию
            session.flush();
            // В этот момент SQL выполнен, но можем откатить
            
            // commit() — завершает транзакцию, делает изменения постоянными
            transaction.commit();
            // Изменения теперь постоянны
        }
    }
}

6. AutoCommit режим

Для операций без транзакции:

public void directQuery() {
    try (Session session = sessionFactory.openSession()) {
        // Без transaction.begin() — используется autocommit режим
        User user = session.get(User.class, 1L);
        // Но изменения не будут сохранены без явного commit!
    }
}

7. Закрытие сессии

Способы закрыть сессию:

Session session = sessionFactory.openSession();

// Способ 1: close() — закрывает и коммитит активную транзакцию
session.close();

// Способ 2: disconnect() — отсоединяет от БД, но не закрывает
session.disconnect();

// Способ 3: evict() — удаляет объект из кэша
session.evict(user);

// Способ 4: clear() — очищает весь кэш сессии
session.clear();

8. Практический пример: batch операции

@Service
public class BatchProcessingService {
    
    @Transactional
    public void saveLargeDataset(List<User> users) {
        for (int i = 0; i < users.size(); i++) {
            userRepository.save(users.get(i));
            
            // Каждые 20 записей flush кэш
            if ((i + 1) % 20 == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
        // Транзакция коммитится в конце метода
    }
}

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

@Service
public class IsolationLevelExample {
    
    @Transactional(isolation = Isolation.READ_COMMITTED)
    public void readData() {
        // Можем читать только коммитнутые данные
    }
    
    @Transactional(isolation = Isolation.REPEATABLE_READ)
    public void criticalRead() {
        // Более строгая изоляция
    }
    
    @Transactional(isolation = Isolation.SERIALIZABLE)
    public void mostStrict() {
        // Максимальный уровень изоляции
    }
}

10. Откат при исключении

@Service
public class RollbackExample {
    
    @Transactional(rollbackFor = CustomException.class)
    public void processWithCustomException(Data data) throws CustomException {
        // При CustomException выполняется rollback
        if (data.isInvalid()) {
            throw new CustomException("Данные невалидны");
        }
    }
    
    @Transactional(noRollbackFor = WarningException.class)
    public void processWithWarning(Data data) throws WarningException {
        // WarningException не вызовет rollback
        if (data.hasWarning()) {
            throw new WarningException("Предупреждение");
        }
    }
}

11. Проверка статуса транзакции

public void checkTransactionStatus() {
    try (Session session = sessionFactory.openSession()) {
        Transaction transaction = session.beginTransaction();
        
        // Проверка активности
        if (transaction.isActive()) {
            System.out.println("Транзакция активна");
        }
        
        // Проверка успешно ли коммитнулась
        transaction.commit();
        if (!transaction.isActive()) {
            System.out.println("Транзакция закрыта");
        }
    }
}

12. Best Practices

@Service
public class BestPractices {
    
    // Всегда используйте @Transactional в Spring
    @Transactional
    public void createOrder(Order order) {
        // Код здесь в одной транзакции
    }
    
    // Держите транзакции короткими
    @Transactional
    public void quickOperation() {
        // Минимум логики в транзакции
    }
    
    // Используйте readOnly для запросов без изменений
    @Transactional(readOnly = true)
    public List<Order> getOrders() {
        return orderRepository.findAll();
    }
    
    // Явно управляйте batch операциями
    @Transactional
    public void bulkInsert(List<Item> items) {
        for (int i = 0; i < items.size(); i++) {
            itemRepository.save(items.get(i));
            if ((i + 1) % 100 == 0) {
                entityManager.flush();
                entityManager.clear();
            }
        }
    }
}

Сравнение способов закрытия

Заключение

В современных Spring приложениях используйте @Transactional аннотацию — это проще и безопаснее. Для низкоуровневого управления используйте try-with-resources. Всегда помните: забытое commit() или rollback() может привести к deadlock или утечкам ресурсов!