Query Cache in Hibernate


Let us understand the Query Cache


We know that, Query cache will cache the results of the query against the object.

If we have queries which runs multiple times with the same parameters then Query caching is best to use to avoid multiple DB calls.

Let us see complete project on Hibernate Query cache

Step 1

Create Hibernate project

Please refer Hibernate setup in eclipse article on how to do it.

Project structure

query_cache_proj_structure

Step 2

Update pom.xml with required dependnecies

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.  
  5.   <groupId>HibernateQueryCache</groupId>
  6.   <artifactId>HibernateQueryCache</artifactId>
  7.   <version>0.0.1-SNAPSHOT</version>
  8.   <packaging>jar</packaging>
  9.  
  10.   <name>HibernateQueryCache</name>
  11.   <url>http://maven.apache.org</url>
  12.  
  13.   <properties>
  14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  15.   </properties>
  16.  
  17.   <dependencies>
  18.  
  19.     <dependency>
  20.       <groupId>junit</groupId>
  21.       <artifactId>junit</artifactId>
  22.       <version>3.8.1</version>
  23.       <scope>test</scope>
  24.     </dependency>
  25.  
  26.     <dependency>
  27.     <groupId>org.hibernate</groupId>
  28.     <artifactId>hibernate-core</artifactId>
  29.     <version>5.2.6.Final</version>
  30.     </dependency>
  31.        
  32.  <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  33.     <dependency>
  34.     <groupId>mysql</groupId>
  35.     <artifactId>mysql-connector-java</artifactId>
  36.     <version>6.0.5</version>
  37.      </dependency>
  38.        
  39.      <dependency>
  40.     <groupId>org.hibernate</groupId>
  41.     <artifactId>hibernate-ehcache</artifactId>
  42.     <version>5.2.9.Final</version>
  43.      </dependency>
  44.   </dependencies>
  45.  
  46. </project>
<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>HibernateQueryCache</groupId>
  <artifactId>HibernateQueryCache</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>HibernateQueryCache</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>

    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>

    <dependency>
	<groupId>org.hibernate</groupId>
	<artifactId>hibernate-core</artifactId>
	<version>5.2.6.Final</version>
    </dependency>
		
 <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
    <dependency>
	<groupId>mysql</groupId>
	<artifactId>mysql-connector-java</artifactId>
	<version>6.0.5</version>
     </dependency>
		
     <dependency>
	<groupId>org.hibernate</groupId>
	<artifactId>hibernate-ehcache</artifactId>
	<version>5.2.9.Final</version>
	 </dependency>
  </dependencies>

</project>

Step 3

Create the Employee class

  1. package com.kb.model;
  2.  
  3. import javax.persistence.Column;
  4. import javax.persistence.Entity;
  5. import javax.persistence.GeneratedValue;
  6. import javax.persistence.GenerationType;
  7. import javax.persistence.Id;
  8. import javax.persistence.Table;
  9.  
  10. import org.hibernate.annotations.Cache;
  11. import org.hibernate.annotations.CacheConcurrencyStrategy;
  12.  
  13. @Entity
  14. @Table(name="Employee")
  15. @Cache(usage=CacheConcurrencyStrategy.READ_ONLY, region="employeeCache")
  16. public class Employee {
  17.     @Id
  18.     @GeneratedValue(strategy = GenerationType.SEQUENCE)
  19.     @Column(name = "Employee_Id")
  20.     private int employeeId;
  21.    
  22.     @Column(name = "FirstName")
  23.     private String firstName;
  24.    
  25.     @Column(name = "LastName")
  26.     private String lastName;
  27.    
  28.     @Column(name = "Age")
  29.     private int age;
  30.    
  31.     @Column(name = "Education")
  32.     private String education;
  33.    
  34.     @Column(name = "Salary")
  35.     private int salary;
  36.    
  37.     public int getEmployeeId() {
  38.         return employeeId;
  39.     }
  40.     public void setEmployeeId(int employeeId) {
  41.         this.employeeId = employeeId;
  42.     }
  43.     public String getFirstName() {
  44.         return firstName;
  45.     }
  46.     public void setFirstName(String firstName) {
  47.         this.firstName = firstName;
  48.     }
  49.     public String getLastName() {
  50.         return lastName;
  51.     }
  52.     public void setLastName(String lastName) {
  53.         this.lastName = lastName;
  54.     }
  55.     public int getAge() {
  56.         return age;
  57.     }
  58.     public void setAge(int age) {
  59.         this.age = age;
  60.     }
  61.     public String getEducation() {
  62.         return education;
  63.     }
  64.     public void setEducation(String education) {
  65.         this.education = education;
  66.     }
  67.     public int getSalary() {
  68.         return salary;
  69.     }
  70.     public void setSalary(int salary) {
  71.         this.salary = salary;
  72.     }
  73. }
package com.kb.model;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;

import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;

@Entity
@Table(name="Employee")
@Cache(usage=CacheConcurrencyStrategy.READ_ONLY, region="employeeCache")
public class Employee {
	@Id
	@GeneratedValue(strategy = GenerationType.SEQUENCE)
	@Column(name = "Employee_Id")
	private int employeeId;
	
	@Column(name = "FirstName")
	private String firstName;
	
	@Column(name = "LastName")
	private String lastName;
	
	@Column(name = "Age")
	private int age;
	
	@Column(name = "Education")
	private String education;
	
	@Column(name = "Salary")
	private int salary;
	
	public int getEmployeeId() {
		return employeeId;
	}
	public void setEmployeeId(int employeeId) {
		this.employeeId = employeeId;
	}
	public String getFirstName() {
		return firstName;
	}
	public void setFirstName(String firstName) {
		this.firstName = firstName;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public String getEducation() {
		return education;
	}
	public void setEducation(String education) {
		this.education = education;
	}
	public int getSalary() {
		return salary;
	}
	public void setSalary(int salary) {
		this.salary = salary;
	}
}

Step 4

Create hibernate.cfg.xml file

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE hibernate-configuration PUBLIC
  3.        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
  4.        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  5.  
  6. <hibernate-configuration>
  7.  
  8.     <session-factory>
  9.  
  10.         <!-- Database connection properties -->
  11.         <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
  12.         <property name="connection.url">jdbc:mysql://localhost/javainsimpleway</property>
  13.         <property name="connection.username">root</property>
  14.         <property name="connection.password">root</property>
  15.  
  16.         <!-- JDBC connection pool (using the built-in) -->
  17.         <property name="connection.pool_size">100</property>
  18.  
  19.         <!-- SQL dialect -->
  20.         <property name="dialect">org.hibernate.dialect.MySQLDialect</property>
  21.  
  22.         <!-- Enable the second-level cache -->
  23.         <property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
  24.         <property name="hibernate.cache.use_second_level_cache">true</property>
  25.         <property name="hibernate.cache.region.factory_class">
  26.                        org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
  27.        
  28.         <property name="hibernate.cache.use_query_cache">true</property>
  29.  
  30.         <!-- Echo all executed SQL to stdout -->
  31.         <property name="show_sql">true</property>
  32.  
  33.         <!-- Format the generated Sql -->
  34.         <property name="format_sql">true</property>
  35.  
  36.         <!-- Dont Drop and re-create the database schema on startup,Just update
  37.             it -->
  38.         <property name="hbm2ddl.auto">update</property>
  39.  
  40.         <mapping class="com.kb.model.Employee" />
  41.  
  42.     </session-factory>
  43.  
  44. </hibernate-configuration>
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
       "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
       "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

	<session-factory>

		<!-- Database connection properties -->
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost/javainsimpleway</property>
		<property name="connection.username">root</property>
		<property name="connection.password">root</property>

		<!-- JDBC connection pool (using the built-in) -->
		<property name="connection.pool_size">100</property>

		<!-- SQL dialect -->
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>

		<!-- Enable the second-level cache -->
		<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
		<property name="hibernate.cache.use_second_level_cache">true</property>
		<property name="hibernate.cache.region.factory_class">
                       org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
		
		<property name="hibernate.cache.use_query_cache">true</property>

		<!-- Echo all executed SQL to stdout -->
		<property name="show_sql">true</property>

		<!-- Format the generated Sql -->
		<property name="format_sql">true</property>

		<!-- Dont Drop and re-create the database schema on startup,Just update 
			it -->
		<property name="hbm2ddl.auto">update</property>

		<mapping class="com.kb.model.Employee" />

	</session-factory>

</hibernate-configuration>

Step 5

Create hibernate utility class

  1. package com.kb.util;
  2.  
  3. import org.hibernate.SessionFactory;
  4. import org.hibernate.cfg.Configuration;
  5.  
  6. public class HibernateUtil {
  7.     private static final SessionFactory sessionFactory = buildSessionFactory();
  8.  
  9.      private static SessionFactory buildSessionFactory() {
  10.         try {
  11.             // Create the SessionFactory from hibernate.cfg.xml
  12.             return new Configuration().configure().buildSessionFactory();
  13.         } catch (Throwable ex) {
  14.             // Make sure you log the exception to track it
  15.             System.err.println("SessionFactory creation failed." + ex);
  16.             throw new ExceptionInInitializerError(ex);
  17.         }
  18.     }
  19.  
  20.     public static SessionFactory getSessionFactory() {
  21.         return sessionFactory;
  22.     }
  23.    
  24.     public static void shutdown() {
  25.         // Optional but can be used to Close caches and connection pools
  26.         getSessionFactory().close();
  27.     }
  28.  
  29. }
package com.kb.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 to track it
            System.err.println("SessionFactory creation failed." + ex);
            throw new ExceptionInInitializerError(ex);
        }
    }

    public static SessionFactory getSessionFactory() {
        return sessionFactory;
    }
    
    public static void shutdown() {
    	// Optional but can be used to Close caches and connection pools
    	getSessionFactory().close();
    }

}

Step 6

Populate the data in DB

  1. package com.kb.db;
  2.  
  3. import org.hibernate.Session;
  4. import org.hibernate.SessionFactory;
  5. import org.hibernate.Transaction;
  6.  
  7. import com.kb.model.Employee;
  8. import com.kb.util.HibernateUtil;
  9.  
  10. public class PopulateData {
  11. public static void main(String[] args) {
  12.  
  13.     // Get session factory using Hibernate Util class
  14.     SessionFactory sf = HibernateUtil.getSessionFactory();
  15.     // Get session from Sesson factory
  16.     Session session = sf.openSession();
  17.  
  18.     // Begin transaction
  19.     Transaction t = session.beginTransaction();
  20.    
  21.     //Create Employee  data
  22.     Employee employee1 = new Employee();
  23.     employee1.setFirstName("John");
  24.     employee1.setLastName("KC");
  25.     employee1.setAge(28);
  26.     employee1.setEducation("PG");
  27.     employee1.setSalary(25000);
  28.    
  29.     Employee employee2 = new Employee();
  30.     employee2.setFirstName("Jacob");
  31.     employee2.setLastName("JC");
  32.     employee2.setAge(30);
  33.     employee2.setEducation("PG");
  34.     employee2.setSalary(30000);
  35.    
  36.     Employee employee3 = new Employee();
  37.     employee3.setFirstName("Martin");
  38.     employee3.setLastName("A");
  39.     employee3.setAge(24);
  40.     employee3.setEducation("UG");
  41.     employee3.setSalary(20000);
  42.    
  43.     Employee employee4 = new Employee();
  44.     employee4.setFirstName("Peter");
  45.     employee4.setLastName("M");
  46.     employee4.setAge(25);
  47.     employee4.setEducation("UG");
  48.     employee4.setSalary(22000);
  49.    
  50.     Employee employee5 = new Employee();
  51.     employee5.setFirstName("Roshan");
  52.     employee5.setLastName("B");
  53.     employee5.setAge(29);
  54.     employee5.setEducation("PG");
  55.     employee5.setSalary(45000);
  56.    
  57.    
  58.     session.save(employee1);
  59.     session.save(employee2);
  60.     session.save(employee3);
  61.     session.save(employee4);
  62.     session.save(employee5);
  63.  
  64.     // Commit the transaction and close the session
  65.     t.commit();
  66.    
  67.     session.close();
  68.     System.out.println("successfully persisted Employee details");
  69.  
  70. }
  71.  
  72. }
package com.kb.db;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;

import com.kb.model.Employee;
import com.kb.util.HibernateUtil;

public class PopulateData {
public static void main(String[] args) {

	// Get session factory using Hibernate Util class
	SessionFactory sf = HibernateUtil.getSessionFactory();
	// Get session from Sesson factory
	Session session = sf.openSession();

	// Begin transaction
	Transaction t = session.beginTransaction();
	
	//Create Employee  data
	Employee employee1 = new Employee();
	employee1.setFirstName("John");
	employee1.setLastName("KC");
	employee1.setAge(28);
	employee1.setEducation("PG");
	employee1.setSalary(25000);
	
	Employee employee2 = new Employee();
	employee2.setFirstName("Jacob");
	employee2.setLastName("JC");
	employee2.setAge(30);
	employee2.setEducation("PG");
	employee2.setSalary(30000);
	
	Employee employee3 = new Employee();
	employee3.setFirstName("Martin");
	employee3.setLastName("A");
	employee3.setAge(24);
	employee3.setEducation("UG");
	employee3.setSalary(20000);
	
	Employee employee4 = new Employee();
	employee4.setFirstName("Peter");
	employee4.setLastName("M");
	employee4.setAge(25);
	employee4.setEducation("UG");
	employee4.setSalary(22000);
	
	Employee employee5 = new Employee();
	employee5.setFirstName("Roshan");
	employee5.setLastName("B");
	employee5.setAge(29);
	employee5.setEducation("PG");
	employee5.setSalary(45000);
	
	
	session.save(employee1);
	session.save(employee2);
	session.save(employee3);
	session.save(employee4);
	session.save(employee5);

	// Commit the transaction and close the session
	t.commit();
	
	session.close();
	System.out.println("successfully persisted Employee details");

}

}

Step 7

Check the output and queries executed

primary_cache_data_populate

Step 8

Create QueryCacheDemo.java for testing query cache

  1. package com.kb.db;
  2.  
  3. import org.hibernate.Query;
  4. import org.hibernate.Session;
  5. import org.hibernate.SessionFactory;
  6.  
  7. import com.kb.model.Employee;
  8. import com.kb.util.HibernateUtil;
  9.  
  10. public class QueryCacheDemo {
  11.     @SuppressWarnings("deprecation")
  12.     public static void main(String[] args) {
  13.  
  14.         // Get session factory using Hibernate Util class
  15.        
  16.         Employee employee1 =  getEmployee(1);
  17.         displayEmployeeDetails(employee1);
  18.         Employee employee2 =  getEmployee(1);
  19.         displayEmployeeDetails(employee2);
  20.  
  21.         Employee employee3 =  getEmployee(2);
  22.         displayEmployeeDetails(employee3);
  23.        
  24.     }
  25.  
  26.     @SuppressWarnings("deprecation")
  27.     private static Employee getEmployee(int id) {
  28.         SessionFactory sf = HibernateUtil.getSessionFactory();
  29.  
  30.         // Get session from Session factory
  31.         Session session = sf.openSession();
  32.  
  33.         Query query = session.createQuery("from Employee e where e.employeeId = :employeeId ");
  34.                
  35.                   query.setParameter("employeeId", id);
  36.                
  37.                   query.setMaxResults(1);
  38.                
  39.                   query.setCacheable(true);
  40.                
  41.                   return query.list() == null ? null : (Employee) query.getResultList().get(0);
  42.     }
  43.  
  44.     private static void displayEmployeeDetails(Employee employee) {
  45.         System.out.println(
  46.                 "ID: " + employee.getEmployeeId() + " Age: " + employee.getAge() + " Salary: " + employee.getSalary());
  47.     }
  48. }
package com.kb.db;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.kb.model.Employee;
import com.kb.util.HibernateUtil;

public class QueryCacheDemo {
	@SuppressWarnings("deprecation")
	public static void main(String[] args) {

		// Get session factory using Hibernate Util class
		
		Employee employee1 =  getEmployee(1);
		displayEmployeeDetails(employee1);
		Employee employee2 =  getEmployee(1);
		displayEmployeeDetails(employee2);

		Employee employee3 =  getEmployee(2);
		displayEmployeeDetails(employee3);
		
	}

	@SuppressWarnings("deprecation")
	private static Employee getEmployee(int id) {
		SessionFactory sf = HibernateUtil.getSessionFactory();

		// Get session from Session factory
		Session session = sf.openSession();

		Query query = session.createQuery("from Employee e where e.employeeId = :employeeId ");
				
				  query.setParameter("employeeId", id);
				
				  query.setMaxResults(1);
				
				  query.setCacheable(true);
				
				  return query.list() == null ? null : (Employee) query.getResultList().get(0);
	}

	private static void displayEmployeeDetails(Employee employee) {
		System.out.println(
				"ID: " + employee.getEmployeeId() + " Age: " + employee.getAge() + " Salary: " + employee.getSalary());
	}
}


In this program, we are calling getEmployee() method twice by passing the same employee id1” and we can observe in the output that query is executed only once for both the method call.

This is because Query is cached with that parameter.

When we make another call to the method by passing Employee Id as “2”, it’s making DB call as data is not available in cache with Employee id “2”.

Step 9

Check the output and queries executed

query_cache-_output

Download this project HibernateQueryCache.zip

About the Author

Founder of javainsimpleway.com
I love Java and open source technologies and very much passionate about software development.
I like to share my knowledge with others especially on technology 🙂
I have given all the examples as simple as possible to understand for the beginners.
All the code posted on my blog is developed,compiled and tested in my development environment.
If you find any mistakes or bugs, Please drop an email to kb.knowledge.sharing@gmail.com

Connect with me on Facebook for more updates

Share this article on