Suppression d'un objet

Suppression avec la méthode remove()

Enfin, regardons la suppression d'un objet. En principe, la suppression d'objets de la base de données est très simple, mais comme on dit, il y a des nuances. Et il y a six de ces nuances:

• Suppression avec la méthode remove()
• Déménagement pour l'entreprise
• Enlèvement par orphelin
• Supprimer avec JPQL
• Suppression via NativeQuery
• softDeleted()

Et nous commencerons par la solution la plus évidente - appeler la méthode remove() .

User user = new User();
user.setName("Kolyan");
session.persist(user);  // add an object to the database
session.flush();
session.clear();  // close the session

user = (User) session.find(User.class, user.getId() ); //receive the object from the database
session.remove(user);
session.flush();
session.clear();  // close the session

//here the object is actually deleted.

L'opération réelle dans la base de données sera exécutée après l'appel de la méthode flush() ou la fermeture de la transaction.

Suppression en cascade

Vous souvenez-vous lorsque nous avons étudié SQL, les tables dépendantes pouvaient être écrites avec CONSTRAINT. Et l'un d'eux est parti comme ça :

CONSTRAINT ONDELETE REMOVE

Sa signification était que si nous avons une table qui contient des entités enfants, alors lorsque l'entité parent est allouée, tous ses enfants doivent être supprimés.

Supposons que nous stockions les informations personnelles de l'utilisateur quelque part et configurions une CONTRAINTE dans la base de données afin que lorsque l'utilisateur est supprimé, ces données soient également supprimées. Ensuite, nous avons juste besoin de supprimer l'objet parent et tous les objets enfants seront supprimés au niveau de base :

User user = new User();
UserPrivateInfo info = new UserPrivateInfo();
user.setPrivateInfo(info);
session.persist(user);  //add the object to the database, the info object will also be saved to the database
session.flush();
session.clear();  // close the session

user = (User) session.find(User.class, user.getId() ); //receive the object from the database
session.remove(user);
session.flush();
session.clear();  // close the session

// here the user and info objects are actually removed from the database.

Enlèvement par orphelin

Il existe également un autre type de suppression appelé suppression des orphelins. C'est un peu similaire à la version précédente. Une entité enfant est supprimée lorsque sa relation avec l'entité parent est rompue. Dans ce cas, l'entité parent n'est généralement pas supprimée.

Disons que nous avons un utilisateur et qu'il a une liste de publications :

User user = new User();
UserMessage message = new UserMessage();
user.getMessageList().add(message);
session.persist(user);  //add the object to the database, the message object will also be saved to the database
session.flush();
session.clear();  // close the session

user = (User) session.find(User.class, user.getId() ); //receive the object from the database
UserMessage message2 = user.getMessageList().get(0); //get the user's message
user.getMessageList().remove(message2);  //remove the message from the list
session.flush();
session.clear();  // close the session

// here the message2 object is actually removed from the database

Il y a aussi une nuance importante, si nous voulons qu'Hibernate implémente ce comportement, il faut le spécifier explicitement lors de la liaison de deux entités à l'aide d'annotations :

@Entity
public class User {

    @OneToMany(cascade = CascadeType.ALL, orphanRemoval = true)
    private List<UserMessage> messageList = new ArrayList<UserMessage>();

}

Supprimer via JPQL

Une autre façon intéressante de supprimer un objet est d'écrire une requête HQL (ou JPQL). N'oubliez pas d'appeler la méthode executeUpdate() à la fin , sinon Hibernate crée une transaction en lecture seule et vous n'obtiendrez aucune suppression.

Exemple:

User user = new User();
session.persist(user);  // add an object to the database
session.flush();
session.clear();  // close the session

session.createQuery("delete from User where id = :id")
   .setParameter("id", user.getId())
   .executeUpdate();

La modification de la base de données ne modifiera en aucun cas les objets Entity existants.

Suppression via NativeQuery

De même, vous pouvez supprimer et appeler NativeQuery.

Exemple:

User user = new User();
session.persist(user);  // add an object to the database
session.flush();
session.clear();  // close the session

session.createNativeQuery("DELETE FROM user WHERE id = :id")
   .setParameter("id", user.getId())
   .executeUpdate();

La modification de la base de données n'affectera en aucun cas les objets Entity existants.

Suppression douce

Parfois, au lieu de supprimer des données dans la base de données, il est pratique de simplement les marquer comme supprimées. Ces données peuvent alors participer à divers scénarios. Premièrement, une telle suppression est facilement réversible - les lignes peuvent à nouveau être marquées comme étant en direct.

Deuxièmement, il est utile «d'archiver» ces données distantes, car il existe des cas où le comportement du serveur est réglementé par la loi, etc. Cependant, si vous marquez vos données comme supprimées, vous seul saurez qu'elles ont été supprimées. Hibernate trouvera toujours ces données et les utilisera également lors du tri.

Par conséquent, les créateurs d'Hibernate ont proposé une annotation spéciale avec laquelle il serait possible de marquer des objets comme vivants. Exemple:

@Entity
@Where(clause = "DELETED = 0") //in all WHEREs "AND DELETED = 0" will be added
public class User {
	// mapping fields

	@Column(name = "DELETED") // if the value in the DELETED column == 0, then the record is alive, if 1 - dead
	private Integer deleted = 0;

	//getters and setters

    public void softDeleted() {
    	this.deleted = 1; //mark the post as dead
    }
}

Pour marquer un objet comme supprimé, il suffit d'appeler la méthode softDeleted() dessus :

User user = new User();
session.persist(user);  // add an object to the database
session.flush();
session.clear();  // close the session

user = (User) session.find(User.class, user.getId() ); //receive the object from the database
user.softDeleted(); // mark the object as deleted
session.flush();
session.clear();  // close the session

//this object will no longer reside via Hibernate