Logical delete at a common place in hibernate

Question

I am using Spring and Hibernate for my application.

I am only allowing logical delete in my application where I need to set the field isActive=false. Instead of repeating the same field in all the entities, I created a Base Class with the property and getter-setter for 'isActive'.

So, during delete, I invoke the update() method and set the isActive to false.

I am not able to get this working. If any one has any idea, please let me know.

Base Entity

public abstract class BaseEntity<TId extends Serializable> implements IEntity<TId> {

    @Basic
    @Column(name = "IsActive")
    protected boolean isActive;

    public Boolean getIsActive() {
        return isActive;
    }

    public void setIsActive(Boolean isActive) {
        isActive= isActive;
    }
}

Child Entity

@Entity(name="Role")
@Table(schema = "dbo")
public class MyEntity extends BaseEntity {
    //remaining entities
}

Hibernate Util Class

public void remove(TEntity entity) {

    //Note: Enterprise data should be never removed.
    entity.setIsActive(false);
    sessionFactory.getCurrentSession().update(entity);
}

Answer 1

Try to replace the code in setIsActive method with:

public void setIsActive(Boolean isActive) {
    this.isActive = isActive;
}

in your code the use of variable name without this could be ambiguos...

I think you should also add @MappedSuperclass annotation to your abstract class to achieve field inheritance.

Answer 2

The issue with the proposed solution (which you allude to in your comment to that answer) is that does not handle cascading delete.

An alternative (Hibernate specific, non-JPA) solution might be to use Hibernate's @SQLDelete annotation:

http://docs.jboss.org/hibernate/orm/3.6/reference/en-US/html/querysql.html#querysql-cud

I seem to recall however that this Annotation cannot be defined on the Superclass and must be defined on each Entity class.

The problem with Logical delete in general however is that you then have to remember to filter every single query and every single collection mapping to exclude these records.

In my opinion an even better solution is to forget about logical delete altogether. Use Hibernate Envers as an auditing mechanism. You can then recover any deleted records as required.

http://envers.jboss.org/

Answer 3

You can use the SQLDelete annotation...

@org.hibernate.annotations.SQLDelete;

//Package name...

//Imports...

@Entity
@Table(name = "CUSTOMER")
//Override the default Hibernation delete and set the deleted flag rather than deleting the record from the db.
@SQLDelete(sql="UPDATE customer SET deleted = '1' WHERE id = ?")
//Filter added to retrieve only records that have not been soft deleted.
@Where(clause="deleted <> '1'")
public class Customer implements java.io.Serializable {
private long id;
...
private char deleted;

Source: http://featurenotbug.com/2009/07/soft-deletes-using-hibernate-annotations/