Een object verwijderen

Verwijderen met de methode remove().

Laten we tot slot eens kijken naar het verwijderen van een object. In principe is het verwijderen van objecten uit de database heel eenvoudig, maar zoals ze zeggen, zijn er nuances. En er zijn zes van dergelijke nuances:

• Verwijderen met de methode remove().
• Verwijdering voor het bedrijf
• Verwijdering door wees
• Verwijderen met JPQL
• Verwijdering via NativeQuery
• zachtVerwijderd()

En we beginnen met de meest voor de hand liggende oplossing: de methode remove() aanroepen .

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.

De daadwerkelijke bewerking in de database wordt uitgevoerd nadat de methode flush() is aangeroepen of de transactie is gesloten.

Trapsgewijs verwijderen

Weet je nog dat toen we SQL bestudeerden, afhankelijke tabellen konden worden geschreven met CONSTRAINT. En een van hen ging als volgt:

CONSTRAINT ONDELETE REMOVE

De betekenis ervan was dat als we een tabel hebben die onderliggende entiteiten bevat, alle onderliggende entiteiten moeten worden verwijderd wanneer de bovenliggende entiteit wordt toegewezen.

Stel dat we de persoonlijke informatie van de gebruiker ergens opslaan en CONSTRAINT in de database instellen zodat wanneer de gebruiker wordt verwijderd, deze gegevens ook worden verwijderd. Dan hoeven we alleen maar het bovenliggende object te verwijderen en alle onderliggende objecten worden op het basisniveau verwijderd:

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.

Verwijdering door wees

Er is ook een andere vorm van verwijdering, de zogenaamde weesverhuizing. Het is enigszins vergelijkbaar met de vorige versie. Een onderliggende entiteit wordt verwijderd wanneer de relatie met de bovenliggende entiteit wordt verbroken. In dit geval wordt de bovenliggende entiteit meestal niet verwijderd.

Laten we zeggen dat we een gebruiker hebben en hij heeft een lijst met berichten:

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

Er is ook een belangrijke nuance: als we willen dat Hibernate dit gedrag implementeert, moet dit expliciet worden gespecificeerd bij het koppelen van twee entiteiten met behulp van annotaties:

@Entity
public class User {

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

}

Verwijderen via JPQL

Een andere interessante manier om een ​​object te verwijderen, is door een HQL-query (of JPQL-query) te schrijven. Vergeet alleen niet de methode executeUpdate() aan het einde aan te roepen , anders maakt Hibernate een alleen-lezen transactie en wordt er niets verwijderd.

Voorbeeld:

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

Het wijzigen van de database verandert op geen enkele manier bestaande Entity-objecten.

Verwijdering via NativeQuery

Op dezelfde manier kunt u NativeQuery verwijderen en aanroepen.

Voorbeeld:

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

De wijziging in de database heeft op geen enkele manier invloed op bestaande Entity-objecten.

Zacht verwijderen

Soms is het handig om in plaats van gegevens in de database te verwijderen, deze eenvoudig als verwijderd te markeren. Dergelijke gegevens kunnen vervolgens deelnemen aan verschillende scenario's. Ten eerste is een dergelijke verwijdering eenvoudig ongedaan te maken - de regels kunnen weer als actief worden gemarkeerd.

Ten tweede is het nuttig om dergelijke externe gegevens te "archiveren", omdat er gevallen zijn waarin het gedrag van de server wettelijk is geregeld en dergelijke. Als u uw gegevens echter als verwijderd markeert, weet alleen u dat ze zijn verwijderd. Hibernate zal deze gegevens nog steeds vinden en ook gebruiken bij het sorteren.

Daarom bedachten de makers van Hibernate een speciale annotatie waarmee het mogelijk zou zijn om objecten als levend te markeren. Voorbeeld:

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

Om een ​​object als verwijderd te markeren, hoef je alleen maar de methode softDeleted() erop aan te roepen :

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