В чем разница между persist () и save () в Hibernate?

Question

С помощью документации я могу найти только одно отличие: метод save генерирует, возвращает объект как сгенерированный идентификатор, но persist - нет. Это единственная цель для предоставления метода persist. Если да, то как это помогает программисту, потому что онне намеревается использовать сгенерированный идентификатор, он может использовать save и игнорировать возвращаемое значение.

Также пришло через этот поток на В чем преимущество persist () перед save () в Hibernate? .Значимое утверждение, которое я могу получить из этого потока: persist () также гарантирует, что оно не выполнит оператор INSERT, если он вызывается вне границ транзакции, а метод сохранения делает , но не уверен, как мне его попробоватьмоя программа, чтобы я мог получить реальную разницу?

Answer 1

Я провел некоторое пробное тестирование, чтобы записать разницу между Save () и Persist ().

Похоже, что оба этих метода ведут себя одинаково при работе с Transient Entity, но различаются при работе с Detached Entity.

Для приведенного ниже примера возьмите EmployeeVehicle в качестве сущности с PK в качестве vehicleId, который является сгенерированным значением, и vehicleName в качестве одного из его свойств.

Пример 1: Работа с временным объектом

                 Session session = factory.openSession();
                 session.beginTransaction();
                 EmployeeVehicle entity = new EmployeeVehicle();
                    entity.setVehicleName("Honda");
                 session.save(entity);
                 // session.persist(entity);
                session.getTransaction().commit();
                session.close();

Результат: select nextval ('hibernate_sequence') // Это для сгенерированного идентификатора транспортного средства: 36

insert into Employee_Vehicle ( Vehicle_Name, Vehicle_Id) values ( Honda, 36)

Repeat the same with using persist(entity) and will result the same with new Id ( say 37 , honda ) ;

Пример 2. Работа с отдельным объектом

// Session 1 
            // Get the previously saved Vehicle Entity 
           Session session = factory.openSession();
            session.beginTransaction();
            EmployeeVehicle entity = (EmployeeVehicle)session.get(EmployeeVehicle.class, 36);
           session.close();

           // Session 2
           // Here in Session 2 , vehicle entity obtained in previous session is a detached object and now we will try to save / persist it 
         (i) Using Save() to persist a detached object 
           Session session2 = factory.openSession();
            session2.beginTransaction();
                    entity.setVehicleName("Toyota");
            session2.save(entity);
            session2.getTransaction().commit();
            session2.close();

Результат: Возможно, вы ожидаете автомобильс идентификатором: 36, полученным в предыдущей сессии, обновляется с именем «Тойота».Но происходит то, что новый объект сохраняется в БД с новым идентификатором, сгенерированным для, и именуется как «Toyota»

         select nextval ('hibernate_sequence')
         insert into Employee_Vehicle ( Vehicle_Name, Vehicle_Id) values ( Toyota, 39)

         (ii) Using Persist()  to persist a detached object 

            // Session 1 
            Session session = factory.openSession();
    session.beginTransaction();
    EmployeeVehicle entity = EmployeeVehicle)session.get(EmployeeVehicle.class, 36);
    session.close();

// Сессия 2 // Здесь в Сессии 2, объект транспортного средства, полученный в предыдущем сеансеявляется отсоединенным объектом, и теперь мы попытаемся сохранить / сохранить его (i) Использование persist () для сохранения отсоединенного объекта

            Session session2 = factory.openSession();
    session2.beginTransaction();
            entity.setVehicleName("Toyota");
    session2.persist(entity);
    session2.getTransaction().commit();
    session2.close();

Результат: генерируется исключение: отсоединенная сущность передана для сохранения

Таким образом, всегда лучше использовать Persist (), а не Save (), поскольку при работе с сессиями и транскрипцией необходимо тщательно использовать save.

Answer 2

• Тип возвращаемого значения : обе функции вставляют записи в базу данных, но возвращаемый тип метода persist () является недействительным, а возвращаемый тип метода save () - это значение идентификатора первичного ключа, которое генерируется hibernate.

• Идентификатор : метод persist () не гарантирует, что значение идентификатора будет присвоено постоянному экземпляру немедленно, назначение может произойти во время сброса.

• Границы транзакции : Мы можем вызывать метод persist () только внутри транзакции, поэтому он безопасен и заботится о любых каскадных объектах. Метод save () может вызываться внутри или снаружи транзакции.

• Context : методы persist () добавляют объект сущности в постоянный контекст и отслеживают любые дальнейшие изменения. Все дальнейшие изменения сохраняются во время совершения транзакции, например, сохраняются.

наконец, метод persist () лучше, чем save ().

примеры

Answer 3

Упорство ():

• Это пустой метод, который не гарантирует, что значение идентификатора присваивается экземпляру постоянства после INSERT. назначение может произойдет во время сброса.
• Он не будет выполнен, если его вызывают из внешних транзакций границы.
• Это будет полезно для длительных разговоров с расширенным контекстом сеанса / постоянства.

Save ():

• Он вернет идентификатор после выполнения INSERT.
• Будет выполнено даже за пределами границы транзакции.
• Бесполезно для длительных разговоров.

Answer 4

save () возвращает идентификатор, и если для получения идентификатора необходимо выполнить INSERT, эта INSERT происходит немедленно, независимо от того, находитесь ли вы внутри или вне транзакции.Это не очень хорошо в длительном диалоге с расширенным контекстом Session / persistence.

persist () используется для временных объектов.Это делает временный экземпляр постоянным.Однако это не гарантирует, что значение идентификатора будет присвоено постоянному экземпляру немедленно, назначение может произойти во время сброса. Это также гарантирует, что оно не выполнит оператор INSERT, если он вызывается вне границ транзакции.Это полезно в длительных беседах с расширенным контекстом сеанса / постоянства.

Answer 5

public class TestSave {

public static void main(String[] args) {

    Session session= HibernateUtil.getSessionFactory().openSession();
    Person person= (Person) session.get(Person.class, 1);
    System.out.println(person.getName());
    session.close();

    Session session1= HibernateUtil.getSessionFactory().openSession();
    session1.beginTransaction();

    person.setName("person saved with Persist");
    session1.getTransaction().commit();
    System.out.println(session1.save(person));

    //session1.persist(person);
    session1.flush();

    session1.close();

}
}

Разница между сохранением и сохранением. Выполнение сохранения за пределами транзакции.Выполните приведенный выше код и проверьте, что консоль System.out.println (session1.save (person)) вернется с идентификатором и выполнит его снова, это увеличит ваш идентификатор.Теперь, если вы попытаетесь сохранить другую запись в таблице Person в базе данных с помощью приведенного ниже кода, обновите таблицу базы данных и проверьте столбец id в базе данных.Его значение будет увеличено.

public class TestMain {
  public static void main(String[] args) {
    Person person = new Person();
    saveEntity(person);
 }
private static void saveEntity(Person person) {
person.setId(1);
 person.setName("Concretepage1");
 Session session = HibernateUtil.getSessionFactory().openSession();
 session.beginTransaction();
 session.save(person);
 session.getTransaction().commit();
 session.close();
}

Если мы попытаемся сохранить данные вне границы транзакции, это выдаст исключение.

Answer 6

Метод save () делает оператор вставки обычно вне транзакции

public class HibernateSaveExample {

    public static void main(String[] args) {

        SessionFactory sessionFactory = HibernateUtil.getSessionFactory();
        Session session = sessionFactory.openSession();
        Student student = new Student("javabycode.com", new Date(), "USA", "1234569");
        Long studentId = (Long) session.save(student);
        System.out.println(" Identifier : " + studentId);
        System.out.println(" Successfully saved");

        Session session2 = sessionFactory.openSession();
        Transaction trans = session2.beginTransaction();

        Student student2 = new Student("javabycode.com", new Date(), "USA", "1234569");
        Long studentId2 = (Long) session2.save(student2);
        trans.commit();
        System.out.println(" Identifier : " + studentId2);
        System.out.println(" Successfully saved");

        sessionFactory.close();
    }

}

, а метод persist () не может этого сделать.

И еще одно отличие между методом сохранения и сохранением в Hibernate: постоянство поддерживается JPA, в то время как сохранение поддерживается только Hibernate.

Из учебника Разница между методом сохранения и сохранения в Hibernate