Обзор

Каждая сущность в Hibernate проходит через определённые состояния (жизненный цикл) в процессе взаимодействия с базой данных. Понимание жизненного цикла критически важно для правильного использования Hibernate и предотвращения ошибок.

Зачем это знать: чтобы понимать какой метод вызывать (persist или merge), почему изменения сохраняются сами (dirty checking), почему возникает «detached entity passed to persist».

---

🟢 Junior Level

4 состояния Entity

Сущность в Hibernate может находиться в одном из четырёх состояний:

1. Transient (Новый / Временный) — создан через new, ещё не в БД
2. Persistent (Управляемый) — сохранён в БД, отслеживается Hibernate
3. Detached (Отсоединённый) — был в БД, но сессия закрыта
4. Removed (Удалённый) — помечен на удаление, будет удалён при flush

new User() ──persist()──→ Managed ──close()──→ Detached
                             │
                          remove()
                             ↓
                          Removed

Пример

// 1. Transient — новый объект, не в БД
User user = new User();
user.setName("John");

// 2. Persistent — сохранён, отслеживается
entityManager.persist(user);
// Теперь user в БД и под управлением Hibernate

// 3. Detached — сессия закрыта
entityManager.close();
// user всё ещё существует в памяти, но Hibernate больше не следит

// 4. Removed — помечен на удаление
entityManager.remove(user);
// При flush/commit будет выполнен DELETE

---

🟡 Middle Level

persist() vs merge()

Операция	Transient	Detached	Persistent
persist()	INSERT	ОШИБКА	ОШИБКА
merge()	SELECT+INSERT	SELECT+UPDATE	SELECT (бесполезно)

Переходы между состояниями

Transient → Persistent:  persist(), merge()
Persistent → Detached:   close(), clear(), detach()/evict()
Detached → Persistent:   merge(), update()
Persistent → Removed:    remove()
Transient → Detached:    (невозможно напрямую)

Детальное описание операций

// persist() — для новых сущностей (INSERT)
User newUser = new User();
entityManager.persist(newUser);
// newUser теперь Persistent

// merge() — для detached сущностей (UPDATE)
User detached = getDetachedUser();
User managed = entityManager.merge(detached);
// managed — новая управляемая копия
// detached остаётся detached!

// remove() — для удаления (DELETE)
entityManager.remove(managedUser);
// При flush будет выполнен DELETE

// refresh() — перезагрузить из БД
entityManager.refresh(user);
// Обновляет данные из БД, перезаписывая изменения в памяти

// detach()/evict() — отсоединить. evict() — Hibernate-specific (Session). detach() — JPA-стандарт (EntityManager). Используйте detach() для переносимости.
entityManager.detach(user);
// user становится Detached

// clear() — отсоединить все
entityManager.clear();
// Все сущности становятся Detached

Dirty Checking

Dirty checking — Hibernate автоматически отслеживает изменения объектов. Вы просто меняете поле — Hibernate сам делает UPDATE.

@Transactional
public void updateUser(Long id, String name) {
    User user = entityManager.find(User.class, id);  // Persistent
    user.setName(name);
    // НЕ НУЖЕН em.merge() или em.save()!
    // Hibernate автоматически обнаружит изменение и сделает UPDATE
}

Типичные ошибки

// ❌ Detached entity passed to persist
User user = new User();
user.setId(1L);  // ID уже установлен
entityManager.persist(user);  // ❌ EntityExistsException или ошибка

// ✅ Правильно: merge() для detached
User merged = entityManager.merge(user);

// ❌ merge() для новой сущности (лишний SELECT)
User newUser = new User();
entityManager.merge(newUser);  // Сначала SELECT, потом INSERT

// ✅ Правильно: persist() для новых
entityManager.persist(newUser);  // Сразу INSERT

// ❌ merge() для persistent (бесполезно)
User user = entityManager.find(User.class, 1L);  // Persistent
User merged = entityManager.merge(user);  // Лишний SELECT

---

🔴 Senior Level

Внутренняя реализация

Persistence Context — контейнер для всех managed сущностей в рамках EntityManager. EntityEntry — запись внутри Persistence Context, хранит текущее состояние и snapshot. Snapshot — копия состояния объекта на момент загрузки, используется для dirty checking.

Persistence Context (StatefulPersistenceContext):

EntityManagerImpl {
    persistenceContext: StatefulPersistenceContext {
        entitiesByKey: Map<EntityKey, Object>,     // cache by ID
        entityEntries: Map<Object, EntityEntry>,   // state tracking
    }
}

EntityEntry хранит:
- snapshot — состояние при загрузке (для dirty checking)
- status — текущее состояние (MANAGED, DELETED, etc.)
- loadedState — состояние при загрузке из БД

Dirty checking механизм

1. При загрузке: Hibernate сохраняет snapshot entity
2. При изменении: меняется поле в объекте
3. При flush: Hibernate сравнивает snapshot с текущим состоянием
4. Если разные → генерирует UPDATE SQL
5. Обновляет snapshot

Алгоритм:
- O(N) где N = число entities в persistence context
- Для больших контекстов может быть медленно
- Решение: entityManager.clear() периодически

Управление памятью при больших операциях

@Transactional
public void batchProcess(List<User> users) {
    for (int i = 0; i < users.size(); i++) {
        entityManager.merge(users.get(i));

        // Периодическая очистка persistence context
        if (i % 50 == 0) {
            entityManager.flush();    // сбросить в БД
            entityManager.clear();    // очистить кэш
        }
    }
}

После clear() все ранее загруженные/созданные объекты становятся detached. Если цикл продолжается — следующие итерации работают с новыми объектами, старые теряются (и при обращении к ним потребуется merge()).

Best Practices

✅ persist() для новых сущностей
✅ merge() для detached сущностей
✅ remove() для удаления
✅ Dirty checking для обновлений (не нужен merge)
✅ entityManager.clear() для пакетных операций
✅ flush + clear каждые 50-100 entities

❌ persist() для detached (ошибка)
❌ merge() для новых (лишний SELECT)
❌ merge() для persistent (лишний SELECT)
❌ Игнорирование состояний сущностей
❌ Загрузка большого количества entities без clear

---

🎯 Шпаргалка для интервью

Обязательно знать:

• 4 состояния: Transient (new), Persistent (managed), Detached (в БД, но не tracked), Removed (помечен на удаление)
• persist() — для новых (INSERT), merge() — для detached (UPDATE/INSERT)
• Dirty checking: Hibernate автоматически отслеживает изменения managed-сущностей
• Persistence Context — контейнер для всех managed сущностей, хранит snapshot для dirty checking
• merge() возвращает НОВЫЙ managed объект, оригинал остаётся detached
• entityManager.clear() очищает persistence context, все сущности становятся detached

Частые уточняющие вопросы:

• Почему persist() для новых лучше merge()? persist() = сразу INSERT, merge() = сначала SELECT (проверка)
• Что такое snapshot? Копия состояния при загрузке, используется для dirty checking при flush
• Как обработать 10k+ сущностей? persist/merge + flush + clear каждые 50-100 entities
• Почему merge() возвращает новый объект? Потому что оригинал может быть detached, Hibernate создаёт managed копию

Красные флаги (НЕ говорить):

• «Использую merge() для новых сущностей» — лишний SELECT
• «Игнорирую return value merge()» — изменения не сохранятся
• «persist() для detached с ID» — EntityExistsException
• «Не чищу persistence context при batch» — OutOfMemoryError

Связанные темы:

• [[8. Что такое состояния transient, persistent, detached, removed]]
• [[12. Что такое dirty checking в Hibernate]]
• [[13. Как работает механизм flush в Hibernate]]
• [[14. В чём разница между persist() и merge()]]
• [[9. Что такое кэш первого уровня в Hibernate]]