В чем разница между Persistent Context и EntityManager?

# Persistent Context vs EntityManager: Различия и Взаимосвязь

Это вопрос о Hibernate и JPA — одном из наиболее неоднозначных для разработчиков. На самом деле Persistent Context это не объект, а состояние, управляемое EntityManager.

Что такое Persistent Context

Persistent Context — это не класс, а логическое пространство управления состоянием сущностей. Это кэш первого уровня (L1 cache), который отслеживает все загруженные объекты в рамках одной транзакции.

Состояния объекта в Persistent Context

Каждая сущность в Persistent Context находится в одном из 4 состояний:

// 1. TRANSIENT (не управляется контекстом)
User user = new User("John");
// user нигде не сохранен

// 2. MANAGED (управляется контекстом)
User managedUser = entityManager.find(User.class, 1L);
// managedUser отслеживается контекстом, любые изменения будут сохранены

// 3. DETACHED (был управляемым, но отсоединен)
transaction.commit();
// После commit managedUser становится DETACHED

// 4. REMOVED (помечен на удаление)
entityManager.remove(managedUser);
// managedUser в состоянии REMOVED

Что такое EntityManager

EntityManager — это объект (интерфейс JPA), который управляет Persistent Context. Это главный API для работы с БД в JPA.

Основные методы EntityManager

@Repository
public class UserRepository {
    @Autowired
    private EntityManager entityManager;
    
    // Сохранение нового объекта
    public User save(User user) {
        entityManager.persist(user);  // user становится MANAGED
        return user;
    }
    
    // Поиск объекта
    public User findById(Long id) {
        return entityManager.find(User.class, id);  // MANAGED
    }
    
    // Обновление (объект должен быть MANAGED)
    public User update(User user) {
        return entityManager.merge(user);  // переводит DETACHED в MANAGED
    }
    
    // Удаление
    public void delete(Long id) {
        User user = entityManager.find(User.class, id);
        entityManager.remove(user);  // REMOVED -> удаляется при flush
    }
    
    // Refresh из БД
    public void refresh(User user) {
        entityManager.refresh(user);  // перезагружает с БД
    }
}

Persistent Context и EntityManager: Взаимосвязь

Привязка очень простая:

EntityManager = API для управления
Persistent Context = состояние, которым управляет EntityManager

Аналогия:

• EntityManager = водитель
• Persistent Context = автомобиль
• Сущности = пассажиры

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

@Transactional
public void demonstrateLifecycle() {
    // 1. TRANSIENT
    User user = new User("John");
    System.out.println("Is managed: " + entityManager.contains(user)); // false
    
    // 2. MANAGED (сохранение)
    entityManager.persist(user);
    System.out.println("Is managed: " + entityManager.contains(user)); // true
    
    // Изменение отслеживается контекстом
    user.setName("Jane");
    // Не нужно вызывать save(), будет сохранено при commit
    
    // entityManager.flush() — отправляет изменения в БД
    // но транзакция еще не завершена
    entityManager.flush();
    
    // После commit сущность становится DETACHED
} // <-- commit и entityManager.close() здесь

// 3. DETACHED (после закрытия транзакции)
User detachedUser = user; // остался из транзакции выше
detachedUser.setName("Bob");
// Изменение не отслеживается, не будет сохранено!

// 4. MERGE (переведение DETACHED в MANAGED)
@Transactional
public void updateDetached(User detachedUser) {
    User managedUser = entityManager.merge(detachedUser);
    managedUser.setName("Alice");
    // Теперь изменение отслеживается и будет сохранено
}

Ключевые различия в практике

Методы EntityManager для управления состояниями

@Transactional
public void statefulMethods() {
    // PERSIST: TRANSIENT -> MANAGED
    User user = new User();
    entityManager.persist(user);
    
    // MERGE: DETACHED -> MANAGED
    User detached = findAndClose();
    User managed = entityManager.merge(detached);
    
    // FIND: загружает и переводит в MANAGED
    User found = entityManager.find(User.class, 1L);
    
    // REFRESH: перезагружает из БД
    entityManager.refresh(found);
    
    // REMOVE: MANAGED -> REMOVED
    entityManager.remove(found);
    // При flush удалится из БД
}

Проблемы и LazyInitializationException

Проблема 1: LazyInitializationException

public class User {
    @OneToMany(fetch = FetchType.LAZY)
    private List<Post> posts;  // ленивая загрузка
}

@Service
public class UserService {
    @Transactional
    public User getUser(Long id) {
        return entityManager.find(User.class, id);
    }
    
    public void printPosts() {
        User user = getUser(1L);  // транзакция закрывается здесь
        // Ошибка! user.getPosts() вызовет LazyInitializationException
        // потому что posts не загружены и контекст закрыт
        System.out.println(user.getPosts());
    }
}

Решение: open-in-view (антипаттерн)

// application.yml
spring:
  jpa:
    properties:
      hibernate:
        enable_lazy_load_no_trans: true
// или deprecated: spring.jpa.open-in-view=true

Правильное решение: Eager загрузка или JOIN FETCH

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

Практический пример: Spring Data JPA

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Spring создает EntityManager и управляет Persistent Context
}

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public void updateUser(Long id, String newName) {
        // EntityManager управляет контекстом
        User user = userRepository.findById(id).orElseThrow();
        // user MANAGED
        user.setName(newName);
        // При commit это сохранится (dirty checking)
        // userRepository.save() не требуется!
    }
    
    @Transactional(readOnly = true)
    public User getUser(Long id) {
        // readOnly оптимизирует: не отслеживает изменения
        return userRepository.findById(id).orElseThrow();
    }
}

Почему это важно

1. Производительность: Persistent Context кэширует объекты, предотвращая повторные загрузки
2. Dirty Checking: Автоматический поиск измененных объектов и их сохранение
3. Идентичность объектов: Один объект в памяти, несколько ссылок
4. Транзакционность: Все изменения в контексте либо все сохраняются, либо все откатываются

Итог

• EntityManager — это инструмент, контролер, API
• Persistent Context — это управляемое состояние, кэш сущностей в рамках одной транзакции
• Каждая сущность имеет состояние: TRANSIENT, MANAGED, DETACHED, REMOVED
• Понимание этого критично для избежания LazyInitializationException и проблем с производительностью