Что такое Persistence Context?

# Persistence Context в JPA

Persistence Context — это управляемый ORM контекст, который отслеживает состояние сущностей (entities) и синхронизирует их с базой данных. Это ключевое понятие в JPA (Java Persistence API) и Hibernate.

Что такое Persistence Context

Persistence Context — это "кэш первого уровня" (first-level cache) в ORM, который:

• Отслеживает все загруженные из БД сущности
• Следит за изменениями их состояния
• Синхронизирует изменения с БД при коммите транзакции
• Обеспечивает идентичность объектов (один объект = один экземпляр в памяти)

Жизненный цикл сущности

// Состояния сущности в Persistence Context:

// 1. NEW (Transient) — объект создан, но не в контексте
User user = new User("John");

// 2. MANAGED — объект загружен или сохранён в контексте
User managedUser = entityManager.find(User.class, 1L);

// 3. DETACHED — объект был в контексте, но контекст закрыт
Session session = sessionFactory.openSession();
User detachedUser = session.load(User.class, 1L);
session.close(); // user становится DETACHED

// 4. REMOVED — объект удалён из контекста
entityManager.remove(managedUser);

Пример работы Persistence Context

public class PersistenceContextExample {
    private EntityManager entityManager;
    
    public void demonstrateContext() {
        // Шаг 1: загрузка сущности
        User user1 = entityManager.find(User.class, 1L);
        User user2 = entityManager.find(User.class, 1L);
        
        // user1 и user2 указывают на ОДИН объект в памяти
        // (благодаря Persistence Context)
        System.out.println(user1 == user2); // true!
        
        // Шаг 2: изменение сущности
        user1.setName("Jane");
        
        // Изменение отслеживается контекстом
        // Синхронизация произойдёт при коммите транзакции
        
        // Шаг 3: коммит
        entityManager.getTransaction().begin();
        entityManager.getTransaction().commit();
        // Здесь выполнится UPDATE запрос
    }
}

Важные операции

public class PersistenceContextOperations {
    private EntityManager em;
    
    // Загрузка в контекст
    public void loadEntity() {
        User user = em.find(User.class, 1L); // MANAGED
    }
    
    // Сохранение нового объекта
    public void persistEntity() {
        User user = new User("John");
        em.persist(user); // теперь MANAGED
        // будет INSERT при коммите
    }
    
    // Слияние DETACHED объекта
    public void mergeEntity(User detachedUser) {
        User managedUser = em.merge(detachedUser);
        // detachedUser становится MANAGED
    }
    
    // Удаление объекта
    public void removeEntity(User user) {
        em.remove(user); // user становится REMOVED
        // будет DELETE при коммите
    }
    
    // Явная синхронизация
    public void flushChanges() {
        em.flush(); // отправляет все изменения в БД
        // но не коммитит транзакцию
    }
    
    // Очистка контекста
    public void clearContext() {
        em.clear(); // все объекты становятся DETACHED
    }
}

Практические примеры

public class PersistenceContextExamples {
    @Autowired
    private EntityManager entityManager;
    
    // Пример 1: Dirty checking (автоматическое отслеживание изменений)
    @Transactional
    public void updateUser(Long id, String newName) {
        User user = entityManager.find(User.class, id);
        user.setName(newName);
        // UPDATE выполнится автоматически при коммите
        // explicit entityManager.persist() не нужна!
    }
    
    // Пример 2: LazyInitializationException
    public void lazyLoadingProblem() {
        User user;
        try (Session session = sessionFactory.openSession()) {
            user = session.get(User.class, 1L); // MANAGED
        } // session закрылся, user теперь DETACHED
        
        // ❌ Exception! контекст закрыт
        // user.getOrders().size();
    }
    
    // Пример 3: Использование EAGER loading
    @Entity
    public class User {
        @Id
        private Long id;
        
        @OneToMany(fetch = FetchType.EAGER)
        private List<Order> orders;
    }
    
    // Пример 4: Контроль размера контекста
    @Transactional
    public void processLargeDataset() {
        List<User> users = userRepository.findAll();
        
        for (User user : users) {
            processUser(user);
            entityManager.flush();
            entityManager.clear(); // очищаем контекст каждую итерацию
            // иначе контекст будет содержать ВСЕ объекты в памяти
        }
    }
}

Ключевые понятия

Проблемы и решения

1. LazyInitializationException — загрузка коллекций после закрытия контекста

   • Решение: EAGER loading или запрос в пределах сессии

2. OutOfMemoryException — контекст содержит слишком много объектов

   • Решение: периодически вызывать clear() и flush()

3. Stale data — работа с DETACHED объектами

   • Решение: использовать merge() для синхронизации

Persistence Context — это мощный инструмент для работы с базой данных, но требует понимания жизненного цикла объектов.