Entity Mapping and Configuration

Mapping is the process of telling Hibernate exactly how a Java class and its fields correspond to a database table and its columns. Modern Hibernate uses JPA annotations directly on the entity class, which keeps the mapping next to the code it describes instead of in a separate XML file.

Core Mapping Annotations

A handful of annotations cover the majority of real-world mapping needs.

• @Entity — marks a class as a persistent entity; it must have a no-argument constructor and a primary key field.
• @Table(name = "...") — maps the class to a specific table name (optional; defaults to the class name).
• @Id — designates the primary key field.
• @GeneratedValue(strategy = GenerationType.IDENTITY) — lets the database auto-generate the primary key (e.g. AUTO_INCREMENT); other strategies include SEQUENCE and TABLE.
• @Column(name = "...", nullable = false, unique = true, length = 100) — customizes how a field maps to its column.
• @Transient — marks a field that should not be persisted at all (e.g. a computed, in-memory-only value).
• @Enumerated(EnumType.STRING) — stores a Java enum as readable text rather than its ordinal integer, which is safer against future reordering of enum constants.

Primary Key Generation Strategies

IDENTITY delegates key generation entirely to the database's auto-increment column — simple, but it means Hibernate cannot batch inserts efficiently, since it must ask the database for the generated id after each insert. SEQUENCE uses a database sequence object to pre-allocate ids, which allows efficient batching and is generally preferred for high-throughput inserts on databases that support sequences (PostgreSQL, Oracle). TABLE emulates a sequence using an ordinary table and is the most portable but slowest option, used mainly when a database supports neither identity columns nor sequences.

hbm2ddl.auto — Schema Generation Modes

This property controls whether Hibernate touches your schema at startup: validate only checks the schema matches the entities and fails fast if not (the safest for production); update adds missing tables/columns without dropping data (convenient in early development, risky in production); create drops and recreates the schema on every startup (useful for tests); create-drop does the same but also drops everything on shutdown. Production systems typically use validate and manage real schema changes with a migration tool like Flyway or Liquibase instead.

Example

import jakarta.persistence.*;

@Entity
@Table(name = "employee", uniqueConstraints = @UniqueConstraint(columnNames = "email"))
public class Employee {

    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "emp_seq")
    @SequenceGenerator(name = "emp_seq", sequenceName = "employee_seq", allocationSize = 1)
    private long id;

    @Column(name = "full_name", nullable = false, length = 120)
    private String name;

    @Column(nullable = false, unique = true)
    private String email;

    @Enumerated(EnumType.STRING)
    private Status status;

    @Transient
    private int yearsOfServiceComputedAtRuntime; // never persisted

    public enum Status { ACTIVE, ON_LEAVE, TERMINATED }

    // getters and setters
}

Hibernate: insert into employee (full_name, email, status, id) values (?, ?, ?, ?)

Exercise

A teammate is about to make this mistake: Storing enums with the default (ordinal) mapping instead of @Enumerated(EnumType.STRING) — reordering enum constants later silently corrupts existing data. Use Core Mapping Annotations to review the decision. Write a corrected implementation or design sketch that follows @Entity, @Table, @Id, and @GeneratedValue are the essential annotations for mapping a class to a table., then name one edge case you would check.

Quick quiz

Interview questions