Quel est l'avantage de persist() et save() en mode veille prolongée?

De ce post sur le forum

persist() est bien défini. Il fait un
transitoire instance persistante.
Toutefois, cela ne garantit pas que l'
identificateur de valeur sera attribuée à
l'instance persistante immédiatement,
la cession pourrait arriver à rincer
temps. La spécification de ne pas dire qu', qui
est le problème que j'ai avec persist().

persist() également des garanties
de ne pas exécuter une instruction INSERT si c'
est appelé à l'extérieur de la transaction
les limites. Ceci est utile dans
les longues conversations avec un
Séance prolongée/contexte de persistance.

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

save() ne garantit pas le même, il
retourne un identifiant, et si un
INSERTION doit être exécutée pour obtenir l'
identifiant (exemple: "identité" générateur,
pas de "séquence"), cet INSERT se produit
immédiatement, peu importe si vous êtes
à l'intérieur ou à l'extérieur d'une transaction.
Ce n'est pas bon dans une longue
conversation avec une longue
Session/contexte de persistance.

J'ai fait de la maquette de test pour enregistrer la différence entre save() et persist().

Sonne comme ces deux méthodes se comporte de la même lorsque vous traitez avec des Transitoires de l'Entité, mais diffèrent lorsque vous traitez avec des Détaché de l'Entité.

Pour l'exemple ci-dessous, prendre EmployeeVehicle comme une Entité avec PK comme vehicleId qui est une valeur générée et vehicleName comme l'une de ses propriétés.

Exemple 1 : traitement Transitoire Objet

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)

Note le résultat est le même lorsque vous obtenez déjà un objet persistant et l'enregistrer

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

Répéter les mêmes à l'aide de persist(entity) et le résultat sera le même avec une nouvelle Id ( dire 37 , honda ) ;

Exemple 2 : gérer les Détachée de l'Objet

//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 peut-être attendre le Véhicule avec l'id : 36 obtenu en session précédente est mis à jour avec le nom "Toyota" . Mais ce qui se passe est que, une nouvelle entité est enregistrée dans la base de données avec de nouvelles Id généré et un Nom comme "Toyota"

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

À l'aide de persister à persister détaché entité

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

Donc, il est toujours préférable d'utiliser Persist() plutôt que de les Enregistrer() pour enregistrer doit être soigneusement utilisés lorsqu'il s'agit Transitoire de l'objet .

Remarque importante : Dans l'exemple ci-dessus , la pharmacocinétique du véhicule entité est une valeur générée , de sorte que lors de l'utilisation de save() pour conserver un décollement de l'entité , hibernate génère un nouvel id de persister . Néanmoins, si le pk n'est pas une valeur générée que c'est le résultat dans une exception indiquant clé violé.

save()- Comme la méthode nom l'indique, hibernate save() peut être utilisé pour économiser de l'entité de base de données. Nous pouvons appeler cette méthode en dehors d'une transaction. Si nous utilisons ce sans transaction et nous avons en cascade entre les entités, alors que l'entité principale est enregistré, à moins que nous rincer la session.

persist()-Hibernate persistent est similaire à enregistrer (avec de la transaction), et il ajoute l'objet d'entité à la persistance de contexte, de sorte que toute les autres changements sont suivis. Si les propriétés de l'objet sont modifiées avant la transaction est validée ou de la session est vidé, il sera également enregistrée dans la base de données.
Aussi, nous pouvons utiliser persist() la méthode que dans la limite d'une transaction, il est donc sûr et prend soin de tout en cascade des objets.
Enfin, persistent à ne retourne rien, donc nous avons besoin d'utiliser l'objet persistant pour obtenir l'identifiant généré de la valeur.

Voici la différence:

1. enregistrer:

   1. sera de retour l'id/identificateur lorsque l'objet est enregistré dans la base de données.
   2. permettra aussi de sauver lorsque l'objet est tenté de faire de même en ouvrant une nouvelle session après qu'il est détaché.

2. Persistent:

   1. sera de retour nulle lorsque l'objet est enregistré dans la base de données.
   2. va jeter PersistentObjectException quand a essayé de sauver le détachement de l'objet par le biais d'une nouvelle session.

Règle de base, dit que :

Pour les Entités avec l'identifiant généré :

save() : retourne une entité identifiant immédiatement en plus de faire l'objet persistant. Si une requête d'insertion est déclenché immédiatement.

persist() : Elle retourne l'objet persistant. Il n'a pas de contrainte de retourner l'identificateur immédiatement de sorte qu'il ne garantit pas que l'insert sera immédiatement licenciés. Il peut mettre le feu à un insert immédiatement, mais il n'est pas garanti. Dans certains cas, la requête peut être déclenché immédiatement, tandis que dans d'autres, il peut être déclenché lors de la session du flush.

Pour les Entités avec l'identifiant attribué :

save(): retourne une entité identifiant immédiatement. Depuis l'identifiant est déjà attribué à l'entité avant l'appel de l'enregistrer, de sorte que l'insert n'est pas immédiatement licenciés. Il est déclenché lors de la session du flush.

persist() : la même que pour enregistrer. Il a également incendie insérer le flush.

Supposons que nous avons une entité qui utilise un identifiant généré comme suit :

@Entity
@Table(name="USER_DETAILS")
public class UserDetails {
    @Id
    @Column(name = "USER_ID")
    @GeneratedValue(strategy=GenerationType.AUTO)
    private int userId;

    @Column(name = "USER_NAME")
    private String userName;

    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
}

save() :

    Session session = sessionFactory.openSession();
    session.beginTransaction();
    UserDetails user = new UserDetails();
    user.setUserName("Gaurav");
    session.save(user); //Query is fired immediately as this statement is executed.
    session.getTransaction().commit();
    session.close();

persist() :

    Session session = sessionFactory.openSession();
    session.beginTransaction();
    UserDetails user = new UserDetails();
    user.setUserName("Gaurav");
    session.save(user); //Query is not guaranteed to be fired immediately. It may get fired here.
    session.getTransaction().commit(); //If it not executed in last statement then It is fired here.
    session.close();

Maintenant, supposons que nous avons la même entité définie comme suit, sans le champ id ayant généré annotation c'est à dire le code d'identification attribué manuellement.

@Entity
@Table(name="USER_DETAILS")
public class UserDetails {
    @Id
    @Column(name = "USER_ID")
    private int userId;

    @Column(name = "USER_NAME")
    private String userName;

    public int getUserId() {
        return userId;
    }
    public void setUserId(int userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
}

pour enregistrer() :

Session session = sessionFactory.openSession();
session.beginTransaction();
UserDetails user = new UserDetails();
user.setUserId(1);
user.setUserName("Gaurav");
session.save(user); //Query is not fired here since id for object being referred by user is already available. No query need to be fired to find it. Data for user now available in first level cache but not in db.
session.getTransaction().commit();//Query will be fired at this point and data for user will now also be available in DB
session.close();

pour persist() :

Session session = sessionFactory.openSession();
session.beginTransaction();
UserDetails user = new UserDetails();
user.setUserId(1);
user.setUserName("Gaurav");
session.persist(user); //Query is not fired here.Object is made persistent. Data for user now available in first level cache but not in db.
session.getTransaction().commit();//Query will be fired at this point and data for user will now also be available in DB
session.close();

Le cas ci-dessus était vrai lors de l'enregistrer ou de persister ont été appelés dans une transaction.

Les autres points de différence entre enregistrer et persistent sont :

1. save() peut être appelée en dehors d'une transaction. Si l'identifiant attribué est utilisée depuis l'id est déjà disponible, donc pas de requête d'insertion est immédiatement déclenché. La requête n'est déclenché lorsque la session est vidé.

2. Si l'identifiant généré est utilisé , depuis id besoin d'généré, insert est immédiatement déclenché. Mais il seulement d'économiser de l'entité principale. Si l'entité a quelques cascade entités alors ceux qui ne seront pas enregistrées dans la bd à ce point. Ils seront enregistrés lorsque la session est vidé.

3. Si persist() est en dehors d'une transaction puis insérer est déclenché uniquement lorsque la session est vidé, quel que soit le type de l'identificateur (générées ou affectés) est utilisé.

4. Si économiser est appelée sur un objet persistant, l'entité est enregistré à l'aide de requête de mise à jour.