Spring Boot – JPA Metadata handling (created…, lastModified…)

A lot of Customer want to store some Metadata to an entry in the database. The most common are

  • When the entry was created         (createdDate)
  • When the entry was lastly updated (lastModifiedDate)
  • Who created the entry                 (createdBy)
  • Who modified the entry lately       (lastModifiedBy)

One way handling this different things is by performing the actions manually. Everytime you write in the database you could intercept, get the entry add the metadata to this and write the entry to your database (again).
That´s a well known way but I think it isn´t a very comfortable way.

In the following Post we will look at how to achieve this without writing a bunch of code or have to intercept in an transaction.


Before we start with our intercepting please make sure you have a Spring Boot Application that you can compile and run. If not, may have a look at this.

Maven Dependencies

Furthermore make sure you have the following dependencies added to your pom.xml. 

    <relativePath/> <!-- lookup parent from repository -->

If you have an application with Rest API you have to add some more dependencies. But this is just a hint, for our example you don´t have to.

Hero Entity

This example will work with the an entity called hero. Nothing special about it (for now). Just define it like this

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

 * @author javadevcorner.com
public class Hero {

    @GeneratedValue(strategy = GenerationType.AUTO)
    private long id;

    @Column(name = "HERO_NAME")
    private String heroName;
    //getter and setter


Now we start with the implementation of our Metadata Handler.

Generic Metadata Class

First of all we have to define an entity that contains the metadata we want to have.
Because we don´t want to implement the the metadata over and over again we´ll define them in an abstract class. This one can be extend by every entity that needs this metadata.

import java.util.Date;
import javax.persistence.EntityListeners;
import javax.persistence.MappedSuperclass;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;

 * @author javadevcorner.com
public abstract class Auditable<T> {

    protected T createdBy;

    protected Date creationDate;

    private T lastModifiedBy;

    protected Date lastModifiedDate;

    //setter and getter

Because this class will be Superclass to many other entities please annotate it with @MappedSuperclass.
Because we want to store auditing information we use the AuditingEntityListener to capture this information on persisting or updating entries. The AuditingEntityListener works via Callback Methods annotated with the @PrePersist and @PreUpdate annotation.

Modify Hero

As you maybe already mentioned the Auditable Superclass has to become the mother of our hero.

public class Hero extends Auditable<String> {
    //everything else stays the same - no changes needed

If you would start the application now and would retrieve some data, every thing (except the hero specifiy attributes) would be null. So there´s something missing.

Enable and Define JPA Auditing

The thing that is missing for our example is the configuration of our JPA.

import java.util.Optional;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.domain.AuditorAware;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;

 * @author javadevcorner.com
public class AuditingConfiguration {

    public AuditorAware<String> auditorProvider() {
        return new AuditorAwareImpl();
    class AuditorAwareImpl implements AuditorAware<String> {

        public Optional<String> getCurrentAuditor() {
            return Optional.of("javadevcorner");
            //If you´re working with the security context here is the place 
            //where you call your context and get the user

We use this class to define which bean should be used for the awaring process (auditorProvider()).
I´ve made an inner class for the implementation of the AuditorAware. But feel free to change it in an external class.


We looked at the problematic of storing Metadata within the persisting and updating process of (new) entries to our database. After we have added the correct maven dependencies we wrote a Superclass with the metadata as attributes and placed it in the inheritance tree above our hero entity. To perform the actions we wanted to have, we wrote a configuration class for JPA and our implementation of the AuditorAware interface to store who modified the entry.


Thanks for reading and have fun using the Spring Boot way of storing Metadata. 

Feel free to share

Leave a Reply

Your email address will not be published. Required fields are marked *

This site uses Akismet to reduce spam. Learn how your comment data is processed.