Normal view

There are new articles available, click to refresh the page.

Before yesterdayMain stream

Journey of Full stack developer
Spring boot annotation used in entity class
17 April 2025 at 16:54

Spring boot annotation used in entity class

Journey of Full stack developer

By: kalaiarasanpandi

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 BaseEntity class is annotated with @MappedSuperclass. It contains the common fields that you want to share across multiple entity classes.
The Employee class inherits from BaseEntity, effectively inheriting the id field 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 Author entity’s reference to a Book entity is removed from the books collection, the orphaned Book entity 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:

Kalai Arasan
Spring boot annotation used in entity class
17 April 2025 at 16:54