Eliminazione di un oggetto

Rimozione con il metodo remove()

Infine, diamo un'occhiata all'eliminazione di un oggetto. In linea di principio, eliminare oggetti dal database è molto semplice, ma come si suol dire, ci sono delle sfumature. E ci sono sei di queste sfumature:

• Rimozione con il metodo remove()
• Rimozione per l'azienda
• Rimozione da parte di orfano
• Elimina con JPQL
• Eliminazione tramite NativeQuery
• softDeleted()

E inizieremo con la soluzione più ovvia: chiamare il metodo 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'operazione effettiva nel database verrà eseguita dopo che il metodo flush() è stato chiamato o la transazione è stata chiusa.

Eliminazione a cascata

Ti ricordi quando abbiamo studiato SQL, le tabelle dipendenti potevano essere scritte con CONSTRAINT. E uno di loro è andato così:

CONSTRAINT ONDELETE REMOVE

Il suo significato era che se abbiamo una tabella che contiene entità figlio, quando l'entità genitore viene allocata, tutti i suoi figli devono essere cancellati.

Supponiamo di archiviare le informazioni personali dell'utente da qualche parte e impostare CONSTRAINT nel database in modo che quando l'utente viene eliminato, anche questi dati vengano eliminati. Quindi dobbiamo solo eliminare l'oggetto genitore e tutti gli oggetti figlio verranno eliminati a livello di 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.

Rimozione da parte di orfano

Esiste anche un altro tipo di rimozione chiamata rimozione orfana. È in qualche modo simile alla versione precedente. Un'entità figlio viene eliminata quando la sua relazione con l'entità padre viene interrotta. In questo caso, l'entità madre di solito non viene eliminata.

Diciamo che abbiamo un utente e ha un elenco di post:

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

C'è anche una sfumatura importante, se vogliamo che Hibernate implementi questo comportamento, deve essere esplicitamente specificato quando si collegano due entità usando le annotazioni:

@Entity
public class User {

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

}

Elimina tramite JPQL

Un altro modo interessante per eliminare un oggetto è scrivere una query HQL (o JPQL). Non dimenticare di chiamare il metodo executeUpdate() alla fine , altrimenti Hibernate crea una transazione di sola lettura e non otterrai alcuna cancellazione.

Esempio:

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 modifica del database non modificherà in alcun modo gli oggetti Entity esistenti.

Eliminazione tramite NativeQuery

Allo stesso modo, puoi eliminare e chiamare NativeQuery.

Esempio:

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 modifica nel database non influirà in alcun modo sugli oggetti Entità esistenti.

Eliminazione temporanea

A volte, invece di eliminare i dati nel database, è conveniente contrassegnarli semplicemente come eliminati. Tali dati possono quindi partecipare a vari scenari. In primo luogo, tale cancellazione è facilmente reversibile: le linee possono essere nuovamente contrassegnate come attive.

In secondo luogo, è utile "archiviare" tali dati remoti, perché ci sono casi in cui il comportamento del server è regolato dalla legge e simili. Tuttavia, se contrassegni i tuoi dati come eliminati, solo tu saprai che sono stati eliminati. Hibernate troverà comunque questi dati e li utilizzerà anche durante l'ordinamento.

Pertanto, i creatori di Hibernate hanno escogitato un'annotazione speciale con la quale sarebbe possibile contrassegnare gli oggetti come vivi. Esempio:

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

Per contrassegnare un oggetto come eliminato, devi solo chiamare il metodo softDeleted() su di esso :

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