Quelle est la différence entre session.persist() et session.save() dans Hibernate ?

Question

Quelqu'un peut-il me dire quel est l'avantage de persist() vs save() dans Hibernate ?

Answer 1

De ce message du forum

persist() est bien défini. Il rend une instance transitoire persistante. Cependant, il ne garantit pas que la valeur de l'identifiant sera attribuée à l'instance persistante immédiatement, l'affectation peut se faire au moment de la chasse d'eau au moment du flush. La spécification ne le dit pas. est le problème que j'ai avec persist() .

persist() garantit également qu'il n'exécutera pas une instruction INSERT si elle est appelée en dehors des limites transaction. Ceci est utile dans conversations de longue durée avec un contexte de session/persistance étendu.

Une méthode comme persist() est nécessaire.

save() ne garantit pas la même chose, il renvoie un identifiant, et si un INSERT doit être exécuté pour obtenir l'identifiant identifiant (par exemple le générateur "identity", pas "séquence"), cet INSERT est exécuté immédiatement, peu importe si vous êtes l'intérieur ou l'extérieur d'une transaction. Ce n'est pas une bonne chose dans une conversation avec une session/contexte de persistance.

Answer 2

J'ai fait des recherches approfondies sur la méthode save() vs. persist(), notamment en l'exécutant plusieurs fois sur ma machine locale. Toutes les explications précédentes sont confuses et incorrectes. Je compare les méthodes save() et persist() ci-dessous après une recherche approfondie.

Save()

1. Renvoie l'identité générée après l'enregistrement. Son type de retour est Serializable ;
2. Enregistre les modifications dans la base de données en dehors de la transaction ;
3. Affecte l'identifiant généré à l'entité que vous faites persister ;
4. session.save() pour un objet détaché créera une nouvelle ligne dans le tableau.

Persist()

1. Ne renvoie pas l'identité générée après la sauvegarde. Son type de retour est void ;
2. N'enregistre pas les modifications dans la base de données en dehors de la transaction ;
3. Affecte l'identifiant généré à l'entité que vous faites persister ;
4. session.persist() pour un objet détaché lancera un PersistentObjectException car cela n'est pas autorisé.

Tous ces éléments sont testés sur Hibernate v4.0.1 .

Answer 3

J'ai fait quelques tests simulés pour enregistrer la différence entre save() y persist() .

Il semble que ces deux méthodes se comportent de la même manière lorsqu'il s'agit d'une entité transitoire, mais diffèrent lorsqu'il s'agit d'une entité détachée.

Dans l'exemple ci-dessous, prenons EmployeeVehicle comme entité avec PK en tant que vehicleId qui est une valeur générée et vehicleName comme l'une de ses propriétés.

Exemple 1 : Traitement d'un objet transitoire

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

Résultat :

select nextval ('hibernate_sequence') // This is for vehicle Id generated : 36
insert into Employee_Vehicle ( Vehicle_Name, Vehicle_Id) values ( Honda, 36)

Notez que le résultat est le même lorsque vous récupérez un objet déjà persistant et que vous le sauvegardez.

EmployeeVehicle entity =  (EmployeeVehicle)session.get(EmployeeVehicle.class, 36);
entity.setVehicleName("Toyota");
session.save(entity);    -------> **instead of session.update(entity);**
// session.persist(entity);

Répétez l'opération en utilisant persist(entity) et le résultat sera le même avec une nouvelle Id ( disons 37 , honda ) ;

Exemple 2 : Traitement d'un objet détaché

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

Résultat : Vous pourriez vous attendre à ce que le véhicule avec l'id : 36 obtenu dans la session précédente soit mis à jour avec le nom "Toyota". Mais ce qui se passe, c'est qu'une nouvelle entité est sauvegardée dans la base de données avec le nouvel ID généré pour et le nom "Toyota".

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

Utilisation de persist pour persister une entité détachée

// (ii) Using Persist()  to persist a detached
// Session 1 
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
Session session2 = factory.openSession();
session2.beginTransaction();
entity.setVehicleName("Toyota");
session2.persist(entity);
session2.getTransaction().commit();
session2.close();

Résultat :

Exception being thrown : detached entity passed to persist

Ainsi, il est toujours préférable d'utiliser Persist() plutôt que Save() car Save doit être utilisé avec précaution lorsqu'il s'agit d'objets transitoires.

Note importante : Dans l'exemple ci-dessus, le pk de l'entité véhicule est une valeur générée, donc quand on utilise save() pour persister une entité détachée, Hibernate génère un nouvel id à persister. Cependant, si ce pk n'est pas une valeur générée, il en résulte une exception indiquant que la clé est violée.

Answer 4

Cette question contient de bonnes réponses sur les différentes méthodes de persistance dans Hibernate. Pour répondre directement à votre question, avec save(), l'instruction d'insertion est exécutée immédiatement, quel que soit l'état de la transaction. Elle renvoie la clé insérée, ce qui vous permet de faire quelque chose comme ceci :

long newKey = session.save(myObj);

Utilisez donc save() si vous avez besoin d'un identifiant attribué à l'instance persistante immédiatement.

Avec persist(), l'instruction d'insertion est exécutée dans une transaction, pas nécessairement immédiatement. C'est préférable dans la plupart des cas.

Utilisez persist() si vous n'avez pas besoin que l'insertion soit

Answer 5

Voici les différences qui peuvent vous aider à comprendre les avantages des méthodes de persistance et de sauvegarde :

• La première différence entre save et persist est leur type de retour. L'adresse type de retour de la méthode persist est void tandis que le type de retour de save
  est un objet Serializable.

• La méthode persist() ne garantit pas que la valeur de l'identifiant sera sera assignée à l'état persistant immédiatement, l'assignation pourrait se produire au moment du flush.

• La méthode persist() n'exécutera pas une requête d'insertion si elle est appelée en dehors des limites de la transaction. Par contre, la méthode save() renvoie un identifiant afin qu'une requête d'insertion soit exécutée immédiatement pour obtenir l'identifiant, peu importe qu'il soit à l'intérieur ou à l'extérieur d'une transaction.

• La méthode persist est appelée en dehors des limites de la transaction, elle est utile dans les conversations de longue durée avec un contexte de étendue. D'un autre côté, la méthode save n'est pas utile dans une conversation avec un contexte de session étendu.

• Cinquième différence entre les méthodes save et persist dans Hibernate : persist est supportée par JPA, alors que save n'est supportée que par Hibernate.

Vous pouvez voir l'exemple complet de travail à partir de l'article. Différence entre les méthodes save et persist dans Hibernate