Top Hibernate Interview Questions and Answers for Freshers & Experienced

Hibernate is an open-source ORM framework for Java. It maps Java classes to database tables and Java objects to table rows, so you don’t have to write long JDBC code and SQL for every operation. You work with objects, and Hibernate takes care of the database communication behind the scenes.  

Why do developers like it? 

• Less boilerplate code compared to JDBC
• Database independence (switch from MySQL to PostgreSQL with minimal changes)
• Built-in caching for better performance
• Automatic table creation and schema management
• Support for lazy loading and powerful querying 

With that in mind, let’s look at the questions.

If you’re just starting out, interviewers mostly check your basics: what Hibernate is, how it works, and how it differs from JDBC. These hibernate interview questions for freshers are the ones you’re most likely to face. 

1. What is ORM, and why do we need it?

ORM stands for Object-Relational Mapping. It’s a technique that connects object-oriented programming with relational databases. In Java, we think in classes and objects. Databases think in tables and rows. ORM bridges that gap so you don’t have to manually convert data between the two. 

2. What are the advantages of Hibernate over JDBC?

• JDBC needs a lot of repetitive code (opening connections, writing queries, handling result sets). Hibernate reduces this.
• Hibernate handles exceptions as unchecked exceptions, so you aren’t forced into endless try-catch blocks. 
• It supports HQL, which is database-independent.
• It offers built-in caching and lazy loading.
• It supports object relationships like one-to-many and many-to-many natively. 

3. What is the difference between Hibernate and JPA?

JPA (Java Persistence API) is a specification. It defines the rules for ORM in Java. Hibernate is an implementation of that specification. Other implementations exist, like EclipseLink, but Hibernate is the most popular. You can write code using JPA annotations and run it on Hibernate underneath. 

4. What are the core interfaces of Hibernate? 

The main ones are:

• SessionFactory: a heavy, thread-safe object created once per application. It holds configuration and creates sessions.
• Session: a lightweight, single-threaded object used for database operations.
• Transaction: represents a unit of work.
• Query / Criteria: used to fetch data from the database. 

5. What is the difference between get() and load()?

This is a classic one.

• get() hits the database immediately and returns null if the record doesn’t exist.
• load() returns a proxy object without hitting the database right away. It throws an ObjectNotFoundException if the record isn’t found when you actually access it.

Use get() when you’re not sure the record exists, and load() when you’re confident it does.

6. What is the difference between save(), persist(), and saveOrUpdate()? 

• save() inserts a record and returns the generated identifier immediately.
• persist() also inserts a record but returns nothing (void). It follows the JPA standard.
• saveOrUpdate() inserts a new record if it doesn’t exist, or updates it if it does.  

7. What is HQL?

HQL stands for Hibernate Query Language. It looks like SQL, but instead of table and column names, you use entity class names and property names. For example:

Example

HQL is object-oriented and database-independent, which is its biggest advantage.

8. What is the hibernate.cfg.xml file?

It’s the main configuration file where you define database connection details (driver, URL, username, password), the dialect, and mapping information. In modern projects, many of these settings are moved to application.properties when using Spring Boot.  

9. What is a Dialect in Hibernate?

A dialect tells Hibernate which database you’re using, so it can generate SQL that suits that specific database. For example, MySQL8Dialect or PostgreSQLDialect. This is how Hibernate stays database-independent. 

10. What are the states of an object in Hibernate?

An entity can be in one of these states:

• Transient: a new object not associated with any session or database row.
• Persistent: associated with an active session and mapped to a database row.
• Detached: was persistent earlier, but the session has been closed.
• Removed: scheduled for deletion.   

Understanding this lifecycle is very important, because many follow-up questions are built on it.

11. What are annotations in Hibernate? Name a few.

Annotations replace XML mapping. Common ones include: 

• @Entity: marks a class as a database entity
• @Table: specifies the table name
• @Id: marks the primary key
• @GeneratedValue: defines how the ID is generated
• @Column: maps a field to a column
• @OneToMany, @ManyToOne, @ManyToMany: define relationships 

12. What is the difference between Session and SessionFactory?

SessionFactory is created once, is thread-safe, and is expensive to build. Session is created for each unit of work, is not thread-safe, and is cheap to create. Think of SessionFactory as a factory and Session as a single conversation with the database. 

13. What is lazy loading?

Lazy loading means Hibernate doesn’t fetch related data until you actually need it. For example, if an Employee has a list of Projects, Hibernate won’t load the projects until you call getProjects(). This saves memory and improves performance. 

14. What is the difference between openSession() and getCurrentSession()?

• openSession() always creates a new session, and you must close it manually.
• getCurrentSession() returns a session bound to the current context (like a thread), and it closes automatically when the transaction ends.  

15. What is a primary key generation strategy?

It defines how IDs are generated. Common strategies are AUTO, IDENTITY, SEQUENCE, and TABLE. For MySQL, IDENTITY is usually used. For Oracle and PostgreSQL, SEQUENCE is popular. 

Once you have a few years under your belt, interviewers expect you to go beyond definitions. They want to know how you handle performance, concurrency, and real-world design problems. Here are the Hibernate interview questions for experienced professionals that come up again and again.  

16. What is the N+1 select problem, and how do you fix it?

This is probably the most asked question for senior roles. It happens when Hibernate runs one query to fetch a list of parent entities, and then runs N additional queries to fetch the child entities of each parent. 

For example, fetching 100 departments and then loading employees for each one results in 101 queries.  

Solutions:

• Use JOIN FETCH in HQL: select d from Department d join fetch d.employees
• Use @EntityGraph in Spring Data JPA
• Apply @BatchSize to fetch children in batches
• Choose the right fetch strategy 

Always check the SQL logs, because this issue often goes unnoticed until the application slows down in production.

17. Explain the first-level and second-level cache.

First-level cache is enabled by default and is tied to the session. If you load the same entity twice in one session, Hibernate hits the database only once.

Second-level cache is optional, tied to the SessionFactory, and shared across sessions. It needs a provider like Ehcache or Infinispan. It’s useful for read-heavy data that rarely changes, like country lists or configuration tables.

A good interview answer also mentions that caching should be used carefully, since stale data can become a problem. 

18. What is the query cache?

The query cache stores the results of HQL queries, specifically the IDs of the returned entities. It works together with the second-level cache. It’s useful only when the same query is run repeatedly with the same parameters and the underlying data doesn’t change often. 

19. How does Hibernate handle optimistic and pessimistic locking?

Optimistic locking assumes conflicts are rare. You add a @Version field to your entity. When updating, Hibernate checks whether the version has changed. If yes, it throws an OptimisticLockException.

Pessimistic locking locks the database row as soon as it’s read, preventing others from modifying it. You use LockModeType.PESSIMISTIC_WRITE.

Use optimistic locking for most web applications, and pessimistic locking when conflicts are frequent and data integrity is critical.  

20. What is the difference between merge() and update()?

• update() reattaches a detached object to the session. It throws an exception if another instance with the same ID is already in the session.
• merge() copies the state of a detached object into a persistent instance and returns the managed object. It’s safer because it avoids the duplicate-session conflict. 

21. What is the LazyInitializationException, and how do you avoid it? 

It occurs when you try to access a lazily loaded property after the session has closed. Hibernate can no longer fetch the data.  

Ways to avoid it:

• Use JOIN FETCH to load the data upfront
• Use DTO projections instead of returning entities
• Keep the session open for the required scope (but avoid the “Open Session in View” anti-pattern when possible)
• Use @EntityGraph 

Many developers fix this by switching everything to EAGER, which is a bad idea because it creates performance problems. 

22. What is the difference between FetchType.LAZY and FetchType.EAGER?   

LAZY loads related data only when accessed. EAGER loads it immediately with the parent. As a best practice, keep associations LAZY by default and fetch what you need explicitly. Note that @ManyToOne and @OneToOne are EAGER by default, so many teams override this.

23. How do you implement batch processing in Hibernate?

When inserting or updating thousands of records, you shouldn’t let the session grow endlessly. The usual approach is:

• Set hibernate.jdbc.batch_size (for example, 50)
• Call session.flush() and session.clear() after every batch

Example

This prevents memory issues and improves speed significantly. Also remember that IDENTITY generation disables JDBC batching, so SEQUENCE is a better choice for bulk operations.

24. What is the difference between flush() and commit()?

flush() synchronizes the session’s changes with the database by executing the SQL, but the transaction is still open and can be rolled back. commit() flushes the changes and then permanently saves the transaction. 

25. What are the different inheritance mapping strategies?

Hibernate supports three:

• SINGLE_TABLE: all classes in one table with a discriminator column. Fast, but has many nullable columns.
• TABLE_PER_CLASS: each concrete class gets its own table. Polymorphic queries can be slow.
• JOINED: a table for each class, linked by foreign keys. Clean design, but requires joins.

The choice depends on whether you value performance or normalization more. 

26. How do you handle the mappedBy attribute in bidirectional relationships? 

In a bidirectional relationship, one side owns the relationship (the side with the foreign key), and the other side uses mappedBy to refer to it. Without it, Hibernate may create an unnecessary join table or duplicate updates. A common mistake is not keeping both sides in sync in code, so helper methods like addEmployee() that set both sides are recommended.  

27. How do you monitor and optimize Hibernate performance?

A strong answer covers several points:

• Enable show_sql and format_sql during development
• Use Hibernate statistics to track query counts and cache hits
• Use tools like p6spy or database profilers 
• Fix N+1 problems and add proper indexes
• Use projections and DTOs instead of full entities when only a few fields are needed
• Choose suitable fetch types and use second-level caching wisely  

28. What is the difference between Hibernate and Spring Data JPA?

Hibernate is the ORM implementation. Spring Data JPA is an abstraction layer on top of JPA that removes boilerplate by letting you define repository interfaces. It uses Hibernate under the hood by default. Spring Data JPA saves time, but understanding Hibernate is essential for debugging and tuning performance.   

Knowing the answers is only half the battle. Here’s how to present them well:

1. Explain with examples. Instead of reciting definitions, give a small real-world case, like the N+1 problem in an e-commerce app.
2. Practice by building. Create a small project with one-to-many and many-to-many relationships. Hands-on experience shows in your answers. 
3. Read the SQL. Turn on SQL logging and see what Hibernate actually generates. This helps you answer performance questions confidently.
4. Know the “why.” Don’t just say what lazy loading is. Explain when and why you’d use it.
5. Be honest. If you don’t know something, say so and explain how you’d find the answer. Interviewers value honesty over guessing.
6. Revise the basics even if you’re experienced. Many senior candidates stumble on simple questions like the difference between get() and load(). 

Hibernate may look big at first, but most interview questions revolve around a handful of core ideas: how sessions work, how entities move through their lifecycle, how fetching and caching affect performance, and how to avoid common traps like N+1 and  LazyInitializationException.  

If you’re a beginner, master the basics and build a small project. If you’re experienced, sharpen your performance and design knowledge. Either way, go through these hibernate interview questions a few times, try the code yourself, and explain the answers aloud. That practice will make you far more confident when the real interview begins.     

Good luck with your preparation!