Hibernate Caching: First-Level and Second-Level

Repeatedly hitting the database for data that hasn't changed is wasted work. Hibernate has two built-in caching layers that reduce redundant SQL, each operating at a different scope.

First-Level Cache (Session Cache)

Always on, and scoped to a single Session. Within one Session, calling session.get(Student.class, 1) twice only issues one SQL query — the second call returns the same managed object straight from the Session's internal cache, without touching the database again. This cache is cleared automatically when the Session closes, so it never leaks data between unrelated units of work.

Second-Level Cache (SessionFactory Cache)

Optional, and scoped to the whole SessionFactory — shared across every Session in the application, so entities cached by one user's request can be reused by another's. It requires a caching provider (commonly Ehcache or Caffeine) and must be explicitly enabled per entity with @Cacheable. Because it's shared, entries need a clear invalidation strategy so stale data isn't served after an update — Hibernate handles this automatically for entities it manages, evicting or updating cached entries when they change through Hibernate itself.

Query Cache

A companion to the second-level cache that caches the results of specific queries (a list of ids matching a WHERE clause), not just individual entities. It only becomes useful once the second-level cache is enabled, since the query cache stores entity ids and relies on the second-level cache to supply the actual entity data for those ids.

Example

<!-- Maven dependencies: hibernate-jcache + ehcache -->

<!-- hibernate.cfg.xml -->
<property name="hibernate.cache.use_second_level_cache">true</property>
<property name="hibernate.cache.region.factory_class">org.hibernate.cache.jcache.JCacheRegionFactory</property>

import jakarta.persistence.*;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

@Entity
@Cacheable
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Student {
    @Id @GeneratedValue private long id;
    private String name;
}

// First session: hits the database, then populates the 2nd-level cache
Student s1 = session1.get(Student.class, 1);

// A completely different, later session: served from the 2nd-level cache, no SQL executed
Student s2 = session2.get(Student.class, 1);

Hibernate: select * from student where id=? (only on the first session's load)

Exercise

Using the lesson's Enabling the second-level cache for an entity (with Ehcache as the provider) example, create a small implementation or design sketch that demonstrates First-level cache is automatic, scoped to one Session, and cannot be disabled.. Add a test case or scenario that would catch Assuming the second-level cache is on by default — it requires an explicit provider dependency, configuration, and @Cacheable on each entity., and describe the expected result.

Quick quiz

Interview questions