Haresh @ Liferay: Hibernate second level cache using Ehcache

Hibernate is compatible with many second-level cache providers. One of the best solution is Ehcache.

We create a sample project and configure second-level cache with hibernate using Maven. Here we use Hibernate 4.1 and Hibernate Ehcache 4.1

So the pom.xml is look like this

<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">

<groupId>com.haresh</groupId>

<artifactId>hibernate-tutorials</artifactId>

<version>0.0.1-SNAPSHOT</version>

<name>HibernateTutorial</name>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-core</artifactId>

<version>4.1.12.Final</version>

</dependency>

<!-- Hibernate uses jboss-logging for logging, for the tutorials we will

use the sl4fj-simple backend -->

<artifactId>slf4j-simple</artifactId>

</dependency>

<groupId>junit</groupId>

<artifactId>junit</artifactId>

</dependency>

<groupId>mysql</groupId>

<artifactId>mysql-connector-java</artifactId>

</dependency>

<groupId>org.hibernate</groupId>

<artifactId>hibernate-ehcache</artifactId>

<version>4.1.1.Final</version>

</dependency>

<groupId>com.h2database</groupId>

</dependency>

</dependencies>

</project>

Now have to create a Hibernate-configuration File. hibernate.cfg.xml.

the Default configuration of hibernate.cfg.xml is as below,

<property name="cache.provider_class">org.hibernate.cache.internal.NoCacheProvider</property>

Here we have to change the configuration to enable second-level cache. I mention that we are using 4.x version of Hibernate.

So, In our case we have to add two more property in configuration file. One is for enable the cache, it's a boolean value, this value tell to hibernate that the second-level cache is enable.

And Second-one is Provider Class, which tell to hibernate that the Second-level cache is used through this provider. Below is the configuration.

<!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>

<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>

<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>

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

<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>

<property name="hbm2ddl.auto">update</property>

</session-factory>

</hibernate-configuration>

Now we have to create an entity. Which have annotation for ORM. And we add another annotation to this entity for cache.

At the top of Class and below the @Entity annotation we add two more annotation, one is @Cacheable which tell to hibernate that the entity is enable for Cache. And the Second one and Most important thing is to add Cache strategy, Here we add READ-ONLY. The Object is only in read mode while it's a cache-able, there is no insert/update operation perform event after the change of State of Object. Hibernate have no worry to manage Object when it's state change. In READ-WRITE the Object's data is update then the Cache is also update simultaneously.

package com.haresh.model;

import java.util.Date;

import javax.persistence.Cacheable;

import javax.persistence.Column;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.Id;

import javax.persistence.Table;

import javax.persistence.Temporal;

import javax.persistence.TemporalType;

import org.hibernate.annotations.Cache;

import org.hibernate.annotations.CacheConcurrencyStrategy;

import org.hibernate.annotations.GenericGenerator;

@Entity

@Cacheable

@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)

@Table( name = "EVENTS" )

public class Event {

private Long id;

private String title;

private Date date;

public Event() {

// this form used by Hibernate

}

public Event(String title, Date date) {

// for application use, to create new events

this.title = title;

this.date = date;

}

@Id

@GeneratedValue(generator="increment")

@GenericGenerator(name="increment", strategy = "increment")

public Long getId() {

return id;

}

private void setId(Long id) {

this.id = id;

}

@Temporal(TemporalType.TIMESTAMP)

@Column(name = "EVENT_DATE")

public Date getDate() {

return date;

}

public void setDate(Date date) {

this.date = date;

}

public String getTitle() {

return title;

}

public void setTitle(String title) {

this.title = title;

}

@Override

public String toString() {

return "[id = "+id+", title = "+title+"]";

}

Now let's test the code, We are trying to fetch a Record from Database of Event having ID equal 1. In a normal case when we are trying to fetch record from Hibernate Session, it's traverse to the database for each new query in a every new open session.

Here It's traverse once to database and in second query it's look in to cache and get data immediatly. For ex.

Session session = HibernateUtil.getSessionFactory().openSession();

session.getTransaction().begin();

session.get(Event.class, 1l);

session.getTransaction().commit();

session.close();

// Again try to fatch data for the same Event Id,It retrive from Cache

session = HibernateUtil.getSessionFactory().openSession();

session.getTransaction().begin();

session.get(Event.class, 1l);

session.getTransaction().commit();

session.close();

In console it print only one select query rather than two select query. The Second fetch was from Cache.; Hibernate: select event0_.id as id1_0_0_, event0_.EVENT_DATE as EVENT2_0_0_, event0_.title as title3_0_0_ from EVENTS event0_ where event0_.id=?; Hibernate Cache Strategy.(http://docs.jboss.org/hibernate/orm/4.1/devguide/en-US/html_single/#d5e1364); read-only; A read-only cache is good for data that needs to be read often but not modified. It is simple, performs well, and is safe to use in a clustered environment.
nonstrict read-write: Some applications only rarely need to modify data. This is the case if two transactions are unlikely to try to update the same item simultaneously. In this case, you do not need strict transaction isolation, and a nonstrict-read-write cache might be appropriate. If the cache is used in a JTA environment, you must specify hibernate.transaction.manager_lookup_class. In other environments, ensore that the transaction is complete before you call Session.close() or Session.disconnect().
read-write: A read-write cache is appropriate for an application which needs to update data regularly. Do not use a read-write strategy if you need serializable transaction isolation. In a JTA environment, specify a strategy for obtaining the JTA TransactionManager by setting the property hibernate.transaction.manager_lookup_class. In non-JTA environments, be sure the transaction is complete before you call Session.close() or Session.disconnect().
transactional: The transactional cache strategy provides support for transactional cache providers such as JBoss TreeCache. You can only use such a cache in a JTA environment, and you must first specify hibernate.transaction.manager_lookup_class.

Haresh @ Liferay

Tuesday, 23 July 2013

Hibernate second level cache using Ehcache

No comments:

Post a Comment

Infinidb _CpNoTf_ problem

Followers

Total Pageviews