Какой жизненный цикл у сущностей Hibernate?

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

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

Сущности Hibernate проходят четыре основных состояния (lifecycle states):

1. Transient — новый объект, не привязан к сессии
2. Persistent — управляется сессией Hibernate
3. Detached — был привязан к сессии, но сессия закрыта
4. Removed — помечен на удаление

Четыре состояния жизненного цикла

1. Transient (Переходное)

Объект только что создан, Hibernate о нём не знает:

// Объект в состоянии Transient
User user = new User();
user.setName("John");
user.setEmail("john@example.com");

// В этот момент:
// - Объект не имеет ID
// - Нет записи в БД
// - Hibernate не отслеживает изменения

Характеристики:

• Нет связи с Session
• Нет записи в БД
• user.getId() == null
• Изменения не отслеживаются

2. Persistent (Постоянное)

Объект привязан к сессии Hibernate:

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    
    @Transactional
    public User createUser(User user) {
        // После save() объект становится Persistent
        User saved = userRepository.save(user);
        
        // Теперь:
        // - Объект управляется Hibernate
        // - saved.getId() != null
        // - Есть запись в БД
        // - Все изменения отслеживаются
        
        // Изменения автоматически сохранятся при commit
        saved.setName("Jane");
        
        return saved;
    }
}

Характеристики:

• Привязан к Session
• Имеет ID
• Есть запись в БД
• Hibernate отслеживает все изменения (dirty checking)
• При commit все изменения сохраняются

3. Detached (Отсоединённое)

Объект был Persistent, но сессия закрыта:

User user; // Persistent в рамках @Transactional метода

// После выхода из @Transactional метода
public void someMethod() {
    User user = userService.getUser(1L); // Был Persistent
    
    // После завершения транзакции (выход из сервиса):
    // - Сессия закрыта
    // - Объект становится Detached
    // - user.getId() ещё есть
    // - Hibernte больше не отслеживает изменения
    
    user.setName("New Name"); // Изменение НЕ сохранится!
}

Характеристики:

• Был Persistent, но сессия закрыта
• Имеет ID
• Изменения НЕ отслеживаются
• Изменения НЕ сохраняются автоматически
• Может быть повторно привязан к сессии (merge/attach)

Проблема N+1 с Detached объектами:

@Transactional(readOnly = true)
public User getUserWithPosts(Long id) {
    return userRepository.findById(id).orElse(null);
    // user становится Detached здесь
}

public void processUser() {
    User user = getUserWithPosts(1L); // Detached!
    
    // LazyInitializationException!
    // user.getPosts() не загружена, и сессия закрыта
    user.getPosts().forEach(p -> System.out.println(p));
}

4. Removed (Удалённое)

Объект помечен на удаление:

@Transactional
public void deleteUser(Long id) {
    User user = userRepository.findById(id).orElse(null);
    
    if (user != null) {
        // После delete() объект становится Removed
        userRepository.delete(user);
        
        // Теперь:
        // - Объект помечен на удаление
        // - При commit будет удалён из БД
        // - Можно ещё получить данные (user.getId())
        // - После commit станет обычным Transient
    }
}

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

Transient → [save()]  → Persistent
    ↓
  [new()]  
    
Persistent → [close()/flush()] → Detached
    ↓
  [delete()]  
    ↓
  Removed → [commit()] → Transient (obsolete)

Detached → [merge()/lock()] → Persistent
    ↓
  [load()]  

Методы для управления жизненным циклом

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // Уже реализованы JPA/Hibernate методы
}

@Service
public class UserService {
    @Autowired
    private UserRepository repo;
    
    @Autowired
    private EntityManager em;
    
    // === Transient → Persistent ===
    @Transactional
    public User save(User user) {
        return repo.save(user); // persist()
    }
    
    // === Persistent (в пределах транзакции) ===
    @Transactional
    public User update(User user) {
        // Достаточно изменить объект - сохранится автоматически
        user.setName("New Name");
        return user; // Изменения сохранятся при commit
    }
    
    // === Detached → Persistent ===
    @Transactional
    public User merge(User detachedUser) {
        return em.merge(detachedUser);
        // Объект присоединяется к сессии
        // Изменения будут отслеживаться
    }
    
    // === Persistent → Detached ===
    public User getDetached(Long id) {
        return repo.findById(id).orElse(null);
        // После выхода из @Transactional - становится Detached
    }
    
    // === Persistent → Removed → Transient ===
    @Transactional
    public void delete(Long id) {
        repo.deleteById(id); // remove()
    }
    
    // === Проверка состояния ===
    public void checkState(User user) {
        boolean isPersistent = em.contains(user);
        System.out.println("Is persistent: " + isPersistent);
    }
}

Реальный пример: полный цикл жизни

@Service
public class CompleteLifecycleExample {
    @Autowired
    private UserRepository repo;
    
    @Autowired
    private EntityManager em;
    
    public void demonstrateLifecycle() {
        // 1. TRANSIENT - создаём новый объект
        User user = new User();
        user.setName("Alice");
        // user.getId() == null
        // em.contains(user) == false
        
        // 2. TRANSIENT → PERSISTENT
        saveUserInTransaction(user);
        // После этого: user.getId() != null
        
        // 3. Работаем с Detached объектом
        updateDetachedUser(user);
        // Изменение НЕ сохранилось!
        
        // 4. DETACHED → PERSISTENT
        user = mergeAndUpdate(user);
        // Теперь изменения сохранились
        
        // 5. PERSISTENT → REMOVED → TRANSIENT
        deleteUser(user);
    }
    
    @Transactional
    private void saveUserInTransaction(User user) {
        repo.save(user);
        // user становится Persistent
    }
    
    private void updateDetachedUser(User user) {
        user.setEmail("alice@example.com");
        // Сессия закрыта - изменение не сохранится
    }
    
    @Transactional
    private User mergeAndUpdate(User detachedUser) {
        User managed = em.merge(detachedUser);
        // managed становится Persistent
        managed.setEmail("alice@example.com");
        // Теперь это изменение сохранится
        return managed;
    }
    
    @Transactional
    private void deleteUser(User user) {
        repo.delete(user);
        // user становится Removed
    }
}

Частые ошибки

1. LazyInitializationException

// ❌ ОШИБКА
User user = userService.getUser(1L); // Detached
user.getPosts().size(); // LazyInitializationException!

// ✅ РЕШЕНИЕ 1: Eager loading
@Entity
public class User {
    @OneToMany(fetch = FetchType.EAGER)
    private List<Post> posts; // Загружается всегда
}

// ✅ РЕШЕНИЕ 2: Загрузить в транзакции
@Transactional
public User getUserWithPosts(Long id) {
    User user = userRepository.findById(id).orElse(null);
    user.getPosts().size(); // Инициализируем в транзакции
    return user;
}

// ✅ РЕШЕНИЕ 3: Использовать merge
@Transactional
public void process(User detachedUser) {
    User managed = em.merge(detachedUser);
    managed.getPosts().size(); // Теперь работает
}

2. Изменения Detached объекта не сохраняются

// ❌ ОШИБКА
User user = userService.getUser(1L);
user.setName("New Name"); // Не сохранится

// ✅ РЕШЕНИЕ
userService.updateUser(user); // Merge внутри

Выводы

• Transient: новый объект, не привязан к Hibernate
• Persistent: управляется сессией, изменения отслеживаются
• Detached: был Persistent, сессия закрыта
• Removed: помечен на удаление
• @Transactional обеспечивает автоматическую очистку изменений при commit
• Используй merge() для присоединения Detached объектов
• Помни про LazyInitializationException при работе с отношениями