В каком случае сессия будет закрыта

# В каком случае сессия будет закрыта?

Краткий ответ

Сессия Hibernate будет закрыта в следующих случаях:

1. Явный вызов session.close() — самый явный способ
2. Конец области видимости (scope) — в Spring с аннотацией @Transactional
3. Try-with-resources — автоматическое закрытие
4. Исключение в транзакции — откат и закрытие
5. Программное закрытие SessionFactory — закрывает все сессии

Жизненный цикл Hibernate сессии

Создание → Открыта → Работа → Закрыта

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

1. Явное закрытие сессии

Session session = sessionFactory.openSession();

try {
    User user = session.get(User.class, 1L);
    System.out.println(user.getName());
} finally {
    session.close();  // Явное закрытие
}

Проблема: нужно помнить о try-finally.

2. Try-with-resources (рекомендуется)

// Session реализует AutoCloseable
try (Session session = sessionFactory.openSession()) {
    User user = session.get(User.class, 1L);
    System.out.println(user.getName());
} // Сессия автоматически закроется здесь

Это самый чистый способ в обычном коде.

3. Spring @Transactional (рекомендуется для Spring приложений)

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional  // Spring управляет сессией
    public User getUser(Long id) {
        return userRepository.findById(id).orElse(null);
        // Сессия закроется после выхода из метода
    }
}

Spring автоматически управляет жизненным циклом сессии.

Когда сессия закрывается?

Сценарий 1: Успешное завершение транзакции

@Transactional
public void updateUser(Long id, String name) {
    User user = userRepository.findById(id);
    user.setName(name);
    userRepository.save(user);
    // Здесь:
    // 1. Выполняется commit
    // 2. Сессия закрывается
    // 3. Метод возвращает управление
}

Сценарий 2: Исключение

@Transactional
public void processPayment() {
    User user = userRepository.findById(1L);
    user.setBalance(user.getBalance() - 100);
    
    if (user.getBalance() < 0) {
        throw new IllegalArgumentException("Недостаточно средств");
        // Здесь:
        // 1. Транзакция откатывается (ROLLBACK)
        // 2. Сессия закрывается
        // 3. Исключение пробрасывается
    }
}

Сценарий 3: Явное закрытие в обработчике

public class DataProcessor {
    private SessionFactory sessionFactory;
    
    public void process() {
        Session session = sessionFactory.openSession();
        Transaction tx = null;
        
        try {
            tx = session.beginTransaction();
            
            // Работа с БД
            Query query = session.createQuery("FROM User");
            List<User> users = query.list();
            
            tx.commit();
        } catch (Exception e) {
            if (tx != null) {
                tx.rollback();
            }
            throw e;
        } finally {
            session.close();  // Сессия закроется в любом случае
        }
    }
}

Проблемы с закрытием сессии

Проблема 1: Lazy Loading после закрытия

@Transactional(readOnly = true)  // Сессия закроется после выхода
public User getUser(Long id) {
    return userRepository.findById(id);
    // userRepository возвращает User с коллекциями в состоянии LAZY
}

// В контроллере:
public void handleRequest() {
    User user = userService.getUser(1L);
    // Сессия уже закрыта!
    
    user.getPosts().size();  // ❌ LazyInitializationException!
    // Не можно инициализировать коллекцию - сессия закрыта
}

Решение 1: Eager Loading

@Query("SELECT u FROM User u LEFT JOIN FETCH u.posts WHERE u.id = :id")
User findUserWithPosts(@Param("id") Long id);

Решение 2: Open-in-View паттерн (не рекомендуется)

# application.yml
spring:
  jpa:
    open-in-view: true  # Сессия открыта в течение всего request

Проблема 2: Забыли закрыть сессию

// ❌ Плохо - сессия не закроется
public User loadUser(Long id) {
    Session session = sessionFactory.openSession();
    return session.get(User.class, id);
    // Утечка соединения!
}

// ✅ Хорошо - гарантированное закрытие
public User loadUser(Long id) {
    try (Session session = sessionFactory.openSession()) {
        return session.get(User.class, id);
    }
}

Проблема 3: Статус сессии

Session session = sessionFactory.openSession();

User user = session.get(User.class, 1L);

if (session.isOpen()) {
    System.out.println("Сессия открыта");
}

session.close();

if (session.isOpen()) {
    System.out.println("Сессия открыта");
} else {
    System.out.println("Сессия закрыта");  // Выведется это
}

Детали закрытия сессии

Что происходит при вызове session.close():

1. Отправляются оставшиеся изменения в БД
2. Закрывается соединение (connection.close())
3. Очищается кэш объектов (first-level cache)
4. Освобождаются все ресурсы
5. session.isOpen() возвращает false

Как узнать, открыта ли сессия?

Session session = sessionFactory.openSession();

if (session.isOpen()) {
    System.out.println("Сессия открыта");
}

session.close();

if (!session.isOpen()) {
    System.out.println("Сессия закрыта");
}

// Попытка использовать закрытую сессию
try {
    session.createQuery("FROM User").list();
} catch (IllegalStateException e) {
    System.out.println("Ошибка: " + e.getMessage());
    // "Session is closed"
}

SessionFactory vs Session

// SessionFactory - долгоживущий объект (singleton)
SessionFactory factory = new Configuration().configure()
    .buildSessionFactory();

// Session - кратковременный объект (на один request)
Session session = factory.openSession();
session.close();  // Закрываем сессию

// factory НЕ закрываем (пока приложение работает)
// factory.close();  // Только при завершении приложения

Spring Data JPA подход

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    User findById(Long id);
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public User getUser(Long id) {
        // Spring автоматически управляет сессией
        // Сессия откроется в начале @Transactional метода
        // Сессия закроется в конце метода
        return userRepository.findById(id);
    }
}

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

1. Используй Spring @Transactional — автоматическое управление
2. Try-with-resources для обычного кода — явное управление
3. Никогда не забывай закрывать сессию — используй try или аннотации
4. Проверяй session.isOpen() — при отладке
5. Не используй opened-in-view — может привести к проблемам с производительностью
6. Поймай LazyInitializationException — нужно загружать данные в открытой сессии

Выводы

• Сессия закрывается явно (session.close()) или автоматически (@Transactional, try-with-resources)
• Закрытие происходит после завершения операции (успешно или с ошибкой)
• После закрытия сессии нельзя использовать её объекты
• Spring управляет сессиями автоматически для @Transactional методов
• Утечки соединений происходят, когда забыли закрыть сессию