Hibernate Caching Example

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (178K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

This tutorial will guide you through setting up and demonstrating caching in Hibernate 6.4 with Java 21. We'll create a simple application that performs database operations and demonstrates the use of first-level and second-level caching to improve performance.

Introduction

Caching in Hibernate can significantly improve the performance of your application by reducing the number of database queries. Hibernate supports two levels of caching:

1. First-Level Cache: Also known as the session cache, it is associated with the Session object and is enabled by default.
2. Second-Level Cache: It is associated with the SessionFactory object and must be explicitly configured.

In this tutorial, we will:

1. Set up a Maven project with Hibernate and an H2 database dependency.
2. Configure Hibernate and enable second-level caching.
3. Create an entity class (User).
4. Implement methods to demonstrate first-level and second-level caching.
5. Demonstrate caching with a sample application.

Step 1: Set Up Your Project

1.1 Create a Maven Project

Open your IDE and create a new Maven project.

1.2 Add Dependencies

Update your pom.xml file to include the necessary dependencies for Hibernate, H2 (an in-memory database for simplicity), and EHCache (for second-level caching).

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.example</groupId> <artifactId>hibernate-caching-example</artifactId> <version>1.0-SNAPSHOT</version> <dependencies> <!-- Hibernate ORM --> <dependency> <groupId>org.hibernate.orm</groupId> <artifactId>hibernate-core</artifactId> <version>6.4.0.Final</version> </dependency> <!-- H2 Database --> <dependency> <groupId>com.h2database</groupId> <artifactId>h2</artifactId> <version>2.1.214</version> </dependency> <!-- EHCache --> <dependency> <groupId>org.ehcache</groupId> <artifactId>ehcache</artifactId> <version>3.9.6</version> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId>maven-compiler-plugin</artifactId> <version>3.10.1</version> <configuration> <source>21</source> <target>21</target> </configuration> </plugin> </plugins> </build> </project> 

1.3 Configure Hibernate and Enable Second-Level Caching

Create a file named hibernate.cfg.xml in the src/main/resources directory to configure Hibernate and enable second-level caching.

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property> <property name="hibernate.connection.driver_class">org.h2.Driver</property> <property name="hibernate.connection.url">jdbc:h2:mem:testdb;DB_CLOSE_DELAY=-1</property> <property name="hibernate.connection.username">sa</property> <property name="hibernate.connection.password"></property> <property name="hibernate.hbm2ddl.auto">update</property> <property name="hibernate.show_sql">true</property> <!-- Second-level cache configuration --> <property name="hibernate.cache.use_second_level_cache">true</property> <property name="hibernate.cache.region.factory_class">org.hibernate.cache.jcache.JCacheRegionFactory</property> <property name="hibernate.javax.cache.provider">org.ehcache.jsr107.EhcacheCachingProvider</property> <property name="hibernate.cache.use_query_cache">true</property> </session-factory> </hibernate-configuration> 

Create ehcache.xml Configuration File

Create a file named ehcache.xml in the src/main/resources directory to configure EHCache.

<config xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.ehcache.org/v3" xsi:schemaLocation="http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core.xsd"> <cache alias="default"> <heap unit="entries">1000</heap> <expiry> <ttl unit="minutes">10</ttl> </expiry> </cache> <cache alias="com.example.entity.User"> <heap unit="entries">100</heap> <expiry> <ttl unit="minutes">10</ttl> </expiry> </cache> </config> 

Step 2: Create the Entity Class

Create an entity class User that will be mapped to a table in the database. This class uses annotations to define the entity and its fields, including cache configuration.

package com.example.entity; import jakarta.persistence.Entity; import jakarta.persistence.GeneratedValue; import jakarta.persistence.GenerationType; import jakarta.persistence.Id; import org.hibernate.annotations.Cache; import org.hibernate.annotations.CacheConcurrencyStrategy; @Entity @Cache(usage = CacheConcurrencyStrategy.READ_WRITE) public class User { @Id @GeneratedValue(strategy = GenerationType.IDENTITY) private Long id; private String name; private String email; // Getters and setters public Long getId() { return id; } public void setId(Long id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getEmail() { return email; } public void setEmail(String email) { this.email = email; } } 

Explanation:

• The @Entity annotation specifies that the class is an entity and is mapped to a database table.
• The @Id annotation specifies the primary key of the entity.
• The @GeneratedValue(strategy = GenerationType.IDENTITY) annotation specifies that the primary key is auto-incremented.
• The @Cache annotation enables second-level caching for the User entity.

Step 3: Create the Hibernate Utility Class

Create a utility class HibernateUtil to manage the Hibernate SessionFactory. This class ensures a single instance of SessionFactory is created and provides a method to close it.

package com.example.util; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class HibernateUtil { private static final SessionFactory sessionFactory = buildSessionFactory(); private static SessionFactory buildSessionFactory() { try { // Create the SessionFactory from hibernate.cfg.xml return new Configuration().configure().buildSessionFactory(); } catch (Throwable ex) { // Make sure you log the exception, as it might be swallowed System.err.println("Initial SessionFactory creation failed." + ex); throw new ExceptionInInitializerError(ex); } } public static SessionFactory getSessionFactory() { return sessionFactory; } public static void shutdown() { // Close caches and connection pools getSessionFactory().close(); } } 

Explanation:

• The buildSessionFactory method creates the SessionFactory from the hibernate.cfg.xml configuration file.
• The getSessionFactory method returns the singleton instance of SessionFactory.
• The shutdown method closes the SessionFactory to release resources.

Step 4: Implement Caching

Create a class UserService to handle database operations with caching. This class includes methods to demonstrate first-level and second-level caching.

First-Level Cache Demonstration

package com.example.service; import com.example.entity.User; import com.example.util.HibernateUtil; import org.hibernate.Session; import org.hibernate.Transaction; public class UserService { public void demonstrateFirstLevelCache() { Session session = HibernateUtil.getSessionFactory().openSession(); Transaction transaction = null; try { transaction = session.beginTransaction(); // Load user for the first time User user1 = session.get(User.class, 1L); System.out.println("First query: " + user1.getName()); // Load user again within the same session User user2 = session.get(User.class, 1L); System.out.println("Second query: " + user2.getName()); transaction.commit(); } catch (Exception e) { if (transaction != null) { transaction.rollback(); } e.printStackTrace(); } finally { session.close(); } } // Methods for second-level cache demonstration can be added here. } 

Second-Level Cache Demonstration

package com.example.service; import com.example.entity.User; import com.example.util.HibernateUtil; import org.hibernate.Session; import org.hibernate.Transaction; public class UserService { // First-level cache demonstration method public void demonstrateSecondLevelCache() { Session session1 = HibernateUtil.getSessionFactory().openSession(); Transaction transaction1 = null; try { transaction1 = session1.beginTransaction(); // Load user for the first time User user1 = session1.get(User.class, 1L); System.out.println("First session, first query: " + user1.getName()); transaction1.commit(); } catch (Exception e) { if (transaction1 != null) { transaction1.rollback(); } e.printStackTrace(); } finally { session1.close(); } // Open a new session and load the same user Session session2 = HibernateUtil.getSessionFactory().openSession(); Transaction transaction2 = null; try { transaction2 = session2.beginTransaction(); // Load user again in a new session User user2 = session2.get(User.class, 1L); System.out.println("Second session, first query: " + user2.getName()); transaction2.commit(); } catch (Exception e) { if (transaction2 != null) { transaction2.rollback(); } e.printStackTrace(); } finally { session2.close(); } } } 

Explanation:

• The demonstrateFirstLevelCache method loads a user twice within the same session. The second query will not hit the database because the user is cached in the first-level cache.
• The demonstrateSecondLevelCache method loads a user in two different sessions. The second query will hit the second-level cache, avoiding a database hit.

Step 5: Demonstrate Caching

Create a MainApp class to demonstrate the caching functionality. This class calls the caching demonstration methods of UserService.

package com.example.main; import com.example.service.UserService; public class MainApp { public static void main(String[] args) { UserService userService = new UserService(); // Add a user to the database (for demonstration purposes) userService.createUser("Ramesh Fadatare", "ramesh.fadatare@example.com"); // Demonstrate first-level cache System.out.println("Demonstrating First-Level Cache:"); userService.demonstrateFirstLevelCache(); // Demonstrate second-level cache System.out.println("Demonstrating Second-Level Cache:"); userService.demonstrateSecondLevelCache(); } } 

Explanation:

1. Create a UserService Instance:

   UserService userService = new UserService(); 

   An instance of UserService is created to call its methods for performing database operations.

2. Add a User to the Database:

   userService.createUser("Ramesh Fadatare", "ramesh.fadatare@example.com"); 

   A user is added to the database for demonstration purposes.

3. Demonstrate First-Level Cache:

   System.out.println("Demonstrating First-Level Cache:"); userService.demonstrateFirstLevelCache(); 

   The demonstrateFirstLevelCache method is called to demonstrate the first-level cache functionality.

4. Demonstrate Second-Level Cache:

   System.out.println("Demonstrating Second-Level Cache:"); userService.demonstrateSecondLevelCache(); 

   The demonstrateSecondLevelCache method is called to demonstrate the second-level cache functionality.

Sample Output

When you run the MainApp class, you should see the following output:

Demonstrating First-Level Cache: First query: Ramesh Fadatare Second query: Ramesh Fadatare Demonstrating Second-Level Cache: First session, first query: Ramesh Fadatare Second session, first query: Ramesh Fadatare 

This output indicates that the first-level cache was used to avoid a second database hit within the same session, and the second-level cache was used to avoid a second database hit across different sessions.

Conclusion

In this tutorial, we have successfully demonstrated how to implement caching in Hibernate. We set up a Hibernate project, created an entity class, and implemented caching functionality using first-level and second-level caches. This guide provides a solid foundation for improving the performance of your Hibernate-based applications through caching.