Login
Spring boot annotation used in entity class
17 April 2025 at 16:54
Class based Annotation:
- @Entity – used to indicates the class is below to JPA entites.
- @Table – is used to indicates the table name.
- @MappedSuperClass – is used to parent entity, which can be inherited by many entities, but it won’t be mapped to its own table. we cannot use @Entity annotation on this class.
@MappedSuperclass
public abstract class BaseEntity implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
// Getters and setters
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
}
@Entity
@Table(name = "employees")
public class Employee extends BaseEntity {
private String firstName;
private String lastName;
// Constructors, getters, setters, other fields...
}
- In this example, the
BaseEntityclass is annotated with@MappedSuperclass. It contains the common fields that you want to share across multiple entity classes. - The
Employeeclass inherits fromBaseEntity, effectively inheriting theidfield from the superclass. - By using
@MappedSuperclass, you’re able to create a common base class for your entity hierarchy while allowing each subclass to include additional fields and annotations specific to their needs. - This promotes code reusability and maintains a clean and structured entity hierarchy.
Primary Keys
- Define a primary key using @Id.
- Use @GeneratedValue with appropriate strategy for generating primary key values (e.g., GenerationType.IDENTITY, GenerationType.SEQUENCE)
@Entity
public class Product {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
// other fields, getters, setters
}
Associations
It says the relationship between two entity class.
- Use @OneToOne, @OneToMany, @ManyToOne, and @ManyToMany to define relationships between entities.
- Use fetch attribute to control loading behavior (e.g., LAZY or EAGER).
- Utilize mappedBy to define the owning side of bidirectional relationships.
@Entity
public class Department {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
@OneToMany(mappedBy = "department",cascade=CascadeType.ALL)
private List<Employee> employees;
// Constructors, getters, setters, other fields...
}
@Entity
public class Employee {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String firstName;
private String lastName;
@ManyToOne
@JoinColumn(name = "department_id")
private Department department;
// Constructors, getters, setters, other fields...
}
Cascading Operations
- Use cascade attribute to specify cascading operations (e.g., CascadeType.ALL, CascadeType.PERSIST).
- Be cautious with cascading DELETE to avoid unintentional data loss.
import javax.persistence.*;
import java.util.List;
@Entity
public class Author {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String name;
@OneToMany(mappedBy = "author", cascade = CascadeType.ALL, orphanRemoval = true)
private List<Book> books;
// Constructors, getters, setters, other fields...
}
@Entity
public class Book {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String title;
@ManyToOne
@JoinColumn(name = "author_id")
private Author author;
// Constructors, getters, setters, other fields...
}
- CascadeType.ALL: This option specifies that all operations (e.g., persist, merge, remove) should be cascaded from the parent entity (
Author) to the child entity (Book). - orphanRemoval = true: This option specifies that when an
Authorentity’s reference to aBookentity is removed from thebookscollection, the orphanedBookentity should also be removed from the database
When you perform a cascading operation on the Author entity, the corresponding operation will cascade to the associated Book entities. For instance.
Author author = new Author();
author.setName("J.K. Rowling");
Book book1 = new Book();
book1.setTitle("Harry Potter and the Sorcerer's Stone");
book1.setAuthor(author);
Book book2 = new Book();
book2.setTitle("Harry Potter and the Chamber of Secrets");
book2.setAuthor(author);
author.setBooks(Arrays.asList(book1, book2));
// Cascading persist: Saving the author will also save both associated books.
entityManager.persist(author);
Likewise, cascading operations work for merge, remove, and other entity operations, reducing the need for explicitly managing related entities persistence.
Validation
Use validation annotations (@NotNull, @Size, etc.) to enforce data integrity constraints directly in the entity class.
Combine JPA validation with Spring’s @Valid annotation to automatically validate incoming data.
@Entity
public class Post {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@NotBlank(message = "Title is required")
@Size(max = 100, message = "Title must be at most 100 characters")
private String title;
@OneToMany(mappedBy = "post", cascade = CascadeType.ALL)
private List<Comment> comments;
// Constructors, getters, setters, other fields...
}
@Entity
public class Comment {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@NotBlank(message = "Text is required")
@Size(max = 500, message = "Text must be at most 500 characters")
private String text;
@ManyToOne
@JoinColumn(name = "post_id")
private Post post;
// Constructors, getters, setters, other fields...
}
Auditing
- Implement entity auditing by adding fields like @CreatedBy, @CreatedDate, @LastModifiedBy, and @LastModifiedDate for tracking who created or modified an entity and when.
- Utilize Spring’s @EntityListeners to manage the auditing behavior.
@EntityListeners(AuditingEntityListener.class)
@MappedSuperclass
public abstract class Auditable {
@CreatedBy
protected String createdBy;
@CreatedDate
@Column(nullable = false, updatable = false)
protected LocalDateTime createdDate;
@LastModifiedBy
protected String lastModifiedBy;
@LastModifiedDate
protected LocalDateTime lastModifiedDate;
// Getters and setters...
}
- @EntityListeners(AuditingEntityListener.class): This annotation specifies that this entity should be audited using the provided entity listener class. Spring Data JPA will automatically update the auditing fields before persisting or updating the entity.
- @MappedSuperclass: This annotation indicates that this class is not an entity itself but serves as a base class for other entities. It allows attributes and behaviors to be inherited by other entities.
- @CreatedBy: This annotation specifies the field to store the username of the user who created the entity.
- @CreatedDate: This annotation marks the field to store the timestamp when the entity was created. The nullable and updatable properties are set to false to ensure that this field is populated during creation and not updated afterwards.
- @LastModifiedBy: This annotation specifies the field to store the username of the user who last modified the entity.
- @LastModifiedDate: This annotation marks the field to store the timestamp when the entity was last modified.
By implementing auditing, you can track who created or modified entities and when those actions occurred. This information can be invaluable for monitoring and maintaining your application’s data.
Enums and Enumerated Types
- Use Java enums for fields with predefined values.
- Annotate enum fields with @Enumerated(EnumType.STRING) to store enum values as strings in the database.
@Entity
public class Task {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Enumerated(EnumType.STRING)
private TaskStatus status;
// other fields, getters, setters
}
public enum TaskStatus {
TODO, IN_PROGRESS, DONE
}
Reference:
- https://medium.com/@bubu.tripathy/best-practices-entity-class-design-with-jpa-and-spring-boot-6f703339ab3d
- https://medium.com/@bubu.tripathy/best-practices-entity-class-design-with-jpa-and-spring-boot-6f703339ab3d
