Was ist der Unterschied zwischen persist() und save() in den Ruhezustand?

Habe ich einige mock-Tests zum erfassen der Unterschied zwischen Save() und Persist().

Klingt wie diese beiden Methoden verhält sich genauso beim Umgang mit Transienten-Einheit, sondern unterscheiden sich beim Umgang mit Detached Entity.

Für das folgende Beispiel nehmen EmployeeVehicle als eine Einheit mit PK als vehicleId, das ist ein generierter Wert und vehicleName als eines Ihrer Immobilie .

Beispiel 1 : der Umgang mit Transienten Objekt

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

Ergebnis : select nextval ('hibernate_sequence') //Das ist für Fahrzeug-Id generiert : 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 ) ;

Beispiel 2 : der Umgang mit Detached-Objekt

//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();

Ergebnis : Sie könnte damit rechnen, dass das Fahrzeug mit der id : 36, erhalten in der vorherigen Sitzung aktualisiert wird, mit Namen wie "Toyota" . Aber was passiert, ist, dass eine neue Entität gespeichert wird in der DB eine neue Id generiert und der Name "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();

//Session 2
//Hier in Sitzung 2 , Fahrzeug-Entität, die in der vorherigen Sitzung ist ein freistehendes Objekt, und jetzt werden wir versuchen, Sie zu retten /beibehalten, es
(i) Mittels persist() persist ein freistehendes Objekt

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

Ergebnis : Exception geworfen : detached entity passed to persist

So, es ist immer besser, zu Bestehen() anstatt Speichern() speichern muss sorgfältig verwendet werden, wenn der Umgang mit session und transcation .

InformationsquelleAutor Deivanayagam Senthil

Persist():

• Es ist eine void-Methode und übernimmt keine Garantie, dass Bezeichner Wert ist
  zugeordnet Persistenz Beispiel nach dem INSERT. die Zuordnung könnte
  passieren flush Zeit.
• Es wird nicht ausgeführt werden, wenn die genannte von außen Transaktionen
  Grenzen.
• Es wird nützlich sein, für lang andauernde Gespräche mit erweiterten Sitzung/Persistenz-Kontext.

Save():

• Wird es wieder die identifier nach dem ausführen EINFÜGEN.
• Es wird ausgeführt, auch außerhalb der Transaktion-Grenze.
• Es nicht sinnvoll, für lang andauernde Gespräche.

InformationsquelleAutor MAA

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();

}
}

Unterschied zwischen Speichern und speichern , Speichern, ausführen, außerhalb der Transaktion. Führen Sie den obigen code, und überprüfen Sie die Konsole System.aus.println(Sitzung 1.save(person)) zurück, mit id und führen Sie es wieder, es erhöht Ihre Kennung. Nun, wenn Sie versuchen, Speichern Sie einen anderen Datensatz in der Person-Tabelle in der Datenbank mit dem folgenden code, und aktualisieren Sie die Datenbank-Tabelle und überprüfen Sie die id-Spalte in der Datenbank. Sein Wert wird inkrementiert.

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();
}

Wenn wir versuchen, die Persistenz der Daten außerhalb Transaktions-Grenze, die es geben Ausnahme.

InformationsquelleAutor Deepak