Implementing Soft Deletes in Hibernate: A Practical Approach

Welcome back to our Hibernate series! In this post, we’ll delve into the concept of soft deletes in Hibernate applications. Soft deletion is an approach where data is not actually removed from the database; instead, a flag is set to indicate that the data is deleted. This practice facilitates data recovery and auditing.

What are Soft Deletes?

Soft deletes allow you to retain records in the database while marking them as inactive or deleted through an additional column, such as isDeleted. This approach is beneficial for:

• Data Recovery: Provides the ability to recover mistakenly deleted records.
• Auditing: Enables a complete history of data without losing any original information.
• Business Logic: Allows application logic to treat “deleted” entities differently without permanently removing them.

Implementing Soft Deletes in Hibernate

To implement soft deletes in Hibernate, you will need to modify your entity to include a deletion flag and adjust your queries accordingly.

1. Update Your Entity

Add an isDeleted field to your entity class:

import javax.persistence.*;

@Entity
public class Product {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    private String name;
    private Double price;

    @Column(name = "is_deleted", columnDefinition = "boolean default false")
    private boolean isDeleted = false;

    // Getters and setters
}

2. Modifying Delete Logic

Instead of directly deleting an entity, create a method that sets the isDeleted flag to true:

public void softDeleteProduct(Long productId) {
    Session session = sessionFactory.openSession();
    Transaction transaction = session.beginTransaction();
    try {
        Product product = session.get(Product.class, productId);
        if (product != null) {
            product.setDeleted(true);
            session.update(product);
        }
        transaction.commit();
    } catch (Exception e) {
        transaction.rollback();
        e.printStackTrace();
    } finally {
        session.close();
    }
}

3. Filtering Out Soft Deleted Entities

To ensure that soft deleted entities are not fetched in your application, you need to adjust your queries:

public List<Product> getActiveProducts() {
    Session session = sessionFactory.openSession();
    List<Product> products = session.createQuery("FROM Product p WHERE p.isDeleted = false", Product.class)
            .getResultList();
    session.close();
    return products;
}

Best Practices for Soft Deletes

• Index the Deleted Flag: Consider indexing the isDeleted column to improve query performance when filtering active entities.
• Reporting & Auditing: Maintain an audit log for soft-deleted records to track why and when they were marked as deleted.
• Consider Privacy Regulations: Ensure compliance with data privacy regulations when retaining data, such as GDPR or CCPA.

Conclusion

In this post, we explored how to implement soft deletes in Hibernate applications, allowing for data to remain in the database while being marked as deleted. This approach offers flexibility in data management and helps support auditing and recovery needs.

Implementing soft deletes correctly can significantly enhance the maintainability and reliability of your data handling processes. Stay tuned for more valuable insights in our Hibernate series!

To learn more about ITER Academy, visit our website: ITER Academy.