What Is Hibernate ORM?

When you use JDBC to read a row from a database, you normally write a SQL query, execute it, and copy the values from the ResultSet into a Java object. If your application has classes such as Book, Author, and Publisher, you repeat this kind of mapping for each class.

Hibernate ORM is a Java framework that handles much of this mapping. You describe how your Java classes correspond to tables, and Hibernate uses that information to load objects and save changes. This series uses Java 25 and Hibernate ORM 7.4.15.Final, the latest stable release as of November 9, 2026. Hibernate ORM 7.4 implements Jakarta Persistence 3.2. See the Hibernate ORM release notes.

What does ORM mean?

ORM stands for object-relational mapping. It connects the way Java represents data as objects with the way a relational database stores data in tables.

For a simple book catalog, the mapping looks like this.

Java Database
Book class books table
One Book object One row in books
id field id primary key column
title field title column

A class that Hibernate can persist is called an entity. Here is the first entity in our catalog.

package org.kodejava.hibernate;

import jakarta.persistence.Column;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;

@Entity
@Table(name = "books")
public class Book {
    @Id
    private Long id;

    @Column(nullable = false)
    private String title;

    protected Book() {
    }

    public Book(Long id, String title) {
        this.id = id;
        this.title = title;
    }

    public String getTitle() {
        return title;
    }
}
  • @Entity marks Book as a persistent entity.
  • @Table(name = "books") maps the entity to the books table.
  • @Id identifies the field that maps to the primary key. This example assigns the ID in the constructor.
  • @Column(nullable = false) declares the title column as non-nullable in the mapping.

Hibernate can read and write the mapped fields directly because the mapping annotations are on the fields. The protected no-argument constructor allows the persistence provider to instantiate a Book when it loads data.

How does Hibernate save an object?

After Hibernate is configured, you can use an EntityManager to work with entities. The following snippet assumes an existing EntityManager and an active transaction.

Book book = new Book(1L, "Effective Java");
entityManager.persist(book);

Calling persist() makes the new Book a managed entity. Hibernate now tracks it in the persistence context. When Hibernate flushes the context, typically as part of committing the transaction, it executes an SQL statement similar to this one.

insert into books (title, id) values (?, ?)

Hibernate binds the values from the object to those parameters and executes the statement through JDBC. You can load a book by its primary key with entityManager.find(Book.class, 1L). If the persistence context already manages that book, Hibernate can return it directly. Otherwise, Hibernate can load it from the database, and find() returns null if the book does not exist.

What is the difference between Jakarta Persistence and Hibernate?

Jakarta Persistence, often called JPA, defines standard annotations and interfaces such as @Entity, @Id, and EntityManager. Hibernate ORM implements that standard and provides its own API, including SessionFactory and Session.

We will start with Jakarta Persistence so you can learn the standard mapping and transaction APIs. Later articles will use Hibernate-specific features where they help solve a concrete problem, such as inspecting SQL activity or tuning fetch behavior. The Hibernate ORM Javadocs describe both APIs.

Where does JDBC fit?

Hibernate uses JDBC to communicate with the database. With plain JDBC, you usually write the SQL and map the results yourself. With Hibernate, you provide entity mappings, and Hibernate handles many routine operations, such as inserting a row or finding it by primary key.

The SQL still matters. Loading a list of books and then accessing each book’s author can trigger extra queries. Later in the series, we will inspect the generated SQL and see how a fetch join can avoid that pattern.

In the next article, we will create a Maven project, configure an in-memory H2 database, and run the Book example from start to finish. We will use plain Java to make the Hibernate configuration and transaction boundaries visible.

Maven Dependencies

Add the following dependency inside the <dependencies> section of your pom.xml. Hibernate Core brings in the Jakarta Persistence API transitively, including the annotations used above. To run the example against a database, you will also need a JDBC driver. We will add the H2 driver in the next article.

<dependency>
    <groupId>org.hibernate.orm</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>7.4.15.Final</version>
</dependency>

How do I handle Detached objects and reattach them using Hibernate?

In Hibernate, detached objects are objects that were previously associated with a Hibernate Session, but that Session has since been closed, leaving the object in a detached state. Detached objects are not currently managed by any Session, so they are not automatically synchronized with the database. If you want to reattach these objects to a new session, Hibernate provides a couple of operations to handle them:


1. Using Session.update()

The update() method reattaches a detached object to the current session and marks it as persistent. The object must represent a row that already exists in the database. If there are issues (e.g., the object doesn’t exist in the database), an exception will be thrown.

Example:

Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();

MyEntity detachedEntity = getDetachedEntity(); // Detached entity

// Reattach the detached entity to the session
session.update(detachedEntity);

// After reattachment, changes to the entity will be synchronized with the database
detachedEntity.setSomeField("newValue");

transaction.commit();
session.close();

Note: Use update() only when you are sure that the detached entity exists in the database.


2. Using Session.merge()

The merge() method is often a better approach for reattaching detached objects, as it handles the entity more flexibly. If the object exists in the database, it merges the changes from the detached entity into the persistent object in the session. If it doesn’t exist, it creates a new database row.

Example:

Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();

MyEntity detachedEntity = getDetachedEntity(); // Detached entity

// Merge the detached entity with the session
MyEntity mergedEntity = (MyEntity) session.merge(detachedEntity);

// Use the merged entity for further operations
mergedEntity.setSomeField("anotherValue");

transaction.commit();
session.close();

Key Differences Between update() and merge():
– update() can throw NonUniqueObjectException if an object with the same identifier is already associated with the session.
– merge() does not throw an exception—it creates a new instance in the session if an object with the same identifier is already associated.


3. Using Session.saveOrUpdate() (Not Recommended for Detached Objects)

The saveOrUpdate() method can accept both transient and detached objects. For detached objects, it either updates the corresponding row in the database or saves it if it’s not already present. However, this method is not as commonly used for handling detached objects as update() or merge().

Example:

Session session = sessionFactory.openSession();
Transaction transaction = session.beginTransaction();

MyEntity detachedEntity = getDetachedEntity(); // Detached entity

// Save or update the detached entity
session.saveOrUpdate(detachedEntity);

transaction.commit();
session.close();

Note: This method can be less predictable when dealing with detached objects compared to merge().


Common Scenarios and Approaches

  • When you need to reattach a detached object and persist its changes: Use merge().
  • When you know the object already exists in the database: Use update().
  • Avoid session conflicts: If a different object with the same identifier is already in the new session, prefer merge() because update() will result in an exception.

Best Practices

  • Ensure entities have properly defined identifiers (@Id) to avoid Hibernate-related issues when reattaching.
  • Use merge() when you are uncertain about whether the object is persistent or detached, as it adapts to the situation.
  • Keep sessions short and transactions small to reduce occurrences of detached objects.

By understanding and implementing these methods appropriately, you can effectively handle detached objects and ensure smooth database operations in a Hibernate-based application.

How do I batch insert or update data using Hibernate efficiently?

Batch inserting or updating data efficiently with Hibernate can significantly improve performance, especially when dealing with large datasets. Below are best practices and steps to achieve this:


1. Enable Hibernate Batch Processing

  • Configure Hibernate for batch processing by setting the hibernate.jdbc.batch_size property in your Hibernate configuration:
hibernate.jdbc.batch_size=20

This specifies the number of SQL statements to batch before executing them.


2. Use Stateless Sessions

  • Stateless sessions in Hibernate can be used for bulk operations since they don’t maintain a persistent context (no caching, dirty checking, etc.), resulting in better performance for inserts and updates:
try (StatelessSession statelessSession = sessionFactory.openStatelessSession()) {
    statelessSession.beginTransaction();
    for (Entity entity : entities) {
        statelessSession.insert(entity); // For batch inserts
    }
    statelessSession.getTransaction().commit();
}

However, keep in mind that StatelessSession sacrifices some features of the Hibernate Session, such as caching.


3. Control the Flush Mode

  • When using a traditional Session, set the flush mode to COMMIT to reduce the frequency of session flushing:
session.setFlushMode(FlushMode.COMMIT);

This avoids automatic flushing after every operation and significantly improves performance.


4. Batch Save or Update

  • Process entities in chunks and manually flush and clear the session to prevent memory overhead and ensure efficient batch execution:
int batchSize = 20; // Define batch size
Session session = sessionFactory.openSession();
session.beginTransaction();

for (int i = 0; i < entities.size(); i++) {
    session.saveOrUpdate(entities.get(i));

    if (i % batchSize == 0 && i > 0) { // Execute batch
        session.flush();
        session.clear(); // Clear the persistence context
    }
}

session.getTransaction().commit();
session.close();

This approach avoids storing too many entities in memory.


5. Use Native SQL for Bulk Operations

  • For massive updates that don’t require Hibernate’s lifecycle benefits, native SQL queries might be more efficient:
String updateQuery = "UPDATE Entity SET status = :status WHERE condition = :condition";
Query query = session.createQuery(updateQuery);
query.setParameter("status", newStatus);
query.setParameter("condition", condition);
int rowsUpdated = query.executeUpdate();

This approach avoids loading entities into memory.


6. Optimize JDBC Batch Settings

  • Configure JDBC for optimal performance when batching. Ensure that the database driver supports batching and is properly configured.

7. Avoid Cascading with Large Batches

  • Cascading operations (e.g., CascadeType.ALL) can cause performance degradation if there are many associated entities. Instead, manage the lifecycle of associations manually.

8. Index SQL Statements Properly

  • Ensure that the database tables involved in batch updates or inserts have the appropriate indexes for your operations.

9. Monitor and Test

  • Use Hibernate logs to monitor SQL being executed:
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.use_sql_comments=true
  • Enable Hibernate statistics or use a profiling tool to analyze the performance:
Session session = sessionFactory.openSession();
Statistics stats = sessionFactory.getStatistics();
stats.setStatisticsEnabled(true);
  • Regularly test to find the optimal batch size for your environment, as it depends on factors like memory and database capabilities.

Summary

By batching operations, clearing the persistence context, and tuning Hibernate and database configurations, you can optimize the performance of batch inserts or updates. Large datasets will benefit greatly when you combine batching with techniques like StatelessSession and native SQL for non-critical use cases.

How do I customize table and column names using Hibernate annotations?

In Hibernate, you can customize table and column names using JPA annotations such as @Table and @Column. These annotations allow you to define how your entity classes map to the database tables and columns. Here’s how you can do it:

Customize the Table Name

To specify a custom table name, use the @Table annotation on the class level. You define the table name by setting the name attribute of the @Table annotation.

import jakarta.persistence.Entity;
import jakarta.persistence.Table;

@Entity
@Table(name = "custom_table_name")
public class MyEntity {
    // Other fields and methods
}

In this example, the associated database table for the MyEntity class will be named custom_table_name.

Customize the Column Names

To customize column names, use the @Column annotation on the field or property. You can specify the name of the column by setting the name attribute of the annotation.

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Column;

@Entity
public class MyEntity {

    @Id
    private Long id;

    @Column(name = "custom_column_name")
    private String myField;

    // Getters and Setters
}

Here, the myField field will map to the column custom_column_name in the database.

Complete Example

Below is a complete example demonstrating both:

import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import jakarta.persistence.Column;

@Entity
@Table(name = "custom_table_name")
public class MyEntity {

    @Id
    private Long id;

    @Column(name = "custom_column_name")
    private String customField;

    @Column(name = "date_of_creation", nullable = false, unique = true)
    private String creationDate;

    // Getters and Setters
}
  • The @Table annotation maps the class to a custom table name (custom_table_name).
  • The @Column annotation maps the fields to custom column names (custom_column_name and date_of_creation).
  • Optional attributes like nullable, unique, length, etc., allow further customization.

Notes

  1. Default Naming: If you omit the @Table or @Column annotations, Hibernate will use default naming strategies (usually camelCase names are converted to snake_case for the database).
  2. Schema or Catalog: You can also specify a schema or catalog in the @Table annotation:
    @Table(name = "custom_table_name", schema = "my_schema")
    
  3. Column Options: The @Column annotation includes additional options like:
    • nullable: Whether the column allows nulls.
    • unique: Whether the column should have a unique constraint.
    • length: The length of the column (useful for VARCHAR columns).
    • precision and scale: For DECIMAL and NUMERIC columns.

This level of customization gives you precise control over how your Java entities are mapped to database tables and columns.

How do I implement auditing using @CreationTimestamp and @UpdateTimestamp?

In Hibernate (or when using JPA with Hibernate), you can use annotations such as @CreationTimestamp and @UpdateTimestamp to handle automatic auditing for fields such as creation time and last updated time. These annotations are commonly used to automatically populate Date or LocalDateTime fields whenever an entity is created or updated.

Here’s how you would implement auditing using these annotations:

Example of an Entity with Auditing Fields

package org.kodejava.hibernate;

import jakarta.persistence.Entity;
import jakarta.persistence.GeneratedValue;
import jakarta.persistence.GenerationType;
import jakarta.persistence.Id;
import org.hibernate.annotations.CreationTimestamp;
import org.hibernate.annotations.UpdateTimestamp;

import java.time.LocalDateTime;

@Entity
public class AuditedEntity {

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

    @CreationTimestamp
    @Column(updatable = false) // Ensure this column isn't updated during entity updates
    private LocalDateTime createdAt;

    @UpdateTimestamp
    private LocalDateTime updatedAt;

    // Getters and Setters
    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public LocalDateTime getCreatedAt() {
        return createdAt;
    }

    public void setCreatedAt(LocalDateTime createdAt) {
        this.createdAt = createdAt;
    }

    public LocalDateTime getUpdatedAt() {
        return updatedAt;
    }

    public void setUpdatedAt(LocalDateTime updatedAt) {
        this.updatedAt = updatedAt;
    }
}

Explanation of the Annotations

  1. @CreationTimestamp:
    • This annotation is used to automatically set the creation date/time when a row is first inserted into the database.
    • It gets the timestamp of when the entity is persisted.
  2. @UpdateTimestamp:
    • This annotation is used to automatically update the field with the current timestamp whenever the entity is updated in the database.

Both annotations work with java.util.Date, java.sql.Timestamp, or java.time classes like LocalDateTime.

How It Works

  • The field annotated with @CreationTimestamp is set only once during the insert operation.
  • The field annotated with @UpdateTimestamp is updated every time the entity is updated in the database.

Prerequisites

  • Ensure that Hibernate is being used as the JPA provider.
  • The annotated fields’ values will depend on the database or Hibernate interceptors — meaning Hibernate will manage the timestamps, not your application code.

Use in Application

package org.kodejava.hibernate;

import jakarta.persistence.EntityManager;
import jakarta.persistence.EntityManagerFactory;
import jakarta.persistence.Persistence;

import java.util.Optional;

public class AuditedEntityService {

    private final EntityManagerFactory entityManagerFactory;

    public AuditedEntityService() {
        this.entityManagerFactory = Persistence.createEntityManagerFactory("my-persistence-unit");
    }

    public AuditedEntity createEntity() {
        EntityManager em = entityManagerFactory.createEntityManager();
        em.getTransaction().begin();

        AuditedEntity entity = new AuditedEntity();
        entity.setName("Foo");
        em.persist(entity);

        em.getTransaction().commit();
        em.close();

        return entity;
    }

    public Optional<AuditedEntity> findEntityById(Long id) {
        EntityManager em = entityManagerFactory.createEntityManager();
        AuditedEntity entity = em.find(AuditedEntity.class, id);
        em.close();

        return Optional.ofNullable(entity);
    }

    public AuditedEntity updateEntity(Long id) {
        EntityManager em = entityManagerFactory.createEntityManager();
        em.getTransaction().begin();

        AuditedEntity entity = em.find(AuditedEntity.class, id);
        if (entity == null) {
            em.getTransaction().rollback();
            em.close();
            throw new RuntimeException("Entity not found");
        }

        // Perform update logic (here you can modify any fields if needed)
        entity.setName("Bar");
        em.merge(entity);

        em.getTransaction().commit();
        em.close();

        return entity;
    }

    public void close() {
        entityManagerFactory.close();
    }

    public static void main(String[] args) {
        // Initialize the service
        AuditedEntityService service = new AuditedEntityService();

        // Create operation
        AuditedEntity createdEntity = service.createEntity();
        System.out.println("Created entity with ID: " + createdEntity.getId());

        // Find operation
        Optional<AuditedEntity> foundEntity = service.findEntityById(createdEntity.getId());
        foundEntity.ifPresent(entity -> System.out.println("Found entity, createdAt: " + entity.getCreatedAt()));

        // Update operation
        AuditedEntity updatedEntity = service.updateEntity(createdEntity.getId());
        System.out.println("Updated entity, updatedAt: " + updatedEntity.getUpdatedAt());

        // Close the service
        service.close();
    }
}

Explanation of the Code

  1. EntityManagerFactory:
    • We use an EntityManagerFactory to create instances of EntityManager.
    • EntityManagerFactory is configured based on . persistence.xml
  2. Create Operation:
    • A new EntityManager is instantiated.
    • A transaction is begun using em.getTransaction().begin().
    • The entity is persisted using em.persist().
    • The transaction is committed with em.getTransaction().commit().
  3. Find Operation:
    • The EntityManager is used to find an entity by its ID using the em.find() method.
  4. Update Operation:
    • The entity is first retrieved using the em.find() method.
    • Changes can be made to the entity, and em.merge() is called to persist updates.
    • The updated timestamps are handled automatically by Hibernate.
  5. Manual Dependency Management:
    • Unlike Spring, we don’t have dependency injection here, so the EntityManagerFactory is manually created in the service constructor.
    • main() is used to demonstrate how to use the service.
  6. Closing Resources:
    • In a real application, you’d likely use a try-with-resources or other dedicated resource management techniques to ensure the EntityManager and EntityManagerFactory are properly closed.

Points to Note

  1. @CreationTimestamp and @UpdateTimestamp rely on Hibernate’s automatic timestamp management.
  2. These annotations will not work if you bypass Hibernate and manually interact with the database, as the timestamps are set at the ORM layer.
  3. Use Lombok’s annotations like @Getter, @Setter, or @Data to simplify getter and setter generation.

This approach allows you to automatically manage your audit fields without having to write extra logic for managing timestamps.