Hibernate性能优化：二级缓存

hibernate二级缓存

定义步骤：
1、打开缓存，在hibernate.cfg.xm中加入：
<property name="hibernate.cache.use_second_level_cache">true</property>

2、指定缓存策略提供商，在hibernate.cfg.xm中加入：
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

3、拷贝echcahe.xml到src下，可以针对不同的策略配置缓存

4、指定那些类使用缓存(两种方式)
  * 在hibernate.cfg.xml
  * 在映射文件中

二级缓存中存储的也是实体对象，他们都属于SessionFactory级别，
是全局的，伴随SessionFactory的生命周期存在和消亡

需要了解一级缓存和二级缓存的交互模式（CacheMode）
测试一级缓存与二级缓存的交互
	 * CacheMode.NORMAL  :从二级缓存读写数据
	 * CacheMode.GET  :从二级缓存读数据,仅在数据更新时向二级缓存写数据
	 * CacheMode.PUT  :仅向二级缓存写数据,但不从二级缓存读数据
	 * CacheMode.REFRESH  :仅向二级缓存写数据,但不从二级缓存读数据.通过hibernate.cache.use_minimal_puts的设置,强制二级缓存从数据库中读数据.刷新缓存内容.

 

 

首先采用一对多双向进行配置,创建表.

POJO:

package com.lwf.hibernate.pojo;

import java.util.HashSet;
import java.util.Set;

public class Classes {

	private int id;
	private String name;
	private Set students = new HashSet();
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public Set getStudents() {
		return students;
	}
	public void setStudents(Set students) {
		this.students = students;
	}
	
}

 

package com.lwf.hibernate.pojo;

public class Student {

	private int id;
	private String name;
	private int age;
	private Classes classes;
	
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	public Classes getClasses() {
		return classes;
	}
	public void setClasses(Classes classes) {
		this.classes = classes;
	}
}

 

Classes.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
	<hibernate-mapping package="com.lwf.hibernate.pojo">
	
		<class name="Classes" table="t_classes">
			<id name="id">
				<generator class="native"/>
			</id>
			<property name="name"/>
			<set name="students" inverse="true">
				<key column="class_id" ></key>
				<one-to-many class="Student" />
			</set>
			
		</class>
	</hibernate-mapping>

 

Student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC 
	"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
	"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
	<hibernate-mapping package="com.lwf.hibernate.pojo">
		<class name="Student" table="t_student">
			<id name="id">
				<generator class="native"/>
			</id>
			<property name="name"/>
			<property name="age"/>
			<many-to-one name="classes" column="class_id"></many-to-one>
		</class>
		
	</hibernate-mapping>

 

工具类:

package com.lwf.hibernate.util;

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;


public class ExportDB {

	/**
	 * @param args
	 */
	public static void main(String[] args) {

		Configuration config = new Configuration().configure();
		SchemaExport export = new SchemaExport(config);
		export.create(true, true);
	}

}

 

package com.lwf.hibernate.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateUtil {

	private static SessionFactory factory;
	static{
		Configuration config = new Configuration().configure();
		factory = config.buildSessionFactory();
	}
	
	
	public static SessionFactory getSessionFactory(){
		return factory;
	}
	public static Session getSession(){
		Session session = null;
		session = factory.openSession();
		return session;
	}
	
	public static void closeSession(Session session){
		if(session!=null){
			if(session.isOpen()){
				session.close();
			}
		}
	}
	
	public static void roolback(Session session){
		if(session!=null){
			if(session.isOpen()){
				session.beginTransaction().rollback();
			}
		}
	}
	
	public static void commit(Session session){
		if(session!=null){
			if(session.isOpen()){
				session.beginTransaction().commit();
			}
		}
	}
}

 

在SRC根目录加上以下三个文件:

hibernate.cfg.xml

<!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.connection.url">
			jdbc:mysql://127.0.0.1/hibernate_cache
		</property>
		<property name="hibernate.connection.driver_class">
			com.mysql.jdbc.Driver
		</property>
		<property name="hibernate.connection.username">root</property>
		<property name="hibernate.connection.password">sys833199</property>
		<property name="dialect">
			org.hibernate.dialect.MySQLDialect
		</property>
		<property name="show_sql">true</property>
		<property name="hibernate.cache.use_second_level_cache">true</property>
		<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
		<mapping resource="com/lwf/hibernate/map/Student.hbm.xml"/>
		<mapping resource="com/lwf/hibernate/map/Classes.hbm.xml"/>
		
		<class-cache usage="read-only" class="com.lwf.hibernate.pojo.Student"/>
		<!--二级缓存一般用于读数据,如果数据变化多使用二级缓存的写功能会比较麻烦,因为更新数据的时候即要改二级缓存又要改数据库,操作更麻烦了.使用二级缓存是为了提高性能 -->
	</session-factory>
</hibernate-configuration>

 

log4j.properties

### direct log messages to stdout ###
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### direct messages to file hibernate.log ###
#log4j.appender.file=org.apache.log4j.FileAppender
#log4j.appender.file.File=hibernate.log
#log4j.appender.file.layout=org.apache.log4j.PatternLayout
#log4j.appender.file.layout.ConversionPattern=%d{ABSOLUTE} %5p %c{1}:%L - %m%n

### set log levels - for more verbose logging change 'info' to 'debug' ###

log4j.rootLogger=warn, stdout

#log4j.logger.org.hibernate=info
#log4j.logger.org.hibernate=debug

### log HQL query parser activity
#log4j.logger.org.hibernate.hql.ast.AST=debug

### log just the SQL
#log4j.logger.org.hibernate.SQL=debug

### log JDBC bind parameters ###
log4j.logger.org.hibernate.type=info
#log4j.logger.org.hibernate.type=debug

### log schema export/update ###
log4j.logger.org.hibernate.tool.hbm2ddl=debug

### log HQL parse trees
#log4j.logger.org.hibernate.hql=debug

### log cache activity ###
#log4j.logger.org.hibernate.cache=debug

### log transaction activity
#log4j.logger.org.hibernate.transaction=debug

### log JDBC resource acquisition
#log4j.logger.org.hibernate.jdbc=debug

### enable the following line if you want to track down connection ###
### leakages when using DriverManagerConnectionProvider ###
#log4j.logger.org.hibernate.connection.DriverManagerConnectionProvider=trace

 

ehcache.xml

<ehcache>

    <!-- Sets the path to the directory where cache .data files are created.

         If the path is a Java System Property it is replaced by
         its value in the running VM.

         The following properties are translated:
         user.home - User's home directory
         user.dir - User's current working directory
         java.io.tmpdir - Default temp file path -->
    <diskStore path="java.io.tmpdir"/>


    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required for defaultCache:

        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->
    <defaultCache
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

    <!--Predefined caches.  Add your cache configuration settings here.
        If you do not have a configuration for your cache a WARNING will be issued when the
        CacheManager starts

        The following attributes are required for defaultCache:

        name              - Sets the name of the cache. This is used to identify the cache. It must be unique.
        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->

    <!-- Sample cache named sampleCache1
        This cache contains a maximum in memory of 10000 elements, and will expire
        an element if it is idle for more than 5 minutes and lives for more than
        10 minutes.

        If there are more than 10000 elements it will overflow to the
        disk cache, which in this configuration will go to wherever java.io.tmp is
        defined on your system. On a standard Linux system this will be /tmp"
        -->
    <cache name="sampleCache1"
        maxElementsInMemory="10000"
        eternal="false"
        timeToIdleSeconds="300"
        timeToLiveSeconds="600"
        overflowToDisk="true"
        />

    <!-- Sample cache named sampleCache2
        This cache contains 1000 elements. Elements will always be held in memory.
        They are not expired. -->
    <cache name="sampleCache2"
        maxElementsInMemory="1000"
        eternal="true"
        timeToIdleSeconds="0"
        timeToLiveSeconds="0"
        overflowToDisk="false"
        /> -->

    <!-- Place configuration for your caches following -->

</ehcache>

 

 

这三个文件都可以在hibernate源码的etc目录拷贝.

生成数据类:

package com.lwf.hibernate.test;

import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import junit.framework.TestCase;

import org.hibernate.Session;

import com.lwf.hibernate.pojo.Classes;
import com.lwf.hibernate.pojo.Student;
import com.lwf.hibernate.util.HibernateUtil;

public class InitData extends TestCase{

	public void testClasses(){
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		try{
			
			Set students = new HashSet();
			for(int i=0;i<5;i++){
				Student s = new Student();
				s.setName("name" + i);
				s.setAge((10 + i));
				students.add(s);
				session.save(s);
			}
			
			
			Classes cla = new Classes();
			cla.setName("class1");
			cla.setStudents(students);
			session.save(cla);
			//先保存，最后根据class_id更新Student
			
			HibernateUtil.commit(session);
		}catch(Exception e){
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
	}
	public void testStudent(){
		//单向测试的时候不会更新student的class_id
		Session session = HibernateUtil.getSession();
		session.beginTransaction();
		try{
			Classes cla = new Classes();
			cla.setName("class1");
			session.save(cla);
			
			for(int i=0;i<5;i++){
				Student s = new Student();
				s.setName("name" + i);
				s.setAge((10 + i));
				s.setClasses(cla);
				session.save(s);
			}
			
			
			HibernateUtil.commit(session);
		}catch(Exception e){
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
		
	}
	
	/**
	 * 从Classes端加载
	 *
	 */
	public void testLoadOne2Many1() {
		Session session = null;
		try {
			session = HibernateUtil.getSession();
			Classes classes = (Classes)session.load(Classes.class, 2);
			System.out.println("班级名称：" + classes.getName() + "拥有学生：");
			Set students = classes.getStudents();
			for (Iterator iter=students.iterator();iter.hasNext();) {
				Student student = (Student)iter.next();
				System.out.println(student.getName());
			}
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtil.closeSession(session);
		}
	}
	
	/**
	 * 从Student端加载
	 *
	 */
	public void testLoadOne2Many2() {
		Session session = null;
		try {
			session = HibernateUtil.getSession();
			Student student = (Student)session.load(Student.class, 2);
			System.out.println("学生姓名：" + student.getName());
			System.out.println("所属班级：" + student.getClasses().getName());
		}catch(Exception e) {
			e.printStackTrace();
		}finally {
			HibernateUtil.closeSession(session);
		}
	}
}

 

测试类:

package com.lwf.hibernate.test;

import junit.framework.TestCase;

import org.hibernate.CacheMode;
import org.hibernate.Session;
import org.hibernate.SessionFactory;

import com.lwf.hibernate.pojo.Student;
import com.lwf.hibernate.util.HibernateUtil;

public class SecondCacheTest extends TestCase{

	/*
	 * 打开两次session,因为打开了二级缓存,所以只发出一次查询
	 */
	public void testCache1(){
		Session session = null;
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			
			Student student = (Student)session.load(Student.class, 1);
			System.out.println(student.getName());
			//发出查询之后,由于配置了二级缓存,此时会向一级缓存和二级缓存缓存对象.
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
			//一级缓存session关闭,二级缓存sessionFactory仍存在
		}
		
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			//开启另一个一级缓存,二级缓存仍是上面的.
			Student student = (Student)session.load(Student.class, 1);
			System.out.println(student.getName());
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
	}
	
	/*
	 * 打开两次session,但因为中间使用factory.evict将Student对象从二级缓存踢出,所以会再次发出查询,在整个这个方法中会发出两次查询.
	 */
	public void testCache2(){
		Session session = null;
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			
			Student student = (Student)session.load(Student.class, 1);
			System.out.println(student.getName());
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
		
		SessionFactory factory = HibernateUtil.getSessionFactory();
		factory.evict(Student.class);
		
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			
			Student student = (Student)session.load(Student.class, 1);
			System.out.println(student.getName());
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
	}
	
	/*
	 * 测试Get的二级缓存,效果与load一样.
	 */
	public void testCache3(){
		Session session = null;
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			
			Student student = (Student)session.get(Student.class, 1);
			System.out.println(student.getName());
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
		
		SessionFactory factory = HibernateUtil.getSessionFactory();
		factory.evict(Student.class);
		
		try {
			session = HibernateUtil.getSession();
			session.beginTransaction();
			
			Student student = (Student)session.get(Student.class, 1);
			System.out.println(student.getName());
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
	}
	
	
	/*
	 * 测试一级缓存与二级缓存的交互
	 * CacheMode.NORMAL  :从二级缓存读写数据
	 * CacheMode.GET  :从二级缓存读数据,仅在数据更新时向二级缓存写数据
	 * CacheMode.PUT  :仅向二级缓存写数据,但不从二级缓存读数据
	 * CacheMode.REFRESH  :仅向二级缓存写数据,但不从二级缓存读数据.通过hibernate.cache.use_minimal_puts的设置,强制二级缓存从数据库中读数据.刷新缓存内容.
	 */
	public void testCache4(){
		Session session = null;
		try {
			//打开第一个session
			session = HibernateUtil.getSession();
			session.setCacheMode(CacheMode.GET);
			//设置了不把数据放入二级缓存,仅从缓存读数据
			session.beginTransaction();
			
			Student student = (Student)session.get(Student.class, 1);
			System.out.println(student.getName());
			//查询出来后没有放入二级缓存
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
		
		
		try {
			//打开第二个session
			session = HibernateUtil.getSession();
			session.beginTransaction();
			//因为上面并没有放入二级缓存,所以这次会发出查询语句.
			Student student = (Student)session.get(Student.class, 1);
			System.out.println(student.getName());
			//按默认查询出来后放入的二级缓存.
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
		
		try {
			//打开第三个session
			session = HibernateUtil.getSession();
			session.beginTransaction();
			//二级缓存已有数据,从二级缓存get,所以不发出查询语句
			Student student = (Student)session.get(Student.class, 1);
			System.out.println(student.getName());
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
		
		try {
			//打开第四个session
			session = HibernateUtil.getSession();
			session.beginTransaction();
			session.setCacheMode(CacheMode.PUT);
			//设置仅向二级缓存写数据,不从二级缓存读
			//不从二级缓存读,所以发出查询语句
			Student student = (Student)session.get(Student.class, 1);
			System.out.println(student.getName());
			//写入二级缓存
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
		
		try {
			//打开第五个session
			session = HibernateUtil.getSession();
			session.beginTransaction();
			//没有相关Cache设置,可读可写.因为上面已写入二级缓存,所以不发出查询语句
			Student student = (Student)session.get(Student.class, 1);
			System.out.println(student.getName());
			HibernateUtil.commit(session);
		} catch (Exception e) {
			HibernateUtil.roolback(session);
		}finally{
			HibernateUtil.closeSession(session);
		}
	}
	
	
}

 

配置步骤:

运行ExportDB.java生成表.

运行InitData.java中的生成数据的方法,产生测试数据

运行SecondCacheTest.java中的方法进行测试.

 

测试结果:

这里只列出testCache4方法的结果:

Hibernate: select student0_.id as id0_0_, student0_.name as name0_0_, student0_.age as age0_0_, student0_.class_id as class4_0_0_ from t_student student0_ where student0_.id=?
name0
Hibernate: select student0_.id as id0_0_, student0_.name as name0_0_, student0_.age as age0_0_, student0_.class_id as class4_0_0_ from t_student student0_ where student0_.id=?
name0
name0
Hibernate: select student0_.id as id0_0_, student0_.name as name0_0_, student0_.age as age0_0_, student0_.class_id as class4_0_0_ from t_student student0_ where student0_.id=?
name0
name0

 

 

注意:这配置二级缓存的时候需要几个其它的包,我在http://quicker.iteye.com/blog/663471一文中有补充.附件里有代码