Eliminación de un objeto

Eliminar con el método remove()

Finalmente, veamos cómo eliminar un objeto. En principio, eliminar objetos de la base de datos es muy sencillo, pero como dicen, hay matices. Y hay seis de esos matices:

• Eliminar con el método remove()
• Mudanza para la empresa
• Eliminación por huérfano
• Eliminar con JPQL
• Eliminación a través de NativeQuery
• suaveEliminado()

Y comenzaremos con la solución más obvia: llamar al método 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.

La operación real en la base de datos se ejecutará después de que se llame al método flush() o se cierre la transacción.

Eliminación en cascada

¿Recuerdas cuando estudiamos SQL, las tablas dependientes se podían escribir con CONSTRAINT? Y uno de ellos decía así:

CONSTRAINT ONDELETE REMOVE

Su significado era que si tenemos una tabla que contiene entidades secundarias, cuando se asigna la entidad principal, todos sus elementos secundarios deben eliminarse.

Supongamos que almacenamos la información personal del usuario en algún lugar y configuramos CONSTRAINT en la base de datos para que cuando se elimine el usuario, estos datos también se eliminen. Luego, solo necesitamos eliminar el objeto principal y todos los objetos secundarios se eliminarán en el nivel 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.

Eliminación por huérfano

También hay otro tipo de eliminación llamada eliminación de huérfanos. Es algo similar a la versión anterior. Una entidad secundaria se elimina cuando se rompe su relación con la entidad principal. En este caso, la entidad matriz normalmente no se elimina.

Digamos que tenemos un usuario y tiene una lista de publicaciones:

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

También hay un matiz importante, si queremos que Hibernate implemente este comportamiento, debe especificarse explícitamente al vincular dos entidades usando anotaciones:

@Entity
public class User {

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

}

Eliminar a través de JPQL

Otra forma interesante de eliminar un objeto es escribir una consulta HQL (o JPQL). Simplemente no olvide llamar al método executeUpdate() al final , de lo contrario, Hibernate crea una transacción de solo lectura y no obtendrá ninguna eliminación.

Ejemplo:

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

Cambiar la base de datos no cambiará los objetos de Entidad existentes de ninguna manera.

Eliminación a través de NativeQuery

Del mismo modo, puede eliminar y llamar a NativeQuery.

Ejemplo:

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

El cambio en la base de datos no afectará a los objetos Entity existentes de ninguna manera.

Eliminación suave

En ocasiones, en lugar de eliminar datos de la base de datos, conviene simplemente marcarlos como eliminados. Dichos datos pueden participar en varios escenarios. En primer lugar, dicha eliminación es fácilmente reversible: las líneas se pueden marcar nuevamente como activas.

En segundo lugar, es útil "archivar" dichos datos remotos, porque hay casos en que el comportamiento del servidor está regulado por ley y similares. Sin embargo, si marca sus datos como eliminados, solo usted sabrá que se han eliminado. Hibernate seguirá encontrando estos datos y también los usará al clasificarlos.

Por lo tanto, los creadores de Hibernate idearon una anotación especial con la que sería posible marcar objetos como vivos. Ejemplo:

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

Para marcar un objeto como eliminado, solo necesita llamar al método softDeleted() en él :

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