Что значит состояние persistent у объекта в Hibernate?

Состояние Persistent в Hibernate: что это значит

Краткое определение

Persistent — это состояние объекта в Hibernate, когда:

1. Объект ассоциирован с session (текущей сессией БД)
2. Объект соответствует строке в БД (имеет primary key)
3. Hibernate отслеживает изменения объекта (dirty tracking)
4. Изменения будут синхронизированы с БД при flush/commit

Три состояния объектов в Hibernate

┌─────────────┬──────────────────────────────────────┐
│  Transient  │ Новый объект, не связан с session   │
│ (преходящее)│ Нет в БД, нет association         │
├─────────────┼──────────────────────────────────────┤
│ Persistent  │ Объект в session, соответствует БД   │
│ (долговечный)│ Изменения отслеживаются            │
├─────────────┼──────────────────────────────────────┤
│ Detached    │ Был в session, но session закрыта    │
│ (отсоединен)│ Изменения НЕ отслеживаются         │
└─────────────┴──────────────────────────────────────┘

Пример: жизненный цикл объекта

public class UserLifecycleExample {
    @Autowired
    private UserRepository repository;
    
    @Autowired
    private EntityManager entityManager;
    
    public void demonstrateStates() {
        // 1. TRANSIENT состояние
        User user = new User();
        user.setName("Alice");
        user.setEmail("alice@example.com");
        // Объект существует только в памяти Java
        // Нет в БД, нет session
        System.out.println("State: TRANSIENT");
        
        // 2. PERSISTENT состояние (сохранение)
        repository.save(user);  // Hibernate берет управление
        // Теперь объект:
        // - Связан с session (через repository)
        // - Имеет primary key (был сгенерирован)
        // - Отслеживается Hibernate
        System.out.println("State: PERSISTENT, ID: " + user.getId());
        
        // 3. Изменения отслеживаются автоматически
        user.setEmail("newemail@example.com");
        // Hibernate видит это изменение
        // При flush/commit → UPDATE запрос в БД
        System.out.println("State: PERSISTENT (dirty), email changed");
    }
}

Ключевые характеристики Persistent состояния

1. Ассоциация с Session

public class PersistentExample {
    @Autowired
    private EntityManager entityManager;
    
    public void checkPersistentState() {
        // Создаем объект
        Product product = new Product();
        product.setName("Laptop");
        product.setPrice(1000);
        
        // Сохраняем → переходит в PERSISTENT
        entityManager.persist(product);
        
        // Проверяем состояние
        if (entityManager.contains(product)) {
            System.out.println("Объект в PERSISTENT состоянии");
            System.out.println("ID был сгенерирован: " + product.getId());
        }
        
        // Закрываем session
        entityManager.close();  // или session.close()
        
        // Теперь объект в DETACHED состоянии
        if (!entityManager.contains(product)) {
            System.out.println("Объект теперь в DETACHED состоянии");
        }
    }
}

2. Dirty Tracking (отслеживание изменений)

public class DirtyTrackingExample {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void demonstrateDirtyTracking() {
        // Загружаем объект (будет PERSISTENT)
        User user = entityManager.find(User.class, 1L);
        // Hibernate запомнил исходное состояние
        // Snapshot: {name: "Alice", email: "alice@example.com"}
        
        // Меняем объект
        user.setEmail("alice.new@example.com");
        
        // При commit/flush Hibernate:
        // 1. Сравнивает текущее состояние со snapshot
        // 2. Видит что email изменился
        // 3. Генерирует UPDATE запрос
        // 4. Выполняет его в БД
        
        // Мы явно не вызывали save/update!
        // Это работает потому что объект PERSISTENT
    }
    // При выходе из @Transactional → автоматический flush
}

3. Автоматическая синхронизация при Flush

public class FlushExample {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void demonstrateFlush() {
        // 1. Создаем и сохраняем
        Account account = new Account();
        account.setBalance(1000);
        entityManager.persist(account);  // PERSISTENT
        entityManager.flush();  // Выполняет INSERT
        
        // 2. Меняем значение
        account.setBalance(1500);
        // Это изменение еще не в БД (кэш)
        
        // 3. Любой запрос вызовет flush (синхронизирует изменения)
        List<Account> accounts = entityManager.createQuery(
            "SELECT a FROM Account a WHERE a.balance > :min",
            Account.class
        ).setParameter("min", 1000)
         .getResultList();  // Автоматический flush перед запросом!
        // Теперь в БД balance = 1500
        
        // 4. При commit (конец @Transactional) → final flush
    }
}

Важные методы Session/EntityManager

public class PersistentStateMethods {
    @Autowired
    private EntityManager entityManager;
    
    public void methods() {
        User user = new User();
        user.setName("Bob");
        
        // persist() → переводит в PERSISTENT
        entityManager.persist(user);
        // Теперь user.getId() будет заполнен (генерируется при flush)
        
        // contains() → проверяет PERSISTENT ли объект
        boolean isPersistent = entityManager.contains(user);
        
        // merge() → переводит DETACHED в PERSISTENT
        User attachedUser = entityManager.merge(user);
        // Возвращает новый объект, привязанный к session
        
        // detach() → выводит из PERSISTENT в DETACHED
        entityManager.detach(user);
        // Теперь entityManager.contains(user) вернет false
        
        // flush() → синхронизирует память с БД
        entityManager.flush();
        // Но транзакция еще не завершена
        
        // refresh() → перезагружает из БД (обновляет snapshot)
        entityManager.refresh(user);
        // Отбрасывает локальные изменения
    }
}

Сравнение состояний

public class StateComparisonExample {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void compareStates() {
        // 1. TRANSIENT
        Product product1 = new Product();
        product1.setName("Phone");
        // entityManager.contains(product1) == false
        // Изменения НЕ отслеживаются
        
        // 2. PERSISTENT
        entityManager.persist(product1);
        // entityManager.contains(product1) == true
        // Изменения ОТСЛЕЖИВАЮТСЯ
        product1.setPrice(500);
        // При commit → UPDATE (хотя не вызывали save)
        
        // 3. DETACHED
        entityManager.flush();
        entityManager.detach(product1);
        // или session.close(); или evict()
        // entityManager.contains(product1) == false
        // Изменения НЕ отслеживаются
        product1.setPrice(600);
        // При commit → НИЧЕГО (объект не в session)
        
        // 4. Вернуть DETACHED в PERSISTENT
        Product merged = entityManager.merge(product1);
        // merged (не product1!) теперь PERSISTENT
        // Если вы меняете product1 — не поможет
        merged.setPrice(700);
        // Это изменение ОТСЛЕЖИВАЕТСЯ
    }
}

Практические применения Persistent состояния

1. Lazy Loading в контексте session

public class LazyLoadingExample {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void lazyLoadingWorks() {
        // Пользователь PERSISTENT
        User user = entityManager.find(User.class, 1L);
        
        // orders — lazy коллекция, но работает!
        // Потому что user в session
        for (Order order : user.getOrders()) {
            System.out.println(order.getTotal());
            // Hibernate генерирует SELECT для orders
        }
    }
    // ❌ LazyInitializationException если закрыть session
}

public class LazyLoadingProblem {
    @Autowired
    private EntityManager entityManager;
    
    public User getUser() {
        User user = entityManager.find(User.class, 1L);
        // entityManager.close() или session ends
        return user;  // DETACHED
    }
    
    public void useUser(User user) {
        // ❌ LazyInitializationException!
        // user.getOrders(); // Hibernate не может lazy-load
        // Потому что нет session
    }
}

2. Optimistic Locking с @Version

@Entity
public class OptimisticLockingEntity {
    @Id
    private Long id;
    
    private String data;
    
    @Version
    private Long version;  // Работает только в PERSISTENT!
}

public class OptimisticLockingExample {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void demonstrateVersioning() {
        // Объект загружен и PERSISTENT
        OptimisticLockingEntity entity = entityManager.find(
            OptimisticLockingEntity.class, 1L);
        // version = 1
        
        entity.setData("new value");
        // При flush → UPDATE с WHERE version=1
        // Если другой поток изменил → OptimisticLockException
        
        // Это работает потому что Hibernate отслеживает
        // PERSISTENT объекты и их версии
    }
}

3. Batch Processing с clear()

public class BatchProcessingExample {
    @Autowired
    private EntityManager entityManager;
    
    @Transactional
    public void processBatch() {
        List<User> users = entityManager.createQuery(
            "SELECT u FROM User u", User.class
        ).getResultList();  // Все в PERSISTENT
        
        for (int i = 0; i < users.size(); i++) {
            User user = users.get(i);
            user.setProcessed(true);
            // Все пользователи в кэше (PERSISTENT)
            // Память растет! ❌
            
            if (i % 1000 == 0) {
                entityManager.flush();
                entityManager.clear();  // Выгоняем из кэша (DETACHED)
                // Память освобождена ✓
            }
        }
    }
}

Итог: почему Persistent важен

Persistent состояние = Hibernate управляет объектом

Бенефиты:
✓ Автоматическое отслеживание изменений (dirty tracking)
✓ Не нужно вызывать save/update явно
✓ Lazy loading работает
✓ Версионирование (@Version) работает
✓ Cascade операции работают
✓ Relationships инициализируются

Риски:
✗ Можно получить LazyInitializationException (нет session)
✗ Много объектов в памяти (нужно clear())
✗ Detached объекты требуют merge() для обратного attach