Hibernate Tutorial

Hibernate is an open-source Java persistence framework project. It performs powerful object-relational mapping and query databases using HQL and SQL. Hibernate is a great tool for ORM mappings in Java. It can cut down a lot of complexity and thus defects as well from your application, which may otherwise find a way to exist. This is especially boon for developers with limited knowledge of SQL.

Initially started as an ORM framework, Hibernate has spun off into many projects, such as Hibernate Search, Hibernate Validator, Hibernate OGM (for NoSQL databases), and so on.

1. Hibernate Architecture

The following diagram summarizes the main building blocks in hibernate architecture.

Hibernate Architecture
Hibernate Architecture

Let’s understand what each block represents.

  1. Configuration: Generally written in hibernate.properties or hibernate.cfg.xml files. For Java configuration, you may find the class annotated with @Configuration. It is used by SessionFactory to work with Java applications and the Database. It represents an entire set of mappings of an application Java Types to an SQL database.
  2. SessionFactory: Any user application requests Session Factory for a session object. SessionFactory uses configuration information from above listed files, to instantiate the session object appropriately.
  3. Session: This represents the interaction between the application and the database at any point in time. This is represented by the org.hibernate.Session class. The instance of a session can be retrieved from the SessionFactory bean.
  4. Query: It allows applications to query the database for one or more stored objects. Hibernate provides different techniques to query databases, including NamedQuery and Criteria API.
  5. First-level cache: It represents the default cache used by Hibernate Session object while interacting with the database. It is also called a session cache and caches objects within the current session. All requests from the Session object to the database must pass through the first-level cache or session cache. One must note that the first-level cache is available with the session object until the Session object is live.
  6. Transaction: enables you to achieve data consistency, and rollback in case something goes unexpected.
  7. Persistent objects: These are plain old Java objects (POJOs), which get persisted as one of the rows in the related table in the database by hibernate. They can be configured in configurations files (hibernate.cfg.xml or hibernate.properties) or annotated with @Entity annotation.
  8. Second-level cache: It is used to store objects across sessions. This needs to be explicitly enabled and one would be required to provide the cache provider for a second-level cache. One of the common second-level cache providers is EhCache.

2. Salient features of the Hibernate framework

Object/Relational Mapping

Hibernate, as an ORM framework, allows the mapping of the Java domain object with database tables and vice versa. As a result, business logic is able to access and manipulate database entities via Java objects. It helps to speed up the overall development process by taking care of aspects such as transaction management, automatic primary key generation, managing database connections and related implementations, and so on.

JPA provider

Hibernate does support the Java Persistence API (JPA) specification. JPA is a set of specifications for accessing, persisting and managing data between Java objects and relational database entities.

Idiomatic persistence

Any class that follows object-oriented principles such as inheritance, polymorphism, and so on, can be used as a persistent class.

High performance and scalability

Hibernate supports techniques such as different fetching strategies, lazy initialization, optimistic locking, and so on, to achieve high performance, and it scales well in any environment.

Easy to maintain

Hibernate is easier to maintain as it requires no special database tables or fields. It generates SQL at system initialization time. It is much quicker and easier to maintain compared to JDBC.

In this page, I have categorized all available hibernate examples in this blog. This page will be updated every time, a new hibernate tutorial is published on this blog. Stay Tuned !!

Feel free to suggest topics you want to read more on.

3. Hibernate Basics

Hibernate Hello World Example

In this hibernate example with annotations, we will learn more about hibernate and step by step build our first running example application for beginners.

How to build SessionFactory in Hibernate

If you have been watching previous hibernate releases then you must have noticed that they have deprecated a lot of classes in quick succession. Deprecated classes are AnnotationConfiguration, ServiceRegistryBuilder and so on.

In this hibernate tutorial, I am giving an example of building hibernate SessionFactory without using the deprecated classes mentioned above. I am using the latest hibernate version i.e. Hibernate 6.0.0.Final, so you can make sure that you are using the latest approach for building a session factory.

Entities Equality and Identity Concepts

Many times in our application, we face a situation where we have to compare two objects to check their equality for satisfying some business rules. In core java, we have already much knowledge about checking the equality of objects, but in hibernate, we need to take care of a few extra things as well. Let’s learn what are those extra concepts.

Defining Association Mappings between Hibernate Entities

When we annotate the java classes with JPA annotations and make them persistent entities, we can face situations where two entities can be related and must be referenced from each other, in either uni-direction or in bi-direction. Let’s understand a few basic things before actually creating references between hibernate entities.

Entity / Persistence LifeCycle States Concepts

Given an instance of an object that is mapped to Hibernate, it can be in any one of four different states: transient, persistent, detached, or removed. We are going to learn about them today in this hibernate tutorial.

Using In-memory Database With Hibernate

In this example, I am using HSQLDB Database for creating and accessing in-memory database through our hibernate code.

Hibernate JPA Cascade Types

To enable cascade and inverse effect, we used “CascadeType” attribute in entities. In this tutorial, we will learn about various type of available options for cascading via CascadeType.

Pros and Cons of Hibernate Annotations Vs Mappings

As you may know that prior to the inline annotations, the only way to create hibernate mappings was through XML files. Although various tools from Hibernate and third-party projects allowed part or all of these mappings to be generated from Java source code automatically. Today annotations are the newest way to define mappings but it is not automatically the best way to do so. Let’s discuss the drawbacks and benefits of hibernate (or I should say JPA) annotations before discussing when to apply them.

Hibernate Query Language [HQL]

HQL is an object-oriented query language, similar to SQL, but instead of operating on tables and columns, HQL works with persistent objects and their properties. It is a superset of the JPQL, the Java Persistence Query Language; a JPQL query is a valid HQL query, but not all HQL queries are valid JPQL queries. HQL is a language with its own syntax and grammar.

Let’s learn HQL using the following examples:

  1. Basic HQL Syntax
    • Update Operation
    • Delete Operation
    • Insert Operation
    • Select Operation
  2. The from Clause and Aliases
  3. The select Clause and Projection
  4. Using Named Parameters
  5. Paging Through the Result Set
  6. Obtaining a Unique Result
  7. Sorting Results with the order by Clause
  8. Associations
  9. Aggregate Methods
  10. Named Queries
  11. Using Native SQL
  12. Enable Logging and Commenting

Hibernate Criteria Queries

The Criteria Query API lets you build nested, structured query expressions in Java, providing a compile-time syntax checking that is not possible with a query language like HQL or SQL. The Criteria API also includes query by example (QBE) functionality. This lets you supply example objects that contain the properties you would like to retrieve instead of having to step-by-step spell out the components of the query. It also includes projection and aggregation methods, including count(). Let’s explore it’s different features in detail.

  1. Basic Usage Example
  2. Using Restrictions with Criteria
  3. Paging Through the Result Set
  4. Obtaining a Unique Result
  5. Obtaining Distinct Results
  6. Sorting the Query’s Results
  7. Performing Associations (Joins)
  8. Adding Projections
  9. Query By Example (QBE)
  10. Summary

Lazy Loading in Hibernate

In this tutorial, I will be discussing a must-known feature in hibernate known as lazy loading. This is useful especially if you working on a very large application.

4. CRUD Operations

Hibernate Insert Query Tutorial

In this tutorial, I am giving an example of inserting data into a single table.

Hibernate @NamedQuery Tutorial

Named queries in hibernate is a technique to group the HQL statements in a single location, and later refer to them by some name whenever need to use them. It helps largely in code cleanup because these HQL statements are no longer scattered in the whole code.

Loading entity from database example

Examples of loading a hibernate entity using either load or get method.

Save() and saveOrUpdate() for Saving Entities

Please note that creating an instance of a class, you mapped with a hibernate annotations, does not automatically persist the object to the database. It must be saved explicitly after attaching it to a valid hibernate session. Let’s learn how to do it.

Merging and Refreshing Entities

In this tutorial, I am discussing a few thoughts about refresh() and merge() method present in hibernate session class.

Insert/select BLOB from Database

An example of inserting BLOB data into the database using hibernate and getting this data from the database, using hibernate entities.

5. Entity Mappings

Defining Hibernate Association Mappings

Before beginning the mapping between the hibernate entities, let’s understand a few basic things.

Hibernate one to one mapping using annotations

Let’s discuss variations of one-to-one mappings supported in hibernate:

  1. Using foreign key association
  2. Using a common join table
  3. Using shared primary key

Hibernate one to many mapping using annotations

Discuss variations of one-to-many mappings supported in hibernate:

  1. Using foreign key association
  2. Using a join table

Hibernate many to many mapping using annotations

Discuss variations of many-to-many mappings supported in hibernate.

6. Connection Pooling and Caching

C3P0 Connection Pool Configuration Tutorial

By default, Hibernate uses JDBC connections in order to interact with a database. Creating these connections is expensive—probably the most expensive single operation Hibernate will execute in a typical-use case. Since JDBC connection management is so expensive that possibly you will advise using a pool of connections, which can open connections ahead of time (and close them only when needed, as opposed to “when they’re no longer used”).

C3P0 is an example of an external connection pool. In this tutorial, we will learn to use it with hibernate.

Hibernate EhCache configuration

Caching is a facility provided by ORM frameworks that help users to get fast-running web applications while helping the framework itself reduce the number of queries made to the database in a single transaction. Hibernate also provide this caching functionality at the first level and second level.

In this tutorial, I am giving an example using Ehcache configuration as a second-level cache in hibernate.

Hibernate OSCache Configuration Example

Learn with example to configure OSCache with hibernate.

Hibernate first-level cache with example

First level cache in hibernate is enabled by default and you do not need to do anything to get this functionality working. Let’s learn more about it.

Hibernate second-level cache with example

In this tutorial, I am giving concepts around hibernate second-level cache and give examples using code snippets.

7. Best Practices

Hibernate @NaturalId usage and example

Hibernate 4 had brought lots of improvements and @NaturalId is one of such nice improvements. As you know @Id annotation is used as metadata for specifying the primary key of an entity. But sometimes, the entity is usually used in DAO layer code with an id which is not the primary key but its logical or natural id. In such cases, @NaturalId annotation will prove a good replacement for named queries in hibernate.

Get Entity Reference for Lazy Loading

Lazy loading is a design pattern commonly used in computer programming to defer the initialization of an object until the point at which it is needed. Hibernate lazy loading can be done by specifying “fetch= FetchType.LAZY” in hibernate mapping annotations.

8. Integration with Other Frameworks

Integrate Hibernate with Spring framework

This hibernate tutorial is focused on the usage of Hibernate with Spring 3 framework. I will show what how a basic end-to-end application flow looks like as a result of this integration.

9. Exceptions We May Face

Happy Learning !!

Was this post helpful?

Join 7000+ Awesome Developers

Get the latest updates from industry, awesome resources, blog updates and much more.

* We do not spam !!

HowToDoInJava

A blog about Java and related technologies, the best practices, algorithms, and interview questions.