Spring Data JPA and Hibernate Interview Questions

Spring Data JPA is an abstraction that creates repository implementations for the JPA standard. It reduces data-access boilerplate while allowing JPQL, specifications, and native queries when needed.

JPA is a standard API, Hibernate is a popular JPA implementation, and Spring Data JPA is a repository abstraction built on top of JPA. They solve different layers of the persistence problem.

CrudRepository provides basic CRUD operations. JpaRepository adds JPA-oriented methods such as flush and batch operations and also includes paging and sorting through its repository hierarchy.

Spring Data parses a repository method name such as findByEmailAndStatus and builds a query from its parts. This is convenient for simple queries; use @Query for complex logic.

@Query lets you declare JPQL or native SQL directly on a repository method. It is useful when a derived method name would be unclear or cannot express the required query.

JPQL uses entity and field names and is portable across databases. Native SQL uses database tables and columns, so it can use vendor features but is less portable.

save() registers the entity for persistence but the SQL may wait until flush or transaction commit. saveAndFlush() explicitly flushes the persistence context immediately after saving.

An entity can be transient, managed, detached, or removed. A managed entity is tracked by the persistence context, so changes can be written automatically during flush.

LAZY loads a relationship when it is accessed, while EAGER loads it immediately. LAZY is usually safer for performance because it avoids fetching data that the request does not need.

N+1 happens when one query loads parent rows and an additional query runs for each parent. Use fetch joins, EntityGraph, carefully designed DTO queries, or batch fetching, then verify the SQL.

N+1 happens when one query loads parent rows and an additional query runs for each parent. Use fetch joins, EntityGraph, carefully designed DTO queries, or batch fetching, then verify the SQL.

A fetch join loads a relationship in a JPQL query. EntityGraph declares the fetch plan separately from the query. Both can solve N+1, but the best choice depends on whether the fetch plan is query-specific or reusable.

A fetch join loads a relationship in a JPQL query. EntityGraph declares the fetch plan separately from the query. Both can solve N+1, but the best choice depends on whether the fetch plan is query-specific or reusable.

The first-level cache belongs to one persistence context or EntityManager. Within a transaction, repeated requests for the same entity can reuse the managed instance without another database query.

The second-level cache is shared by sessions through a configured cache provider. It can reduce database reads across transactions, but invalidation and stale-data rules must be understood.

Hibernate keeps a snapshot of managed entities. During flush it compares the current state with that snapshot and generates update SQL only when a tracked value changed.

Cascading propagates an entity operation such as persist, merge, or remove from a parent to related entities. Use only the cascade types that match the ownership and lifecycle rules.

orphanRemoval deletes a child that is removed from the parent relationship. CascadeType.REMOVE deletes children when the parent is deleted. They are related but are triggered by different actions.

orphanRemoval deletes a child that is removed from the parent relationship. CascadeType.REMOVE deletes children when the parent is deleted. They are related but are triggered by different actions.

Optimistic locking assumes conflicts are uncommon. A @Version column changes on each update; if another transaction changed the row first, the update affects zero rows and Hibernate reports an optimistic-lock exception.

Pessimistic locking asks the database to lock selected rows while a transaction works with them. It can prevent concurrent changes but may reduce throughput and cause blocking.

Optimistic locking assumes conflicts are uncommon. A @Version column changes on each update; if another transaction changed the row first, the update affects zero rows and Hibernate reports an optimistic-lock exception.

Accept a Pageable parameter and return Page<T> or Slice<T> from the repository. Add a stable sort, enforce reasonable page sizes, and remember that large offsets can become expensive.

Use JDBC batching settings, flush and clear in batches, avoid unnecessary entity loading, inspect generated SQL, and use database execution plans. Measure before and after the change.

Use JDBC batching settings, flush and clear in batches, avoid unnecessary entity loading, inspect generated SQL, and use database execution plans. Measure before and after the change.