// 15 Essential Hibernate Interview Questions

Hibernate or Hibernate ORM (Object-Relational Mapping) is a tool that provides a framework for the Java programming language. This framework allows you to map objects with a relational database enabling you to store, manipulate and retrieve data from a database.

Additionally, Hibernate allows reference implementation of the Java Persistence API making it the go-to choice for ORM tools.

A session is used to establish and maintain the connection between the application and the database. Sessions are designed to be lightweight and only instantiated whenever data is required from the database.

Session objects are not thread-safe and hence it is not a good practice to have them always opened. Additionally, Session can be used to retrieve, store or delete data from the database.

The key components that are used in Hibernate are:

1. Configuration
2. Sessions
3. SessionFactory
4. Criteria
5. Query
6. Transaction

The get() and load() methods are two commonly used methods to load data from your database. However, they have a few differences and they are listed below.

The get() method loads the object and the associate data as soon as it is called. Load() returns a proxy object and loads the data only when required. Since hibernate is default set to lazy load, the load() method is more suitable.

The load() method throws an exception when the query's data is not found, whereas get() returns a null.

Every unit of work between the relational database and the application is known as a transaction. Most relational databases support transaction functionality.

In hibernate, all transactions are handled by an underlying transaction manager. Transactions are optional objects and hibernate applications can choose not to use them.

An association where an object is associated with multiple objects is called a many-to-one association. A common example is that the same employee department object can be associated with multiple employees.

This is the most common type of association. However, there are other types of association as well.

This type of association is quite similar to the many-to-one association. In this type of association, only an object can be mapped only to one object. This essentially means that the mapping is unique to that particular object.

A common example for this is an employee’s address is only associated with a single employee object.

Lazy loading is a design pattern that only loads the child objects whenever needed. Since only the main objects are loaded this helps increase the performance of the application.

After Hibernate 3, lazy loading had been enabled by default.

Hibernate allows you to map objects with a relational database. To facilitate this it requires the necessary configuration and mapping information. All this information is needed in advance and it is given in the form of a standard Java properties file called configuration files or hibernate.cfg.xml.

This file must be placed in the root directory of your classpath.

Hibernate facilitates data manipulation through various methods; one such method is by using the Criteria API. Criteria APIs allow you to code a criteria query with filters that run based on a logical operation.

The Session interface provides a createCriteria() method that allows you to create criteria queries.

The code snippet below is a simple query using createCriteria()

Criteria cc = session.createCriteria(Freelancers.class);
List results = cc.list();

Cache is the buffer memory stored between the application and the database. Cache memory can store recently used data and display them whenever needed. Since Hibernate is linked to a relational database it is essential to reduce the number of database queries, hence caching is important in Hibernate.

Hibernate divides caching into two-level:

1. First level caching
2. Second-level caching

Entity beans can exist in three states, they are:

1. Transient
2. Persistent
3. Detached

The merge() method is used to update existing values. Although quite similar to the update() methods, the merge() method is specifically used when you want to save your modification without knowing the current state of the session.

Essentially, merge() creates a copy and returns it. This returned object goes into a persistent state and any changes made to it can be tracked.

When we use the collection API to sort and display a collection of data it is called a sorted list or sorted collection. This method works fine on smaller sets of data, however, while working with larger sets of data they often lead to reduced performance or Outofmemory errors.

The other method to query and sort data is to use the order by query of the criteria API. In this method, the sorting takes place at the database level and hence does not cause any performance issues.

HQL or Hibernate Query Language is an extension of SQL that is also used to perform queries on relational databases. However, HQL uses class names rather than table names making the language easier and independent of any database.

The most commonly used queries are:

1. public int executeUpdate()
2. public List list()
3. public Query setFirstResult(int rowNumber)
4. public Query setMaxResult(int rowsCount)
5. public Query setParameter(int position, Object value)
6. public Query setParameter(String name, Object value)