Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

NPI – JPA Buddy – JPA (partner)
announcement - icon

JPA is huge! It covers nearly every aspect of communication between relational databases and the Java application and is deeply integrated into all major frameworks.

If you're using IntelliJ, JPA Buddy is super helpful. The plugin gently guides you through the subtleties of the most popular JPA implementations, visually reminds you of JPA features, generates code that follows best practices, and integrates intelligent inspections to improve your existing persistence code.

More concretely, it provides powerful tooling to generate Spring Data JPA repositories and methods, Flyway Versioned Migrations, Liquibase Differential Changelogs, DDL and SQL statements, DTO objects, and MapStruct interfaces.

Oh, and it actually generates JPA entities from an existing database and gradually update the data model as the database evolves! Yeah.

>> Become a lot more productive with JPA Buddy

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

1. Introduction

When working with JPA, there are several events that we can be notified of during an entity's lifecycle. In this tutorial, we'll discuss the JPA entity lifecycle events and how we can use annotations to handle the callbacks and execute code when these events occur.

We'll start by annotating methods on the entity itself and then move on to using an entity listener.

2. JPA Entity Lifecycle Events

JPA specifies seven optional lifecycle events that are called:

  • before persist is called for a new entity – @PrePersist
  • after persist is called for a new entity – @PostPersist
  • before an entity is removed – @PreRemove
  • after an entity has been deleted – @PostRemove
  • before the update operation – @PreUpdate
  • after an entity is updated – @PostUpdate
  • after an entity has been loaded – @PostLoad

There are two approaches for using the lifecycle event annotations: annotating methods in the entity and creating an EntityListener with annotated callback methods. We can also use both at the same time. Regardless of where they are, callback methods are required to have a void return type.

So, if we create a new entity and call the save method of our repository, our method annotated with @PrePersist is called, then the record is inserted into the database, and finally, our @PostPersist method is called. If we're using @GeneratedValue to automatically generate our primary keys, we can expect that key to be available in the @PostPersist method.

For the @PostPersist, @PostRemove and @PostUpdate operations, the documentation mentions that these events can happen right after the operation occurs, after a flush, or at the end of a transaction.

We should note that the @PreUpdate callback is only called if the data is actually changed — that is if there's an actual SQL update statement to run. The @PostUpdate callback is called regardless of whether anything actually changed.

If any of our callbacks for persisting or removing an entity throw an exception, the transaction will be rolled back.

3. Annotating the Entity

Let's start by using the callback annotations directly in our entity. In our example, we're going to leave a log trail when User records are changed, so we're going to add simple logging statements in our callback methods.

Additionally, we want to make sure we assemble the user's full name after they're loaded from the database. We'll do that by annotating a method with @PostLoad.

We'll start by defining our User entity:

public class User {
    private static Log log = LogFactory.getLog(User.class);

    private int id;
    private String userName;
    private String firstName;
    private String lastName;
    private String fullName;

    // Standard getters/setters

Next, we need to create a UserRepository interface:

public interface UserRepository extends JpaRepository<User, Integer> {
    public User findByUserName(String userName);

Now, let's return to our User class and add our callback methods:

public void logNewUserAttempt() {
    log.info("Attempting to add new user with username: " + userName);
public void logNewUserAdded() {
    log.info("Added user '" + userName + "' with ID: " + id);
public void logUserRemovalAttempt() {
    log.info("Attempting to delete user: " + userName);
public void logUserRemoval() {
    log.info("Deleted user: " + userName);

public void logUserUpdateAttempt() {
    log.info("Attempting to update user: " + userName);

public void logUserUpdate() {
    log.info("Updated user: " + userName);

public void logUserLoad() {
    fullName = firstName + " " + lastName;

When we run our tests, we'll see a series of logging statements coming from our annotated methods. Additionally, we can reliably expect our user's full name to be populated when we load a user from the database.

4. Annotating an EntityListener

We're going to expand on our example now and use a separate EntityListener to handle our update callbacks. We might favor this approach over placing the methods in our entity if we have some operation we want to apply to all of our entities.

Let's create our AuditTrailListener to log all the activity on the User table:

public class AuditTrailListener {
    private static Log log = LogFactory.getLog(AuditTrailListener.class);
    private void beforeAnyUpdate(User user) {
        if (user.getId() == 0) {
            log.info("[USER AUDIT] About to add a user");
        } else {
            log.info("[USER AUDIT] About to update/delete user: " + user.getId());
    private void afterAnyUpdate(User user) {
        log.info("[USER AUDIT] add/update/delete complete for user: " + user.getId());
    private void afterLoad(User user) {
        log.info("[USER AUDIT] user loaded from database: " + user.getId());

As we can see from the example, we can apply multiple annotations to a method.

Now, we need to go back to our User entity and add the @EntityListener annotation to the class:

public class User {

And, when we run our tests, we'll get two sets of log messages for each update action and a log message after a user is loaded from the database.

5. Conclusion

In this article, we've learned what the JPA entity lifecycle callbacks are and when they're called. We looked at the annotations and talked about the rules for using them. We've also experimented with using them in both an entity class and with an EntityListener class.

The example code is available over on GitHub.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


Persistence footer banner
Comments are closed on this article!