Hibernate Interview Questions

Hibernate is a powerful Object-Relational Mapping (ORM) framework that simplifies database interaction in Java applications. It provides an abstraction over JDBC by mapping Java objects to relational database tables, eliminating the need for most SQL code. Hibernate is used by companies like Uber, Airbnb, Google, Netflix, and Amazon.

• Explains Hibernate annotations and entity lifecycle states.
• Covers transactions, inheritance mapping, lazy loading, and dirty checking.
• Includes commonly asked interview questions with concise and structured answers.

Hibernate Interview Questions For Beginners

1. What is Hibernate?

Hibernate is an open-source ORM framework for mapping Java objects to relational database tables. It automates CRUD (Create, Read, Update, Delete) operations, reducing the need for manual SQL queries. Hibernate manages object persistence and database communication efficiently.

• Manages object persistence
• Integrates seamlessly with JPA
• Makes applications database-independent

2. What are the advantages of using Hibernate

• Simplifies database operations using ORM.
• Supports HQL (Hibernate Query Language), similar to SQL but object-oriented.
• Provides caching and lazy loading for improved performance.
• Ensures database independence and portability.
• Handles transactions automatically.

3. What is ORM in Hibernate?

ORM (Object-Relational Mapping) is a technique that maps Java objects to database tables. It automates data persistence and retrieval, minimizing manual SQL handling and enabling developers to work directly with objects instead of tables.

• Maps classes to database tables
• Maps objects to table rows
• Maps object fields to table columns
• Automatically handles persistence

4. What are the advantages of Hibernate over JDBC.

Hibernate provides a higher level of abstraction than JDBC by automating object mapping, query generation, caching, and transaction management. This significantly reduces development effort while improving code maintainability.

5. What are the Important Interfaces in Hibernate.

Hibernate provides several core interfaces that help manage database operations, object persistence, transactions, and query execution.

• SessionFactory: Creates and manages Session instances.
• Session: Primary interface between the application and database, maintains the first-level cache.
• Transaction: Represents a unit of work, handles commit and rollback.
• Query: Used for creating and executing HQL or native SQL queries.
• SessionFactoryBuilder: Builds a SessionFactory based on configuration settings.

6. List some of the databases supported by Hibernate.

Hibernate supports most popular relational databases through SQL Dialects, allowing applications to work with different databases without major code changes.

Some Supported Databases

• MySQL
• Oracle
• PostgreSQL
• Microsoft SQL Server
• MariaDB
• H2 Database

7. What is Java Persistence API (JPA)?

JPA (Java Persistence API) is the standard Java specification for Object-Relational Mapping (ORM). It defines a common set of interfaces and annotations for persistence, while frameworks like Hibernate provide the actual implementation.

• Supports JPQL queries
• Provides EntityManager API
• Vendor-independent API

Advantages of JPA

• Standardized persistence framework
• Easy migration between JPA providers
• Reduces vendor dependency

8. Explain Inheritance Mapping in Hibernate

Inheritance Mapping defines how Java class hierarchies are stored in relational database tables. Hibernate supports multiple inheritance strategies based on application requirements.

Types

• Single Table: Entire hierarchy stored in one table.
• Joined Table: Parent and child classes stored in separate tables.
• Table Per Class: Separate table for each concrete class.

Advantages

• Supports object-oriented inheritance
• Flexible mapping strategies
• Optimizes storage based on use case
• Simplifies object persistence

9. What is HQL?

HQL (Hibernate Query Language) is Hibernate's object-oriented query language used to retrieve and manipulate persistent objects. Unlike SQL, HQL works with entity classes and their properties instead of database tables and columns.

• Uses entity names instead of table names
• Supports joins and aggregation
• Supports parameterized queries

10. How to Create HQL Queries

• First, create an HQL Query String including entity name, property name, and relationships in the query.
• Create a query Object by using org.hibernate.query.Query interface for creating and executing queries.
• Also, query can be created by using createQuery()
• Set Parameters using setParameter() is optional.
• Execute the Query using methods like list() to retrieve the data or listing of results.
• uniqueResult() for retrieving a single result.

Session session = sessionFactory.openSession();
String hql = "FROM Employee WHERE department.name = :deptName";
Query<Employee> query = session.createQuery(hql, Employee.class);
query.setParameter("deptName", "Engineering");
List<Employee> employees = query.list();
session.close();

11. How Can We Add Criteria to a Query?

Hibernate provides the Criteria API to build dynamic queries using an object-oriented approach.

Criteria criteria = session.createCriteria(Product.class);
criteria.add(Restrictions.eq("category", "Programming"));
criteria.add(Restrictions.between("price", 100.0, 500.0));
List<Product> products = criteria.list();

12. What is a Session in Hibernate?

Session represents the single unit of work that acts as a gateway for interacting with the databases, Hibernate session is the primary interface for working with databases. Session provides various important functions such as

• Transaction Management
• Caching
• Lazy Loading
• Data Retrieval Strategies
• Object Persistence and Retrieval

It also handles Data Relationship Handling where developers can manage and define relationships between objects, specifying fetching strategies, and overflow of behaviors.

13. What is SessionFactory?

SessionFactory creates and manages Session instances. It is thread-safe and shared across threads. It loads configuration, manages connection settings, and handles caching metadata.

• Creates Session objects
• Loads Hibernate configuration
• Maintains metadata
• Supports second-level cache

public class HibernateUtil {
    private static final SessionFactory sessionFactory =
        new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
}

14. Is Session Thread-Safe?

No, a Session is not thread-safe, but SessionFactory is. Each thread should use its own Session instance to avoid data inconsistency.

15. Difference Between save() and persist()

16. Difference Between get() and load()

Hibernate Interview Questions For Intermediate

17. Difference between update and merge.

18. Difference Between First-Level and Second-Level Cache

19. Difference Between getCurrentSession() and openSession()

20. Difference Between save() and saveOrUpdate()

save() and saveOrUpdate() are Hibernate persistence methods used to store entities in the database, but they differ in how they handle an entity's state.

21. States of the object in Hibernate

An entity passes through different lifecycle states while interacting with Hibernate. These states determine whether the object is managed by Hibernate and synchronized with the database.

• Transient: Not associated with any Session or database.
• Persistent: Associated with an open Session and database; changes are tracked.
• Detached: Was persistent but Session is closed.
• Removed: Deleted from the database and no longer managed.

22. How to Create an Immutable Class in Hibernate.

An immutable entity is a read-only entity whose state cannot be modified after it is created. Hibernate provides the @Immutable annotation to indicate that an entity should not be updated once persisted.

• Object state cannot be modified.
• Hibernate skips update operations.
• Improves performance for read-only data.
• Suitable for reference or lookup tables.

@Immutable
public final class ImmutableEmployee {
    private final String name;
    private final int age;

    private ImmutableEmployee(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static ImmutableEmployee create(String name, int age) {
        return new ImmutableEmployee(name, age);
    }

    public String getName() { return name; }
    public int getAge() { return age; }
}

Immutable classes are thread-safe and represent read-only entities.

23. What is automatic dirty checking in Hibernate?

Automatic Dirty Checking is a Hibernate feature that automatically detects changes made to persistent objects during a session. When the transaction is committed, Hibernate compares the object's current state with its original state and generates the required SQL UPDATE statement automatically.

• No need to call update() explicitly.
• Works only for persistent entities.
• Changes are synchronized during transaction commit.

Employee emp = session.get(Employee.class, 1L);
emp.setAge(31);
session.getTransaction().commit(); // Hibernate updates automatically

24. Is Hibernate prone to SQL injection attacks?

No, Hibernate is safe from SQL injection when using parameter binding in HQL or Criteria queries.Hibernate helps protect applications from SQL injection by supporting parameterized queries in HQL, JPQL, and Criteria API. Parameters are treated as data instead of executable SQL statements.

• Use named parameters (:parameter).
• Avoid string concatenation in queries.
• Criteria API also prevents SQL injection.

Query query = session.createQuery(
    "FROM User WHERE username = :username AND password = :password");
query.setParameter("username", username);
query.setParameter("password", password);

25. What are the most commonly used annotations available to support hibernate mapping?

Hibernate provides several annotations to map Java classes with database tables. These annotations define how Java entities correspond to database structures.

I. @Entity: Marks a class as a persistent entity representing a table in the database.

@Entity
@Table(name = "employees")
public class Employee {
}

II. @Table: Specifies table details associated with the entity.

@Table(name = "employees")

III. @Id: Defines the primary key of the entity.

@Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id;

IV. @GeneratedValue: Specifies the generation strategy for primary keys.

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

V. @Column: Maps a class field to a specific table column.

@Column(name = "employee_name") private String name;

VI. @OneToMany and @ManyToOne: Defines one-to-many or many-to-one relationships between entities.

@ManyToOne @JoinColumn(name = "department_id") private Department department;

VII. @ManyToMany: Defines a many-to-many relationship between entities using a join table.

@ManyToMany
@JoinTable(name = "student_courses", joinColumns = @JoinColumn(name = "student_id"), inverseJoinColumns = @JoinColumn(name = "course_id"))

private List<Course> courses;

26. Explain Hibernate architecture.

Hibernate architecture is layered to separate application logic from database operations. Each component plays a specific role in ORM, transaction handling, and database communication.

Main Components of Hibernate Architecture:

I. Application Layer: Topmost layer where application code resides. It interacts with Hibernate APIs for CRUD operations and transactions.

II. Hibernate API
Provides core interfaces such as:

• SessionFactory: Creates Session instances.
• Session: Represents a single interaction with the database.
• Transaction: Manages commit and rollback operations.

III. Configuration: Responsible for setting up database connection properties, dialects, and mapping files.

Configuration config = new Configuration();
config.configure("hibernate.cfg.xml");
SessionFactory factory = config.buildSessionFactory();

IV. SessionFactory: A heavyweight, thread-safe object created once per application. Used to open sessions.

SessionFactory sessionFactory = new Configuration()
        .configure("hibernate.cfg.xml")
        .buildSessionFactory();

V. Session: Represents a single unit of work with the database. Handles object lifecycle and CRUD operations.

Session session = sessionFactory.openSession();
Employee emp = session.get(Employee.class, 1L);
session.close();

VI. Transaction: Manages atomic operations with commit() and rollback().

Transaction tx = session.beginTransaction();
tx.commit();

VII. Mapping Metadata: Defines mapping between Java objects and database tables using annotations or XML.

VIII. ORM Layer: Handles the conversion between Java objects and database records.

27. What is the Criteria API in Hibernate?

The Criteria API provides a type-safe and object-oriented way to build queries dynamically in Java, without using SQL or HQL directly. It allows for runtime query creation with filtering, projections, and sorting.

Example: Fetch employees aged 30 with salary greater than 50,000

Using HQL:

String hql = "FROM Employee WHERE age = :age AND salary > :salary";
Query query = session.createQuery(hql);
query.setParameter("age", 30);
query.setParameter("salary", 50000);
List<Employee> employees = query.list();

Using Criteria API:

CriteriaBuilder cb = session.getCriteriaBuilder();
CriteriaQuery<Employee> cq = cb.createQuery(Employee.class);
Root<Employee> root = cq.from(Employee.class);
Predicate age = cb.equal(root.get("age"), 30);
Predicate salary = cb.greaterThan(root.get("salary"), 50000);
cq.where(cb.and(age, salary));
List<Employee> employees = session.createQuery(cq).getResultList();

Key Components:

• CriteriaBuilder: Entry point for query construction.
• CriteriaQuery: Defines query structure.
• Root: Represents entity in the query.
• Predicate: Represents filtering conditions.

28. What does session.lock() method in Hibernate do?

session.lock() is used to apply pessimistic locking on an entity. It prevents other transactions from modifying the same data until the current lock is released.

Purpose:

• Maintains data consistency in concurrent transactions.
• Prevents conflicting updates on shared records.

Locking Types in Hibernate:

• Optimistic Locking: Uses versioning to detect conflicts.
• Pessimistic Locking: Physically locks rows in the database until a transaction completes.

session.lock() explicitly requests a pessimistic lock on an object to prevent concurrent modifications.

29. What is Hibernate caching?

Caching improves performance by storing frequently accessed data in memory to minimize database calls.

Types of Hibernate Caching:

I. First-Level(Session) Cache:

• It is enabled by default and cache mapped with Hibernate Session.
• It stores objects of the current session which are recovered.
• It also provides data consistency at transaction level.

II. Second-Level(Session Factory) Cache:

• In the same Sessionfactory, the cache is distributed among all the sessions created.
• It caches data used in different sessions.
• It also provides data consistency at application level.

Hibernate Interview Questions For Experienced

30. When is merge() method of the hibernate session useful?

merge() is used to update a detached entity (an object not currently associated with any session) back into persistence context.

Entity States in Hibernate:

• Transient: Newly created, not persisted.
• Persistent: Managed by a Hibernate session.
• Detached: Was persistent but session is closed.

Example:

Employee detachedEmp = new Employee();
detachedEmp.setId(1L);
detachedEmp.setName("Jane Smith");

Session session = sessionFactory.openSession();
session.beginTransaction();
Employee updated = (Employee) session.merge(detachedEmp);
session.getTransaction().commit();
session.close();

merge() ensures detached entities are synchronized with the database.

31. Does Hibernate support Native SQL Queries?

Yes. Hibernate allows execution of native SQL queries using the createSQLQuery() method for database-specific operations.

Example:

Session session = sessionFactory.openSession();
session.beginTransaction();
String sql = "SELECT name, salary FROM employees";
SQLQuery query = session.createSQLQuery(sql);
List<Object[]> results = query.list();
session.getTransaction().commit();
session.close();

Native queries are useful for optimized queries or database-specific features not supported by HQL.

32. What happens when the no-args constructor is absent in the Entity bean?

Hibernate uses reflection to instantiate entities. Without a no-argument constructor, Hibernate cannot create entity objects during data retrieval, leading to runtime errors.

Incorrect Example:

@Entity
public class Employee {
    @Id
    private Long id;
    public Employee(String name) { this.name = name; }
}

Correct Example:

@Entity
public class Employee {
    @Id
    private Long id;
    public Employee() {}
    public Employee(String name) { this.name = name; }
}

Always include a no-args constructor in entity classes.

33. Can we declare the Entity class final?

Yes, but it is not recommended. Declaring an entity as final prevents Hibernate from creating proxies, which affects lazy loading and runtime enhancements.

@Entity
public final class Employee {
    @Id
    private Long id;
}

Use final only if proxying or lazy loading is not required.

34. Explain Query Cache?

The Query Cache stores query results in memory. When the same query executes again with identical parameters, results are fetched from cache rather than querying the database.

Steps to Enable Query Cache:

• Enable second-level cache in configuration.
• Mark query as cacheable:

Query query = session.createQuery("FROM Employee");
query.setCacheable(true);

This improves performance for repeated queries with static parameters.

35. How to solve the N+1 SELECT problem in Hibernate?

The N+1 SELECT problem happens when Hibernate executes multiple queries for each associated entity instead of one optimized join query.

Solutions:

I. Batch Fetching: Fetches entities in batches to reduce the number of queries.

@Entity
@BatchSize(size = 10)
public class Department { }

II. Fetch Join: Loads related entities in a single query using JOIN FETCH.

String hql = "SELECT d FROM Department d JOIN FETCH d.employees WHERE d.id = :id";
Department dept = session.createQuery(hql, Department.class)
                         .setParameter("id", 1L)
                         .uniqueResult();

Both techniques minimize database round-trips.

36. What is a Single Table Strategy?

A Single Table Strategy is an inheritance mapping approach where an entire class hierarchy is mapped to a single table. A discriminator column differentiates subclass types.

@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "vehicle_type")
public abstract class Vehicle { }

@Entity
@DiscriminatorValue("car")
public class Car extends Vehicle {
    private int numberOfDoors;
}

@Entity
@DiscriminatorValue("motorcycle")
public class Motorcycle extends Vehicle {
    private boolean hasSideCar;
}

37. What are the benefits of NamedQuery?

Named Queries are pre-defined static queries defined in annotations or XML.

Advantages:

• Reusability: Query defined once, reused across multiple classes.
• Performance: Compiled and cached at startup.
• Maintainability: Centralized query definitions.
• Clarity: Separation between application logic and query logic.

38. What is the purpose of the @DynamicUpdate annotation in Hibernate?

@DynamicUpdate optimizes entity update operations by generating SQL statements that include only the modified columns instead of updating all fields.

Example:

@Entity
@DynamicUpdate
public class Employee {
    @Id
    private Long id;
    private String name;
    private String department;
}

Benefits:

• Reduces database traffic
• Improves performance
• Minimizes network overhead