«1. Введение

Hibernate — это удобная среда для управления постоянными данными, но иногда бывает сложно понять, как она работает внутри.

В этом уроке мы узнаем о состояниях объекта и о том, как перемещаться между ними. Мы также рассмотрим проблемы, с которыми мы можем столкнуться с отсоединенными объектами, и способы их решения.

2. Сеанс Hibernate

Интерфейс сеанса является основным инструментом, используемым для связи с Hibernate. Он предоставляет API, позволяющий нам создавать, читать, обновлять и удалять постоянные объекты. Сессия имеет простой жизненный цикл. Открываем его, выполняем какие-то операции, а потом закрываем.

Когда мы работаем с объектами во время сеанса, они привязываются к этому сеансу. Вносимые нами изменения обнаруживаются и сохраняются при закрытии. После закрытия Hibernate разрывает соединения между объектами и сеансом.

3. Состояния объектов

В контексте сеанса Hibernate объекты могут находиться в одном из трех возможных состояний: переходном, постоянном или отсоединенном.

3.1. Transient

Объект, который мы не присоединили ни к одному сеансу, находится в переходном состоянии. Поскольку он никогда не сохранялся, он не представлен в базе данных. Поскольку ни один сеанс не знает об этом, он не будет сохранен автоматически.

Давайте создадим пользовательский объект с помощью конструктора и подтвердим, что он не управляется сессией: 

Session session = openSession();
UserEntity userEntity = new UserEntity("John");
assertThat(session.contains(userEntity)).isFalse();

3.2. Persistent

Объект, который мы связали с сеансом, находится в постоянном состоянии. Мы либо сохранили его, либо прочитали из контекста персистентности, поэтому он представляет некоторую строку в базе данных.

Давайте создадим объект, а затем используем метод persist, чтобы сделать его постоянным: 

Session session = openSession();
UserEntity userEntity = new UserEntity("John");
session.persist(userEntity);
assertThat(session.contains(userEntity)).isTrue();

В качестве альтернативы мы можем использовать метод save. Разница в том, что метод persist просто сохранит объект, а метод save дополнительно сгенерирует его идентификатор, если это необходимо.

3.3. Detached

Когда мы закрываем сеанс, все объекты внутри него становятся отсоединенными. Хотя они по-прежнему представляют строки в базе данных, они больше не управляются никаким сеансом: 

session.persist(userEntity);
session.close();
assertThat(session.isOpen()).isFalse();
assertThatThrownBy(() -> session.contains(userEntity));

Далее мы узнаем, как сохранять временные и отсоединенные сущности.

4. Сохранение и повторное присоединение объекта

4.1. Сохранение временной сущности

Давайте создадим новую сущность и сохраним ее в базе данных. Когда мы впервые создадим объект, он будет находиться в переходном состоянии.

Чтобы сохранить нашу новую сущность, мы будем использовать метод persist: 

UserEntity userEntity = new UserEntity("John");
session.persist(userEntity);

Теперь мы создадим еще один объект с тем же идентификатором, что и у первого. Этот второй объект является временным, поскольку он еще не управляется ни одним сеансом, но мы не можем сделать его постоянным с помощью метода persist. Он уже представлен в базе данных, так что он не совсем новый в контексте уровня сохраняемости.

Вместо этого мы будем использовать метод слияния, чтобы обновить базу данных и сделать объект постоянным: 

UserEntity onceAgainJohn = new UserEntity("John");
session.merge(onceAgainJohn);

4.2. Сохранение отсоединенного объекта

Если мы закроем предыдущий сеанс, наши объекты будут в отсоединенном состоянии. Как и в предыдущем примере, они представлены в базе данных, но в настоящее время ими не управляет какой-либо сеанс. Мы можем снова сделать их постоянными, используя метод слияния: 

UserEntity userEntity = new UserEntity("John");
session.persist(userEntity);
session.close();
session.merge(userEntity);

5. Вложенные объекты

Все становится сложнее, когда мы рассматриваем вложенные объекты. Допустим, наша пользовательская сущность также будет хранить информацию о своем менеджере: 

public class UserEntity {
    @Id
    private String name;

    @ManyToOne
    private UserEntity manager;
}

Когда мы сохраняем эту сущность, нам нужно думать не только о состоянии самой сущности, но и о состоянии вложенной сущности. Давайте создадим постоянный пользовательский объект, а затем установим его менеджер: 

UserEntity userEntity = new UserEntity("John");
session.persist(userEntity);
UserEntity manager = new UserEntity("Adam");
userEntity.setManager(manager);

Если мы попытаемся обновить его сейчас, мы получим исключение: 

assertThatThrownBy(() -> {
            session.saveOrUpdate(userEntity);
            transaction.commit();
});
java.lang.IllegalStateException: org.hibernate.TransientPropertyValueException: object references an unsaved transient instance - save the transient instance before flushing : com.baeldung.states.UserEntity.manager -> com.baeldung.states.UserEntity

Это происходит потому, что Hibernate не знает что делать с временной вложенной сущностью.

5.1. Сохранение вложенных сущностей 

UserEntity manager = new UserEntity("Adam");
session.persist(manager);
userEntity.setManager(manager);

Один из способов решения этой проблемы — явное сохранение вложенных сущностей: 

transaction.commit();
session.close();

Session otherSession = openSession();
UserEntity savedUser = otherSession.get(UserEntity.class, "John");
assertThat(savedUser.getManager().getName()).isEqualTo("Adam");

Тогда, после фиксации транзакции, мы сможем получить правильно сохраненную сущность:

5.2. Каскадные операции 

@ManyToOne(cascade = CascadeType.PERSIST)
private UserEntity manager;

«Временные вложенные объекты могут быть сохранены автоматически, если мы правильно настроим свойство каскада отношения в классе объектов: 

UserEntityWithCascade userEntity = new UserEntityWithCascade("John");
session.persist(userEntity);
UserEntityWithCascade manager = new UserEntityWithCascade("Adam");

userEntity.setManager(manager); // add transient manager to persistent user
session.saveOrUpdate(userEntity);
transaction.commit();
session.close();

Session otherSession = openSession();
UserEntityWithCascade savedUser = otherSession.get(UserEntityWithCascade.class, "John");
assertThat(savedUser.getManager().getName()).isEqualTo("Adam");

Теперь, когда мы сохраняем объект, эта операция будет каскадирована на все вложенные объекты:

6 Резюме

В этом руководстве мы более подробно рассмотрели, как сеанс Hibernate работает в отношении состояния объекта. Затем мы рассмотрели некоторые проблемы, которые он может создать, и способы их решения.