Optimizing entities with JPA lifecycle events
Introduction
In this article, we will explore how to leverage JPA entity lifecycle events, with a particular focus on @PrePersist and @PreUpdate, to enhance code readability and maintainability. By the end of this article, you will gain a clear understanding of how to utilize these lifecycle events to optimize your entities and improve overall performance.
Table of Contents
Requirements
Implementation of BusinessEntity
@Getter
@Setter
@Entity
@Table(name = "business_tab")
@SQLRestriction("deleted_at is null")
@NoArgsConstructor
public class BusinessEntity {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
@Column(name = "created_at", updatable = false)
private LocalDateTime createdAt;
@Column(name = "updated_at", insertable = false)
private LocalDateTime updatedAt;
@Column(name = "deleted_at", nullable = true)
private LocalDateTime deletedAt;
@Column(nullable = false)
private String name;
@Column(nullable = true)
private String description;
@Column(name = "owner_id", nullable = false)
private String ownerId;
@Column(name = "path", nullable = false, unique = true)
private String path;
}
Implementation of ServiceEntity
@Getter
@Setter
@Entity
@Table(name = "service_tab")
@SQLRestriction("deleted_at is null")
@NoArgsConstructor
public class ServiceEntity {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
@Column(nullable = false)
private String name;
@Column(nullable = false)
private int time;
@Column(name = "created_at", updatable = false)
private LocalDateTime createdAt;
@Column(name = "updated_at", insertable = false)
private LocalDateTime updatedAt;
@Column(name = "deleted_at", nullable = true)
private LocalDateTime deletedAt;
}
As you can notice, entities typically share common information, such as the id, the creation date, the last updated date, and, if using soft deletion, the deletion date.
We need to refine our code to eliminate duplicate lines. We’ll achieve this by leveraging lifecycle entities, applying the object-oriented principle of inheritance, and utilizing JPA’s @MappedSuperclass annotation.
Setting up BaseEntity
@Data
public class BaseEntity implements Serializable {
private static final long serialVersionUID = 4871858767721157958L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
@Column(name = "created_at", updatable = false)
private LocalDateTime createdAt;
@Column(name = "updated_at", insertable = false)
private LocalDateTime updatedAt;
@Column(name = "deleted_at", nullable = true)
private LocalDateTime deletedAt;
@Data
@MappedSuperclass
public class BaseEntity implements Serializable {
private static final long serialVersionUID = 4871858767721157958L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
@Column(name = "created_at", updatable = false)
private LocalDateTime createdAt;
@Column(name = "updated_at", insertable = false)
private LocalDateTime updatedAt;
@Column(name = "deleted_at", nullable = true)
private LocalDateTime deletedAt;
}
Great! Now, our JPA entities look way cleaner.
@Getter
@Setter
@Entity
@Table(name = "business_tab")
@SQLRestriction("deleted_at is null")
@NoArgsConstructor
public class BusinessEntity extends BaseEntity {
private static final long serialVersionUID = 1L;
@Column(nullable = false)
private String name;
@Column(nullable = true)
private String description;
@Column(name = "owner_id", nullable = false)
private String ownerId;
@Column(name = "path", nullable = false, unique = true)
private String path;
}
Setting up JPA lifecycle events
Normally, we want to store the creation date every time a new entity is created but instead of adding it manually for each of our entities, we are going to leverage the JPA lifecycle events, specifically the @PrePersist.
But, what are the JPA lifecycle events?
JPA lifecycle events are callback methods that allow us to hook into the lifecycle of an entity. These events occur at specific points in an entity’s life, such as when it is persisted, updated, removed, or loaded from the database. We can use annotations to mark methods in your entity classes that should be called when these events occur.
@PrePersist is triggered before an entity is inserted into the database (before the persist operation). It is very useful for initializing default values or setting timestamps. On the other hand, @PostPersist is triggered after an entity is inserted into the database.
Moreover, @PreUpdate is triggered before an entity is updated in the database (before the merge operation). Similarly, @PostUpdate is triggered after the entity is updated in the database.
@PreRemove is triggered before an entity is removed from the database. It is often used for cleanup tasks or for setting a “soft delete” flag. On the contrary, @PostRemove is triggered after the entity is removed from the database.
Finally, there is also @PostLoad, which is triggered after an entity has been loaded from the database.
How can we leverage JPA lifecycle events?
We can utilize the @PrePersist annotation to automatically set the creation date of an entity. The @PreUpdate annotation will help us maintain the most recent update timestamp.
Finally, the BaseEntity looks as follows and our other entities are clean and free of duplication.
@Data
@MappedSuperclass
public class BaseEntity implements Serializable {
private static final long serialVersionUID = 4871858767721157958L;
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
@Column(name = "id")
private Long id;
@Column(name = "created_at", updatable = false)
private LocalDateTime createdAt;
@Column(name = "updated_at", insertable = false)
private LocalDateTime updatedAt;
@Column(name = "deleted_at", nullable = true)
private LocalDateTime deletedAt;
@PrePersist
protected void setCreatedAt() {
this.createdAt = LocalDateTime.now();
}
@PreUpdate
protected void setUpdatedAt() {
this.updatedAt = LocalDateTime.now();
}
}
Whenever a new entity is inserted or an existing one is updated, the corresponding dates will be automatically refreshed.
Conclusion
Using JPA lifecycle events such as @PrePersist and @PreUpdate improves our entity management by automating the handling of important timestamps and soft delete flags. We ensure that our entities always reflect accurate creation, update, and deletion information.
If you are interested in learning more about Spring Boot, check the Spring Boot section now.