Spring Boot Auditing With JPA and Hibernate –

by Blog Admin
0 comment

In the ever-evolving landscape of software development, maintaining data integrity, ensuring security, and meeting regulatory compliance requirements are paramount. Auditing, the practice of meticulously tracking and recording changes to data and user actions within an application, emerges as a crucial component in achieving these objectives. In the context of Spring Boot, a versatile framework for building Java-based applications, auditing becomes not just a best practice but a necessity.

In this comprehensive guide, we embark on a journey to explore the intricate world of auditing within Spring Boot applications. Our focus is on harnessing the combined power of three stalwarts in the Java ecosystem: Java Persistence API (JPA), Hibernate, and Spring Data JPA. By the end of this article, you will possess the knowledge and tools needed to implement robust auditing solutions tailored to your Spring Boot projects.

Understanding Auditing in Spring Boot

Auditing is a fundamental aspect of software development, especially when dealing with data-driven applications. It involves tracking changes to data, monitoring user actions, and maintaining a historical record of these activities. In the context of Spring Boot applications, auditing plays a crucial role in ensuring data integrity, security, and compliance with regulatory requirements.

What Is Auditing?

At its core, auditing involves recording and monitoring actions taken within a software application. These actions can include:

  • Creation: Tracking when a new record or entity is added to the system.
  • Modification: Monitoring changes made to existing data, including updates and edits.
  • Deletion: Recording when data is removed or marked as deleted.
  • Access Control: Keeping a log of who accessed certain data and when.

Auditing serves several important purposes:

  • Data Integrity: It helps maintain data consistency and prevents unauthorized or malicious changes.
  • Security: Auditing aids in identifying and responding to security breaches or suspicious activities.
  • Compliance: Many industries and applications require auditing to comply with regulations and standards.
  • Troubleshooting: It simplifies the process of identifying and resolving issues by providing a historical trail of actions.

JPA doesn’t explicitly contain an auditing API, but we can achieve this functionality by using entity lifecycle events.

JPA, the Java Persistence API, plays a pivotal role in enabling auditing within your Spring Boot application. It introduces the concept of entity listeners, which allows you to define methods that respond to lifecycle events of JPA entities. For auditing purposes, we are particularly interested in three key lifecycle events:

  • @PrePersist: This event occurs just before an entity is first saved in the database, making it suitable for capturing creation-related information.
  • @PreUpdate: This event takes place just before an entity is updated in the database, making it ideal for tracking modifications.
  • @PreRemove This event occurs just before an entity is removed from the database.

Let’s explore how to use these events effectively:

@Entity public class Product {     // ...          @PrePersist     protected void onCreate() {         // Implement auditing logic here, e.g., setting creation timestamp and user.     }      @PreUpdate     protected void onUpdate() {         // Implement auditing logic here, e.g., updating modification timestamp and user.     }          @PreRemove     protected void onRemove() {         // Implement auditing logic here, e.g., setting deletion timestamp and user.     } }

Internal callback methods should always return void and take no arguments. They can have any name and any access level but shouldn’t be static. 

If we need to add such auditing to multiple classes, we can use @EntityListeners to centralize the code: 

@EntityListeners(AuditListener.class) @Entity public class Product { ... }

public class AuditListener {          @PrePersist     @PreUpdate     @PreRemove     private void beforeAnyOperation(Object object) { ... }      }

Auditing With Hibernate Envers

To set up Envers, we need to add the hibernate-envers JAR into our classpath:

  • Gradle:
dependencies {      ...     implementation 'org.hibernate:hibernate-envers:6.2.4.Final'   ... }

  • Maven:
org.hibernate hibernate-envers ${hibernate.version}

Then we add the @Audited annotation, either on an @Entity (to audit the whole entity) or on specific @Columns (if we need to audit specific properties only):

@Entity @AuditTable(value = "au_drone") public class Drone implements Serializable {      @Id     @GeneratedValue(strategy = GenerationType.IDENTITY)     private Long id;        @NotEmpty     private String serialNumber;             private int weightLimit;      @Audited          private int batteryCapacity;      ... }

@AuditTable is an optional annotation that defines the name of the audit table in the database. In default case, Envers creates an audit table with the name of “tableName_AUD.” Audit table suffix (for all audit tables) and other configurations can be changed in the application properties file.

In case of not to audit a field of an audited Entity, @NotAudited annotation should be used. As an example, password changes are not important for auditing. With @NotAudited annotation, changes of the “password” attribute will be ignored by Envers.

@Entity @Audited public class User implements Serializable { 	@NotEmpty     private String login;            @NotEmpty     private String userName;          @NotAudited 	private String password;      ... }

You can automatically create audit log tables using set hibernate.hbm2ddl.auto property in a development environment for create, create-drop, or update.

Spring Data JPA for Auditing

Spring Data JPA, an integral part of the Spring Data project, simplifies database access with JPA and enhances auditing capabilities. In this section, we will explore the built-in auditing annotations provided by Spring Data JPA, including @CreatedBy, @CreatedDate, @LastModifiedBy, and @LastModifiedDate. These annotations empower you to effortlessly incorporate auditing attributes into your entity classes, automating the auditing process with ease.

The Role of Spring Data JPA Annotations

Spring Data JPA offers a suite of annotations designed specifically for auditing purposes. These annotations eliminate the need for manual configuration and coding, streamlining the implementation of auditing features in your Spring Boot application.

Let’s take a closer look at these annotations:

 @CreatedBy and @LastModifiedBy

@CreatedBy: This annotation marks a field or property as the creator of an entity.

@LastModifiedBy: It signifies the last user who modified an entity.

@Entity public class Product {         @CreatedBy     @ManyToOne     private User createdBy;      @LastModifiedBy     @ManyToOne     private User lastModifiedBy;      ... }

In the example above, createdBy and lastModifiedBy are associated with a User entity, indicating the user responsible for the creation and last modification of a Product entity.

@CreatedDate and @LastModifiedDate

@CreatedDate: This annotation captures the timestamp when an entity is created.

@LastModifiedDate: It records the timestamp of the last modification.

@Entity public class Product {      @CreatedDate     private LocalDateTime createdDate;      @LastModifiedDate     private LocalDateTime lastModifiedDate; 	   ... }

In this example, createdDate and lastModifiedDate are used to store the timestamps of when the Product entity was created and last modified, respectively.

Enabling Spring Data JPA Auditing

To leverage Spring Data JPA’s auditing annotations, you need to enable auditing in your Spring Boot application. Follow these steps:

Step 1: Add @EnableJpaAuditing Annotation

In your Spring Boot application’s main configuration class, add the @EnableJpaAuditing annotation to enable Spring Data JPA’s auditing features.

@SpringBootApplication @EnableJpaAuditing public class YourApplication {     public static void main(String[] args) {         SpringApplication.run(YourApplication.class, args);     } }

Step 2: Use Auditing Annotations in Entity Classes

Annotate your JPA entity classes with the relevant Spring Data JPA auditing annotations, as demonstrated in the previous examples.

With auditing enabled and the appropriate annotations added to your entity classes, Spring Data JPA will automatically manage the audit fields for you. It will populate these fields with the necessary information during entity creation and modification.

Benefits of Spring Data JPA Auditing

Spring Data JPA’s built-in auditing annotations provide several advantages:

  • Simplicity: They eliminate the need for manual implementation of audit fields and logic.
  • Consistency: The annotations ensure a standardized approach to auditing across your application.
  • Automation: Auditing information is automatically captured, reducing the risk of errors.
  • Flexibility: You can easily customize auditing behavior when needed.


In the realm of software development, where data security, accountability, and transparency are paramount, auditing is an essential practice. In this comprehensive guide, we’ve explored the intricacies of implementing auditing in Spring Boot applications using JPA, Hibernate, and Spring Data JPA.

We began our journey by setting up a Spring Boot project, understanding the significance of a well-structured foundation. We then delved into the core concepts of auditing with JPA and Hibernate, learning how to capture data changes with ease.

Spring Data JPA’s auditing annotations proved to be a powerful tool in automating auditing processes. We harnessed these annotations to effortlessly track user actions, timestamps, and modification history.

Software development Spring Data Data (computing) Hibernate Java (programming language) Spring Boot

Opinions expressed by MaximusDevs contributors are their own.

You may also like

Leave a Comment