Sletning af et objekt

Fjernelse med remove()-metoden

Lad os endelig se på at slette et objekt. I princippet er det meget simpelt at slette objekter fra databasen, men som de siger, er der nuancer. Og der er seks sådanne nuancer:

• Fjernelse med remove()- metoden
• Fjernelse for virksomheden
• Fjernelse af Orphan
• Slet med JPQL
• Sletning via NativeQuery
• softDeleted()

Og vi starter med den mest oplagte løsning - kalder remove()- metoden .

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.

Den faktiske operation i databasen vil blive udført, efter at flush() -metoden er kaldt , eller transaktionen er lukket.

Cascading sletning

Kan du huske, da vi studerede SQL, kunne afhængige tabeller skrives med CONSTRAINT. Og en af ​​dem gik sådan her:

CONSTRAINT ONDELETE REMOVE

Dens betydning var, at hvis vi har en tabel, der indeholder underordnede entiteter, så skal alle dens børn slettes, når den overordnede entitet er allokeret.

Antag, at vi gemmer brugerens personlige oplysninger et sted og opsætter CONSTRAINT i databasen, så når brugeren slettes, slettes disse data også. Så skal vi bare slette det overordnede objekt, og alle underordnede objekter vil blive slettet på basisniveauet:

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.

Fjernelse af Orphan

Der er også en anden type fjernelse kaldet Orphan removal. Den minder lidt om den tidligere version. En underordnet enhed slettes, når dens forhold til den overordnede enhed er brudt. I dette tilfælde slettes den overordnede enhed normalt ikke.

Lad os sige, at vi har en bruger, og han har en liste over indlæg:

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

Der er også en vigtig nuance, hvis vi vil have Hibernate til at implementere denne adfærd, skal den udtrykkeligt specificeres, når to entiteter forbindes ved hjælp af annoteringer:

@Entity
public class User {

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

}

Slet via JPQL

En anden interessant måde at slette et objekt på er at skrive en HQL (eller JPQL) forespørgsel. Bare glem ikke at kalde executeUpdate()- metoden til sidst , ellers opretter Hibernate en skrivebeskyttet transaktion, og du vil ikke få nogen sletning.

Eksempel:

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

Ændring af databasen ændrer ikke eksisterende enhedsobjekter på nogen måde.

Sletning via NativeQuery

På samme måde kan du slette og ringe til NativeQuery.

Eksempel:

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

Ændringen i databasen vil ikke påvirke eksisterende enhedsobjekter på nogen måde.

Blød sletning

Nogle gange, i stedet for at slette data i databasen, er det praktisk blot at markere det som slettet. Sådanne data kan derefter deltage i forskellige scenarier. For det første er en sådan sletning let reversibel - linjerne kan igen markeres som live.

For det andet er det nyttigt at "arkivere" sådanne fjerndata, fordi der er tilfælde, hvor serverens adfærd er reguleret ved lov og lignende. Men hvis du markerer dine data som slettede, er det kun dig, der ved, at de er blevet slettet. Hibernate vil stadig finde disse data og også bruge dem ved sortering.

Derfor kom skaberne af Hibernate med en særlig anmærkning, som det ville være muligt at markere objekter som levende. Eksempel:

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

For at markere et objekt som slettet, skal du blot kalde softDeleted() -metoden på det :

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