[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"question-hibernate-zhiznennyy-tsikl-entity-v-hibernate":3},{"id":4,"slug":5,"topicId":6,"topicSlug":7,"topicName":8,"topicEmoji":9,"question":10,"answer":11,"codeLang":12,"codeSrc":12,"important":12,"commonMistakes":12,"modernUsage":12,"difficulty":13,"tags":14,"related":18,"progress":19,"seo":20},751,"zhiznennyy-tsikl-entity-v-hibernate",19,"hibernate","Hibernate","🐻","Жизненный цикл Entity в Hibernate","Сущность (Entity) в Hibernate проходит через четыре состояния в рамках Persistence Context.\n\n> Аналогия из жизни: представьте отдел кадров. Transient — человек, о котором отдел кадров ничего не знает. Persistent — оформленный сотрудник, за которым ведётся наблюдение. Detached — уволившийся, но его личное дело осталось в архиве. Removed — дело помечено на удаление из архива.\n\n### Четыре состояния\n\n1. Transient (Новый) — объект создан через `new`, не связан с Persistence Context и не имеет представления в БД:\n\n```java\nUser user = new User(\"John\", \"john@example.com\"); \u002F\u002F Transient\n\u002F\u002F Hibernate ничего не знает об этом объекте\n```\n\n2. Persistent (Управляемый) — объект связан с Persistence Context и имеет представление в БД. Все изменения автоматически синхронизируются с БД при flush\u002Fcommit:\n\n```java\nsession.persist(user);              \u002F\u002F Transient → Persistent\nUser found = session.find(User.class, 1L); \u002F\u002F Persistent (загружен из БД)\n\nfound.setName(\"Jane\");              \u002F\u002F изменение автоматически попадёт в БД (Dirty Checking)\n```\n\n3. Detached (Отсоединённый) — объект имеет представление в БД, но не связан с текущим Persistence Context:\n\n```java\nsession.close();                    \u002F\u002F все сущности → Detached\nsession.detach(user);               \u002F\u002F конкретная сущность → Detached\nsession.evict(user);                \u002F\u002F Hibernate API — то же самое\n\n\u002F\u002F Detached объект можно вернуть в Persistent:\nsession.merge(user);                \u002F\u002F Detached → Persistent (копирование состояния)\n```\n\n4. Removed (Удалённый) — объект помечен для удаления, будет удалён из БД при flush\u002Fcommit:\n\n```java\nsession.remove(user);               \u002F\u002F Persistent → Removed\n\u002F\u002F DELETE будет выполнен при flush\u002Fcommit\n```\n\n### Диаграмма переходов\n\n```\n         new()          persist()\n[Нет] ────────→ [Transient] ────────→ [Persistent] ←──── find()\u002Fload()\u002Fquery\n                     │                    │   ↑\n                     │              detach()\u002F  merge()\n                     │              close()    │\n                     │                    ↓   │\n                     │              [Detached]\n                     │                    │\n                     │                remove()\n                     │                    ↓\n                     └──────────→ [Removed] ────→ DELETE в БД\n```\n\n### Важное\n\n- Persistent — единственное состояние, в котором Hibernate отслеживает изменения\n- `persist()` — Transient → Persistent, `merge()` — Detached → Persistent (копия), `remove()` — Persistent → Removed\n- Dirty Checking работает только для Persistent-объектов: изменение поля автоматически генерирует UPDATE\n- Persistence Context гарантирует identity: `session.find(User.class, 1L) == session.find(User.class, 1L)` → `true`\n\n### Частые ошибки\n\n- Путать `persist()` и `merge()` — persist делает объект managed, merge создаёт managed копию (оригинал остаётся detached)\n- Изменять Detached-объект и ожидать UPDATE — изменения detached-объекта не отслеживаются; нужен `merge()`\n- Вызывать `persist()` для объекта с заданным `@Id` — если `@GeneratedValue` не используется, нужен `merge()`\n- Не понимать flush — `persist()` не выполняет INSERT немедленно; SQL выполняется при flush (commit, query, `session.flush()`)\n\n### Как используется в 2026\n\n- Spring Data JPA скрывает управление состояниями за `save()`, `findById()`, `delete()`\n- `save()` в Spring Data вызывает `persist()` для нового объекта или `merge()` для существующего\n- Понимание жизненного цикла необходимо для отладки — без него невозможно объяснить, почему UPDATE не выполнился или выполнился лишний раз\n\n> **На собеседовании:** рисуйте диаграмму четырёх состояний и переходов между ними. Интервьюер ожидает, что вы знаете: Transient → persist() → Persistent, Persistent → detach()\u002Fclose() → Detached, Detached → merge() → Persistent. Частый уточняющий вопрос — «чем persist отличается от merge?».","","middle",[15,16,17,7],"persistence-context","jpa","entity-lifecycle",[],null,{"title":21,"description":22,"ogTitle":23,"ogDescription":24,"keywords":25,"schemaAnswer":35,"featuredSnippetReady":36},"Жизненный цикл Entity в Hibernate — Gymterview","Четыре состояния Entity: Transient, Persistent, Detached, Removed. Диаграмма переходов, методы persist\u002Fmerge\u002Fremove и типичные ошибки.","Жизненный цикл Entity: Transient → Persistent → Detached → Removed — Gymterview","Разбираем 4 состояния Entity в Hibernate, переходы между ними (persist, merge, detach, remove) и частые ошибки.",[26,27,28,29,30,31,32,33,8,34],"Entity lifecycle","Transient","Persistent","Detached","Removed","persist","merge","Dirty Checking","JPA","Entity проходит 4 состояния: Transient (создан через new, Hibernate не знает), Persistent (связан с Persistence Context, изменения отслеживаются), Detached (был persistent, Session закрыта), Removed (помечен на удаление). Переходы: persist() → Persistent, merge() → Persistent (копия), detach()\u002Fclose() → Detached, remove() → Removed.",true]