Hibernate Interview Questions and Answers

Top Hibernate interview questions and answers covering architecture, entity lifecycle, caching, dirty checking, fetching, locking, performance tuning, transactions, and real-world scenarios.

Introduction

These questions cover:

Hibernate Basics

Architecture

Entity Lifecycle

Caching

Dirty Checking

Fetching

Transactions

Locking

Performance Tuning

Real Production Scenarios

Questions are grouped from:

Beginner
Intermediate
Advanced
Architect Level

Hibernate Basics

1. What is Hibernate?

Hibernate is an ORM (Object Relational Mapping) framework that maps Java objects to database tables.

Benefits:

Reduces JDBC Boilerplate

Automatic SQL Generation

Caching

Transaction Management

Database Independence

Example:

Employee employee = new Employee();

entityManager.persist(employee);

Instead of:

PreparedStatement ps =
        connection.prepareStatement(sql);

2. What is ORM?

ORM stands for:

Object Relational Mapping

It maps:

Java Class
      ↓
Database Table

Object
      ↓
Table Row

Field
      ↓
Column

3. Why Hibernate instead of JDBC?

JDBC

Connection
PreparedStatement
ResultSet
Manual Mapping

Hibernate

entityManager.persist(employee);

Benefits:

Less Code

Caching

Lazy Loading

Dirty Checking

Automatic Mapping

4. Difference between Hibernate and JPA?

JPA	Hibernate
Specification	Implementation
Interface/API	Framework
Vendor Neutral	Hibernate Specific
EntityManager	Session

Example:

EntityManager

JPA API.

Internally:

Session

Hibernate implementation.

Hibernate Architecture

5. Explain Hibernate Architecture

flowchart TD

A["Application"]

B["Session"]

C["Persistence Context"]

D["Hibernate"]

E["JDBC"]

F["Database"]

A --> B
B --> C
C --> D
D --> E
E --> F

Core Components:

SessionFactory

Session

Persistence Context

Transaction

Entity

Database

6. What is SessionFactory?

Heavyweight object.

Created once per application.

Responsible for:

Creating Sessions

Maintaining Metadata

Managing Second Level Cache

7. What is Session?

Session represents:

Single Unit Of Work

Responsible for:

CRUD Operations

First Level Cache

Dirty Checking

Equivalent in JPA:

EntityManager

Entity Lifecycle

8. Explain Entity States

Hibernate entities have four states:

Transient

Managed (Persistent)

Detached

Removed

9. Explain Transient State

Employee employee =
        new Employee();

Characteristics:

Not in Database

Not in Persistence Context

No Tracking

10. Explain Managed State

entityManager.persist(employee);

Characteristics:

Inside Persistence Context

Dirty Checking Active

Tracked By Hibernate

11. Explain Detached State

entityManager.detach(employee);

Characteristics:

Not Tracked

No Dirty Checking

Exists In Database

12. Explain Removed State

entityManager.remove(employee);

Characteristics:

Scheduled For Delete

EntityManager

13. What is EntityManager?

Primary JPA interface used for:

persist

merge

find

remove

flush

clear

detach

refresh

14. Difference between persist and merge?

persist	merge
New Entity	Detached Entity
Same Object Managed	Returns New Managed Object
Insert	Update
Void	Returns Entity

15. Difference between find and getReference?

find

entityManager.find(Employee.class, 1L);

Immediately hits database.

getReference

entityManager.getReference(Employee.class, 1L);

Returns proxy.

Loads lazily.

Dirty Checking

16. What is Dirty Checking?

Automatic detection of entity changes.

Example:

Employee employee =
        repository.findById(1L).get();

employee.setSalary(200000);

No save call.

Hibernate generates:

UPDATE employee
SET salary=200000
WHERE id=1;

17. How does Dirty Checking work?

Hibernate stores:

Entity Snapshot

During commit:

Current State
VS
Snapshot

Difference detected → UPDATE SQL.

18. When does Dirty Checking happen?

flush()

transaction commit

Caching

19. What is First Level Cache?

Session scoped cache.

Always enabled.

Session
      =
First Level Cache

20. What is Second Level Cache?

Application scoped cache.

Shared across sessions.

Examples:

Ehcache

Redis

Hazelcast

21. Difference between First and Second Level Cache?

First Level	Second Level
Session Scope	Application Scope
Default Enabled	Disabled
Not Shared	Shared
Mandatory	Optional

22. What data should be cached?

Good candidates:

Country

Currency

State

Configuration Data

Avoid:

Frequently Updated Data

Fetching

23. Difference between Lazy and Eager Loading?

Lazy

@ManyToOne(fetch = FetchType.LAZY)

Load when accessed.

Eager

@ManyToOne(fetch = FetchType.EAGER)

Load immediately.

24. Which should be preferred?

LAZY

Use EAGER carefully.

25. What is N+1 Query Problem?

Example:

employees.forEach(
    e -> e.getDepartment().getName()
);

Generated:

1 Query

+

N Queries

Total:

N+1

26. How do you solve N+1?

JOIN FETCH

@EntityGraph

DTO Projection

Example:

@Query("""
       select e
       from Employee e
       join fetch e.department
       """)

Transactions

27. What is Transaction?

Logical unit of work.

Properties:

ACID

28. What is ACID?

Atomicity

Consistency

Isolation

Durability

29. What is Propagation.REQUIRED?

Default propagation.

Join Existing Transaction

OR

Create New Transaction

30. Difference between REQUIRED and REQUIRES_NEW?

REQUIRED

Uses existing transaction.

REQUIRES_NEW

Creates completely new transaction.

Locking

31. What is Optimistic Locking?

Uses version column.

@Version
private Integer version;

Conflict detected during update.

32. What is Pessimistic Locking?

Locks row before update.

Example:

SELECT *
FROM account
FOR UPDATE;

33. When to use Optimistic Locking?

Best for:

Read Heavy Applications

Low Conflict Systems

34. When to use Pessimistic Locking?

Best for:

Seat Booking

Inventory

Bank Transactions

Performance Tuning

35. Biggest Hibernate Performance Issue?

N+1 Query Problem

36. How do you improve Hibernate Performance?

Fix N+1

Pagination

DTO Projection

Indexes

Caching

Batch Processing

37. Why use Pagination?

Bad:

findAll();

Good:

PageRequest.of(0, 50);

Avoids loading millions of rows.

38. Why use DTO Projection?

Fetch only required columns.

Example:

select new EmployeeDto(
    e.name,
    e.salary
)

Less memory.

Better performance.

39. What is Batch Processing?

Processing large datasets in chunks.

Example:

entityManager.flush();
entityManager.clear();

after every:

50 records

40. Why use flush and clear?

flush

Send SQL to Database

clear

Free Persistence Context Memory

Advanced Questions

41. Difference between save and saveAll?

save

save(entity)

Single entity.

saveAll

saveAll(entities)

Multiple entities.

42. Why is IDENTITY bad for batching?

Hibernate needs generated ID immediately.

Can disable batching.

Better:

GenerationType.SEQUENCE

43. What is Flush Mode?

Controls when Hibernate synchronizes changes.

AUTO

COMMIT

44. Difference between flush and commit?

flush

Executes SQL

commit

Permanently Saves Transaction

45. Can flush happen without commit?

Yes.

SQL executes.

Transaction can still rollback.

Architect Level Questions

46. How would you design an Employee Search API with 10 Million Records?

Answer:

Pagination

Indexes

DTO Projection

Read-Only Transaction

EntityGraph

Second Level Cache

Never:

findAll()

47. How would you process 50 Million Records?

Use:

Spring Batch

Chunk Processing

Pagination

JDBC Batch

Partitioning

48. How would you optimize a slow Hibernate API?

Checklist:

Check SQL Count

Check N+1

Check Indexes

Check Fetch Strategy

Check Pagination

Check Projection

Check Cache

49. What metrics do you monitor in Production?

SQL Count

Response Time

Connection Pool Usage

Cache Hit Ratio

Transaction Duration

Deadlocks

Slow Queries

Tools:

Datadog

Dynatrace

Grafana

Prometheus

Splunk

50. What is your Hibernate Optimization Strategy?

My production checklist:

1. LAZY Loading

2. DTO Projections

3. Fix N+1

4. Pagination

5. Proper Indexes

6. Batch Processing

7. Cache Read-Heavy Data

8. Monitor SQL

9. Use Read-Only Transactions

10. Keep Transactions Small

Rapid Fire Questions

Is First Level Cache enabled by default?

Yes

Is Second Level Cache enabled by default?

No

Which fetch type should be default?

LAZY

Biggest performance issue?

N+1 Queries

Annotation for optimistic locking?

@Version

Default transaction propagation?

Propagation.REQUIRED

Best repository interface?

JpaRepository

What creates Hibernate Session?

SessionFactory

Persistence Context equals?

First Level Cache

Can Detached Entity use Dirty Checking?

No

10 Most Asked Hibernate Interview Questions

What is Hibernate?
Difference between Hibernate and JPA?
Explain entity lifecycle.
What is Dirty Checking?
What is First Level Cache?
What is Second Level Cache?
Explain Lazy vs Eager Loading.
What is N+1 Query Problem?
Explain Optimistic vs Pessimistic Locking.
How do you tune JPA/Hibernate performance?

Summary

For 5+ years interviews focus on:

Entity Lifecycle

Dirty Checking

Caching

Lazy Loading

N+1 Queries

Transactions

Locking

Performance Tuning

For Lead/Architect interviews focus on:

Production Problems

Scaling

Batch Processing

Database Optimization

Monitoring

Performance Tuning Strategy

Master these 50 questions and you can confidently handle most Spring Boot, JPA, and Hibernate interviews from Mid-Level to Architect roles.