List of annotations used in JPA and Hibernate

Here is a comprehensive list of annotations used in JPA and Hibernate, grouped by functionality, along with brief explanations and examples for each.

Core JPA Annotations

Entity and Identifier

@Entity
Marks a class as a JPA entity (mapped to a database table).

@Entity
public class Employee {
    @Id
    private Long id;
}

@Table
Specifies the database table for an entity.

@Entity
@Table(name = "employees")
public class Employee {
}

@Id
Specifies the primary key.

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@GeneratedValue
Defines the generation strategy for primary keys (e.g., AUTO, IDENTITY, SEQUENCE, TABLE).
```
@GeneratedValue(strategy = GenerationType.SEQUENCE)
```

@SequenceGenerator
Defines a sequence generator for primary key generation.

@SequenceGenerator(name = "emp_seq", sequenceName = "employee_seq", allocationSize = 1)
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "emp_seq")

Field Mapping

@Column
Customizes column mapping (e.g., name, length, nullable).

@Column(name = "first_name", length = 100, nullable = false)
private String firstName;

@Transient
Marks a field as not persistent (excluded from database).
```
@Transient
private String temporaryValue;
```
@Lob
Maps large objects like CLOB or BLOB.
```
@Lob
private byte[] image;
```

@Enumerated
Maps enums (default: ORDINAL, alternative: STRING).

@Enumerated(EnumType.STRING)
private EmployeeStatus status;

@Temporal
Maps java.util.Date or Calendar to SQL date/time types (DATE, TIME, TIMESTAMP).
```
@Temporal(TemporalType.DATE)
private Date joinDate;
```

@Embedded and @Embeddable
Embeds a reusable object in the entity.

@Embeddable
public class Address {
    private String street;
    private String city;
}

@Entity
public class Employee {
    @Embedded
    private Address address;
}

@AttributeOverride
Overrides column mapping for an embedded field.

@AttributeOverride(name = "street", column = @Column(name = "home_street"))

Relationships

@OneToOne
Defines a one-to-one relationship.

@OneToOne
@JoinColumn(name = "passport_id")
private Passport passport;

@OneToMany
Defines a one-to-many relationship.

@OneToMany(mappedBy = "department")
private List<Employee> employees;

@ManyToOne
Defines a many-to-one relationship.

@ManyToOne
@JoinColumn(name = "dept_id")
private Department department;

@ManyToMany
Defines a many-to-many relationship.

@ManyToMany
@JoinTable(
    name = "employee_project",
    joinColumns = @JoinColumn(name = "employee_id"),
    inverseJoinColumns = @JoinColumn(name = "project_id")
)
private List<Project> projects;

@JoinColumn
Specifies the foreign key column.

@JoinColumn(name = "dept_id", nullable = false)

@JoinTable
Defines a join table for many-to-many relationships.

@JoinTable(
    name = "employee_project",
    joinColumns = @JoinColumn(name = "employee_id"),
    inverseJoinColumns = @JoinColumn(name = "project_id")
)

@Cascade (Hibernate-specific)
Controls cascading operations (e.g., persist, merge).
```
@OneToMany(mappedBy = "department", cascade = CascadeType.ALL)
```

Inheritance

@Inheritance
Defines inheritance strategy (SINGLE_TABLE, TABLE_PER_CLASS, JOINED).
```
@Inheritance(strategy = InheritanceType.JOINED)
```

@DiscriminatorColumn and @DiscriminatorValue
Used in the SINGLE_TABLE inheritance strategy.

@DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue("EMP")

Lifecycle Callbacks

@PrePersist, @PostPersist
Callback methods before/after persisting an entity.

@PrePersist
public void beforeSave() {
    this.createdDate = new Date();
}

@PreUpdate, @PostUpdate
Callback methods before/after updating an entity.
@PreRemove, @PostRemove
Callback methods before/after removing an entity.
@PostLoad
Callback after loading an entity.

Queries

@NamedQuery
Defines a named HQL query.

@NamedQuery(
    name = "Employee.findByName",
    query = "SELECT e FROM Employee e WHERE e.name = :name"
)

@NamedNativeQuery
Defines a named native SQL query.


@NamedNativeQuery(
    name = "Employee.findByNameNative",
    query = "SELECT * FROM employees WHERE name = :name",
    resultClass = Employee.class
)

Validation and Converters

@NotNull, @Size, @Pattern (Bean Validation)
Adds validation constraints.
```
@NotNull
@Size(max = 100)
private String name;
```

@Convert
Converts a field value using a custom converter.

@Convert(converter = YesNoConverter.class)
private Boolean isActive;

Caching

@Cacheable
Marks an entity as cacheable (used with second-level cache).
```
@Cacheable
@Entity
public class Employee {
}
```
@Cache (Hibernate-specific)
Configures caching behavior.
```
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
```

Filters (Hibernate-Specific)

@FilterDef and @Filter
Adds runtime filters to entities.


@FilterDef(name = "activeFilter", parameters = @ParamDef(name = "isActive", type = "boolean"))
@Filter(name = "activeFilter", condition = "active = :isActive")

Auditing (Hibernate Envers)

@Audited
Enables auditing of entity changes.
```
@Audited
public class Employee {
}
```
@NotAudited
Excludes specific fields from auditing.

RIET - Java developer

Search This Blog