Ein Objekt löschen

Entfernen mit der Methode „remove()“.

Schauen wir uns zum Schluss noch das Löschen eines Objekts an. Im Prinzip ist das Löschen von Objekten aus der Datenbank sehr einfach, aber wie man so schön sagt, gibt es Nuancen. Und es gibt sechs solcher Nuancen:

• Entfernen mit der Methode „remove()“.
• Umzug für das Unternehmen
• Entfernung durch Orphan
• Mit JPQL löschen
• Löschung über NativeQuery
• softDeleted()

Und wir beginnen mit der naheliegendsten Lösung – dem Aufruf der Methode „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.

Der eigentliche Vorgang in der Datenbank wird ausgeführt, nachdem die Methode „flush()“ aufgerufen oder die Transaktion geschlossen wurde.

Kaskadierendes Löschen

Erinnern Sie sich, als wir SQL studierten, dass abhängige Tabellen mit CONSTRAINT geschrieben werden konnten? Und einer davon ging so:

CONSTRAINT ONDELETE REMOVE

Das bedeutete: Wenn wir eine Tabelle haben, die untergeordnete Entitäten enthält, müssen bei der Zuordnung der übergeordneten Entität alle untergeordneten Entitäten gelöscht werden.

Angenommen, wir speichern die persönlichen Daten des Benutzers irgendwo und richten CONSTRAINT in der Datenbank ein, sodass beim Löschen des Benutzers auch diese Daten gelöscht werden. Dann müssen wir nur noch das übergeordnete Objekt löschen und alle untergeordneten Objekte werden auf der Basisebene gelöscht:

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.

Entfernung durch Orphan

Es gibt auch eine andere Art der Entfernung, die sogenannte Orphan-Entfernung. Es ähnelt etwas der vorherigen Version. Eine untergeordnete Entität wird gelöscht, wenn ihre Beziehung zur übergeordneten Entität unterbrochen wird. In diesem Fall wird die übergeordnete Entität normalerweise nicht gelöscht.

Nehmen wir an, wir haben einen Benutzer und er hat eine Liste mit Beiträgen:

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

Es gibt auch eine wichtige Nuance: Wenn Hibernate dieses Verhalten implementieren soll, muss es explizit angegeben werden, wenn zwei Entitäten mithilfe von Anmerkungen verknüpft werden:

@Entity
public class User {

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

}

Über JPQL löschen

Eine weitere interessante Möglichkeit, ein Objekt zu löschen, besteht darin, eine HQL- (oder JPQL-)Abfrage zu schreiben. Vergessen Sie nur nicht , am Ende die MethodeexecuteUpdate() aufzurufen , sonst erstellt Hibernate eine schreibgeschützte Transaktion und Sie erhalten keine Löschung.

Beispiel:

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

Durch das Ändern der Datenbank werden vorhandene Entitätsobjekte in keiner Weise geändert.

Löschung über NativeQuery

Ebenso können Sie NativeQuery löschen und aufrufen.

Beispiel:

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

Die Änderung in der Datenbank hat keinerlei Auswirkungen auf vorhandene Entity-Objekte.

Vorläufiges Löschen

Anstatt Daten in der Datenbank zu löschen, ist es manchmal praktisch, sie einfach als gelöscht zu markieren. Solche Daten können dann an verschiedenen Szenarien beteiligt sein. Erstens ist eine solche Löschung leicht rückgängig zu machen – die Zeilen können wieder als aktiv markiert werden.

Zweitens ist es sinnvoll, solche Remote-Daten zu „archivieren“, da es Fälle gibt, in denen das Verhalten des Servers durch Gesetze und dergleichen geregelt ist. Wenn Sie Ihre Daten jedoch als gelöscht markieren, erfahren nur Sie, dass die Daten gelöscht wurden. Hibernate findet diese Daten weiterhin und verwendet sie auch beim Sortieren.

Daher haben die Macher von Hibernate eine spezielle Anmerkung entwickelt, mit der es möglich wäre, Objekte als lebendig zu markieren. Beispiel:

@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
    }
}

Um ein Objekt als gelöscht zu markieren, müssen Sie lediglich die Methode softDeleted() dafür aufrufen :

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