Interview Questions
JPA Hibernate

1. What is the difference between JPA and Hibernate?

This is a very common question in Java backend interviews, as many candidates use Hibernate without clearly knowing how to distinguish JPA from Hibernate.

JPA, short for Java Persistence API, is a specification. It defines a standard for managing the persistence of Java objects in a database.

Hibernate is an implementation of this specification. In practice, when using Spring Data JPA, we often use JPA as the API and Hibernate as the underlying implementation engine.

2. What is the purpose of the @Entity annotation?

@Entity indicates that a Java class is a persistent entity, meaning it can be mapped to a database table.

An entity usually has an identifier annotated with @Id. This identifier allows JPA to distinguish instances and track their state within the persistence context.

In an interview, you should explain that an entity is not just a standard class: it is managed by JPA when attached to the persistence context.

3. What is the EntityManager?

TheEntityManager is the primary JPA interface for interacting with the persistence context.

It allows you to persist, find, remove, and detach an entity, or execute queries.

In an interview, the key point to grasp is that the EntityManager does not just execute SQL queries. It also manages entity states within the persistence context.

4. What are the JPA entity states?

A JPA entity can go through several states during its lifecycle.

A transient entity is a standard Java object that is not yet known to the persistence context.

A managed entity is tracked by JPA. Any modification can be detected and synchronized with the database during flush.

A detached entity was previously managed by JPA, but is no longer attached to the current context. A removed entity is marked for deletion.

5. What is the difference between Lazy and Eager?

Lazy means that the related data is only loaded when it is actually accessed. Eager means that the related data is loaded immediately along with the main entity.

For example, an entity User can have a list of orders. With lazy loading, the orders are not necessarily loaded when the user is fetched.

In an interview, explain that lazy loading can improve performance, but it can also cause a LazyInitializationException if the relationship is accessed outside an active session or transaction.

6. What is the N+1 problem in Hibernate?

The N+1 problem is a classic Hibernate interview trap. It occurs when an initial query fetches a list of entities, and then an additional query is executed for each entity to load a relationship.

For example, a query fetches 100 users. Then Hibernate executes 100 additional queries to load their orders. You end up with 1 initial query + N additional queries.

This issue can significantly degrade performance. To fix it, you can use a JOIN FETCH, a @EntityGraph, a tailored query, or revise the fetching strategy.

7. What is the difference between persist() and merge()?

persist() is used to make a new entity persistent. It is used when an object does not yet exist in the database and must be added to the persistence context.

merge() is used to copy the state of a detached entity into an entity managed by the persistence context.

A common trap is believing that merge() directly reattaches the object passed as a parameter. In reality, merge() returns a managed instance, while the original object can remain detached.

8. What is dirty checking?

Dirty checking is a Hibernate mechanism that automatically detects changes made to a managed entity.

If an entity is attached to the persistence context and its fields are modified, Hibernate can detect these changes and generate an SQL query UPDATE at flush time.

This is an important concept in interviews, as it explains why you do not always need to explicitly call a save method on an already managed entity.

9. What is the difference between cascade and orphanRemoval?

cascade allows propagating certain operations from a parent entity to its related entities. For example, if you persist a parent, you can also automatically persist its children.

orphanRemoval is used to automatically delete a child entity when it is removed from the relationship with its parent.

In an interview, make sure not to confuse the two. Cascade propagates an operation, while orphanRemoval handles deleting a child that is no longer attached to its parent.

10. What is @Version used for in JPA?

@Version enables optimistic locking.

The goal is to prevent an update from silently overwriting changes made by another transaction. JPA checks the entity version when updating.

If two transactions modify the same entity concurrently, the version detects the conflict. An exception can then be thrown instead of overwriting data uncontrolled.

What are the most common JPA Hibernate interview questions?

The most frequent JPA Hibernate interview questions cover the difference between JPA and Hibernate, entities, EntityManager, relationships, Lazy vs Eager, the N+1 problem, transactions, dirty checking, first-level cache, and cascades.

Why is Hibernate frequently asked in Java backend interviews?

Hibernate is widely used in Java applications with Spring Boot. It manages data persistence, but it can also cause performance issues if relationships, transactions, and fetching strategies are not properly understood.

Do you need to know SQL to understand JPA Hibernate?

Yes. Even though JPA lets you work with Java objects, understanding SQL is still essential. In interviews, it is crucial to be able to explain which queries might be generated behind your Java code.

What is the most common trick question about Hibernate?

The N+1 problem is one of the most common pitfalls. It helps verify whether a candidate understands the impact of lazy loading, entity relationships, and queries automatically generated by Hibernate.