What is the difference between first level cache and second level cache?
First Level Cache
|
Second Level Cache
|
|
First Level Cache is associated with Session.
|
Second Level Cache is associated with SessionFactory.
|
|
It is enabled by default.
|
It is not enabled by default.
|
Caching is all about application performance optimization and it sits between your application and the database to avoid the number of database hits as many as possible to give a better performance for performance critical applications.
Caching is important to Hibernate as well which utilizes a multilevel caching schemes as explained below:
First-level cache:
The first-level cache is the Session cache and is a mandatory cache through which all requests must pass. The Session object keeps an object under its own power before committing it to the database.
If you issue multiple updates to an object, Hibernate tries to delay doing the update as long as possible to reduce the number of update SQL statements issued. If you close the session, all the objects being cached are lost and either persisted or updated in the database.
Second-level cache:
Second level cache is an optional cache and first-level cache will always be consulted before any attempt is made to locate an object in the second-level cache. The second-level cache can be configured on a per-class and per-collection basis and mainly responsible for caching objects across sessions.
Any third-party cache can be used with Hibernate. An org.hibernate.cache.CacheProvider interface is provided, which must be implemented to provide Hibernate with a handle to the cache implementation.
Query-level cache:
Hibernate also implements a cache for query resultsets that integrates closely with the second-level cache.
This is an optional feature and requires two additional physical cache regions that hold the cached query results and the timestamps when a table was last updated. This is only useful for queries that are run frequently with the same parameters.
The Second Level Cache:
Hibernate uses first-level cache by default and you have nothing to do to use first-level cache. Let's go straight to the optional second-level cache. Not all classes benefit from caching, so it's important to be able to disable the second-level cache
The Hibernate second-level cache is set up in two steps. First, you have to decide which concurrency strategy to use. After that, you configure cache expiration and physical cache attributes using the cache provider.
Concurrency strategies:
A concurrency strategy is a mediator which responsible for storing items of data in the cache and retrieving them from the cache. If you are going to enable a second-level cache, you will have to decide, for each persistent class and collection, which cache concurrency strategy to use.
- Transactional: Use this strategy for read-mostly data where it is critical to prevent stale data in concurrent transactions,in the rare case of an update.
- Read-write: Again use this strategy for read-mostly data where it is critical to prevent stale data in concurrent transactions,in the rare case of an update.
- Nonstrict-read-write: This strategy makes no guarantee of consistency between the cache and the database. Use this strategy if data hardly ever changes and a small likelihood of stale data is not of critical concern.
- Read-only: A concurrency strategy suitable for data which never changes. Use it for reference data only.
If we are going to use second-level caching for our Employee class, let us add the mapping element required to tell Hibernate to cache Employee instances using read-write strategy.
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD//EN" "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> <hibernate-mapping> <class name="Employee" table="EMPLOYEE"> <meta attribute="class-description"> This class contains the employee detail. </meta> <cache usage="read-write"/> <id name="id" type="int" column="id"> <generator class="native"/> </id> <property name="firstName" column="first_name" type="string"/> <property name="lastName" column="last_name" type="string"/> <property name="salary" column="salary" type="int"/> </class> </hibernate-mapping>
The usage="read-write" attribute tells Hibernate to use a read-write concurrency strategy for the defined cache.
Cache provider:
Your next step after considering the concurrency strategies you will use for your cache candidate classes is to pick a cache provider. Hibernate forces you to choose a single cache provider for the whole application.
| S.N. | Cache Name | Description |
|---|---|---|
| 1 | EHCache | It can cache in memory or on disk and clustered caching and it supports the optional Hibernate query result cache. |
| 2 | OSCache | Supports caching to memory and disk in a single JVM, with a rich set of expiration policies and query cache support. |
| 3 | warmCache | A cluster cache based on JGroups. It uses clustered invalidation but doesn't support the Hibernate query cache |
| 4 | JBoss Cache | A fully transactional replicated clustered cache also based on the JGroups multicast library. It supports replication or invalidation, synchronous or asynchronous communication, and optimistic and pessimistic locking. The Hibernate query cache is supported |
Every cache provider is not compatible with every concurrency strategy. The following compatibility matrix will help you choose an appropriate combination.
| Strategy/Provider | Read-only | Nonstrictread-write | Read-write | Transactional |
|---|---|---|---|---|
| EHCache | X | X | X | |
| OSCache | X | X | X | |
| SwarmCache | X | X | ||
| JBoss Cache | X | X |
You will specify a cache provider in hibernate.cfg.xml configuration file. We choose EHCache as our second-level cache provider:
<?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-configuration SYSTEM "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <property name="hibernate.dialect"> org.hibernate.dialect.MySQLDialect </property> <property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver </property> <!-- Assume students is the database name --> <property name="hibernate.connection.url"> jdbc:mysql://localhost/test </property> <property name="hibernate.connection.username"> root </property> <property name="hibernate.connection.password"> root123 </property> <property name="hibernate.cache.provider_class"> org.hibernate.cache.EhCacheProvider </property> <!-- List of XML mapping files --> <mapping resource="Employee.hbm.xml"/> </session-factory> </hibernate-configuration>
Now, you need to specify the properties of the cache regions. EHCache has its own configuration file,ehcache.xml, which should be in the CLASSPATH of the application. A cache configuration in ehcache.xml for the Employee class may look like this:
<diskStore path="java.io.tmpdir"/> <defaultCache maxElementsInMemory="1000" eternal="false" timeToIdleSeconds="120" timeToLiveSeconds="120" overflowToDisk="true" /> <cache name="Employee" maxElementsInMemory="500" eternal="true" timeToIdleSeconds="0" timeToLiveSeconds="0" overflowToDisk="false" />
That's it, now we have second-level caching enabled for the Employee class and Hibernate now hits the second-level cache whenever you navigate to a Employee or when you load a Employee by identifier.
You should analyze your all the classes and choose appropriate caching strategy for each of the classes. Sometime, second-level caching may downgrade the performance of the application. So it is recommended to benchmark your application first without enabling caching and later on enable your well suited caching and check the performance. If caching is not improving system performance then there is no point in enabling any type of caching.
The Query-level Cache:
To use the query cache, you must first activate it using the hibernate.cache.use_query_cache="true"property in the configuration file. By setting this property to true, you make Hibernate create the necessary caches in memory to hold the query and identifier sets.
Next, to use the query cache, you use the setCacheable(Boolean) method of the Query class. For example:
Session session = SessionFactory.openSession(); Query query = session.createQuery("FROM EMPLOYEE"); query.setCacheable(true); List users = query.list(); SessionFactory.closeSession();
Hibernate also supports very fine-grained cache support through the concept of a cache region. A cache region is part of the cache that's given a name.
Session session = SessionFactory.openSession(); Query query = session.createQuery("FROM EMPLOYEE"); query.setCacheable(true); query.setCacheRegion("employee"); List users = query.list(); SessionFactory.closeSession();
This code uses the method to tell Hibernate to store and look for the query in the employee area of the cache.
Second level cache implementation:
1) Add 2 configuration setting in hibernate.cfg.xml file
<?xml version='1.0' encoding='UTF-8'?>
<!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="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="connection.url">jdbc:oracle:thin:@localhost:1521:orcl</property>
<property name="connection.username">database</property>
<property name="connection.password">database</property>
<property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>
<property name="show_sql">true</property>
<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
<property name="hibernate.cache.use_second_level_cache">true</property>
<mapping resource="com/ibm/hbm/Employee.hbm.xml" />
</session-factory>
</hibernate-configuration>
2) Add cache usage setting in hbm file
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="com.ibm.beans.Employee" table="EMP">
<cache usage="read-only" />
<id name="employeeNo" column="ENO">
<generator class="assigned" />
</id>
<property name="employeeName" column="ENAME" />
<property name="employeeSalary" column="SALARY" />
</class>
</hibernate-mapping>
3) Create ehcache.xml file
<?xml version="1.0"?>
<ehcache>
<defaultCache maxElementsInMemory="100" eternal="false"
timeToIdleSeconds="120" timeToLiveSeconds="200" />
<cache name="com.ibm.beans.Employee" maxElementsInMemory="100"
eternal="false" timeToIdleSeconds="5" timeToLiveSeconds="200" />
</ehcache>
4) Create Employee.java file
package com.ibm.beans;
public class Employee
{
private Integer employeeNo;
private String employeeName;
private Double employeeSalary;
public Integer getEmployeeNo()
{
return employeeNo;
}
public void setEmployeeNo(Integer employeeNo)
{
this.employeeNo = employeeNo;
}
public String getEmployeeName()
{
return employeeName;
}
public void setEmployeeName(String employeeName)
{
this.employeeName = employeeName;
}
public Double getEmployeeSalary()
{
return employeeSalary;
}
public void setEmployeeSalary(Double employeeSalary)
{
this.employeeSalary = employeeSalary;
}
}
5. Main method:
/**
*******************************************************************************
* Licensed Materials - Property of IBM *
* © Copyright IBM 2007 All Rights Reserved *
* Created on 05-Apr-2015 *
*******************************************************************************
* Please do not makes any changes to this file without first *
* updating the revision history below, under description *
* please include relevant CRs or defect ids that required the change *
*******************************************************************************
* Revision History: *
* *
* Date Name Reference Description *
* ---------- ---------------- --------------------------------------------- *
* 05-Apr-2015 Chandra created *
*******************************************************************************
*/
package com.ibm.beans;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
/**
* @author Chandrahasa
*
*/
public class Main
{
/**
* @param args
*/
public static void main(String[] args)
{
Configuration cfg = new Configuration().configure();
SessionFactory factory = cfg.buildSessionFactory();
Session session1 = factory.openSession();
Employee emp1 = (Employee) session1.get(Employee.class, 1);
System.out.println(emp1.getEmployeeNo() + " " + emp1.getEmployeeName() + " " + emp1.getEmployeeSalary());
session1.close();
Session session2 = factory.openSession();
Employee emp2 = (Employee) session2.get(Employee.class, 2);
System.out.println(emp2.getEmployeeNo() + " " + emp2.getEmployeeName() + " " + emp2.getEmployeeSalary());
session2.close();
Session session3 = factory.openSession();
Employee emp3 = (Employee) session3.get(Employee.class, 1);
System.out.println(emp3.getEmployeeNo() + " " + emp3.getEmployeeName() + " " + emp3.getEmployeeSalary());
session3.close();
Session session4 = factory.openSession();
Employee emp4 = (Employee) session4.get(Employee.class, 2);
System.out.println(emp4.getEmployeeNo() + " " + emp4.getEmployeeName() + " " + emp4.getEmployeeSalary());
session4.close();
}
}
Output of above program:
Hibernate: select employee0_.ENO as ENO0_0_, employee0_.ENAME as ENAME0_0_, employee0_.SALARY as SALARY0_0_ from EMP employee0_ where employee0_.ENO=?
1 chandra 20000.0
Hibernate: select employee0_.ENO as ENO0_0_, employee0_.ENAME as ENAME0_0_, employee0_.SALARY as SALARY0_0_ from EMP employee0_ where employee0_.ENO=?
2 chandra 20000.0
1 chandra 20000.0
2 chandra 20000.0
As we can see here, hibernate does not fire query twice. If you don't use second level cache, hibernate will fire query twice because both query uses different session objects.
