Sletting av et objekt

Fjerning med remove()-metoden

Til slutt, la oss se på sletting av et objekt. I prinsippet er det veldig enkelt å slette objekter fra databasen, men som de sier, det er nyanser. Og det er seks slike nyanser:

• Fjerning med remove() -metoden
• Fjerning for selskapet
• Fjerning av Orphan
• Slett med JPQL
• Sletting via NativeQuery
• softDeleted()

Og vi starter med den mest åpenbare løsningen - å kalle 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.

Selve operasjonen i databasen vil bli utført etter at flush() -metoden kalles eller transaksjonen er avsluttet.

Overlappende sletting

Husker du da vi studerte SQL, kunne avhengige tabeller skrives med CONSTRAINT. Og en av dem gikk slik:

CONSTRAINT ONDELETE REMOVE

Betydningen var at hvis vi har en tabell som inneholder underordnede enheter, må alle dens underordnede enheter slettes når den overordnede enheten er tildelt.

Anta at vi lagrer brukerens personopplysninger et sted og setter opp CONSTRAINT i databasen slik at når brukeren slettes, slettes også disse dataene. Da trenger vi bare å slette det overordnede objektet og alle underordnede objekter vil bli slettet på basisnivå:

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.

Fjerning av Orphan

Det finnes også en annen type fjerning kalt Orphan-fjerning. Den ligner litt på forrige versjon. En underordnet enhet slettes når forholdet til den overordnede enheten brytes. I dette tilfellet slettes vanligvis ikke den overordnede enheten.

La oss si at vi har en bruker og han har en liste over innlegg:

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

Det er også en viktig nyanse, hvis vi vil at Hibernate skal implementere denne oppførselen, må den spesifiseres eksplisitt når du kobler to enheter ved hjelp av merknader:

@Entity
public class User {

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

}

Slett via JPQL

En annen interessant måte å slette et objekt på er å skrive en HQL (eller JPQL) spørring. Bare ikke glem å kalle opp executeUpdate()- metoden på slutten , ellers oppretter Hibernate en skrivebeskyttet transaksjon og du vil ikke få noen sletting.

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

Endring av databasen vil ikke endre eksisterende Entity-objekter på noen måte.

Sletting via NativeQuery

På samme måte kan du slette og ringe 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();

Endringen i databasen vil ikke påvirke eksisterende Entity-objekter på noen måte.

Myk sletting

Noen ganger, i stedet for å slette data i databasen, er det praktisk å bare merke det som slettet. Slike data kan da delta i ulike scenarier. For det første er en slik sletting lett reversibel - linjene kan igjen merkes som live.

For det andre er det nyttig å "arkivere" slike eksterne data, fordi det er tilfeller der atferden til serveren er regulert av lov og lignende. Men hvis du merker dataene dine som slettet, er det bare du som vet at de er slettet. Hibernate vil fortsatt finne disse dataene og også bruke dem ved sortering.

Derfor kom skaperne av Hibernate med en spesiell merknad som det ville være mulig å markere gjenstander 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 å merke et objekt som slettet, trenger du bare å kalle opp 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