hibernate查询缓存

查询缓存是针对普通属性结果集的缓存
对实体对象的结果集只缓存id

查询缓存的生命周期，当前关联的表发生修改，那么查询缓存生命周期结束

查询缓存的配置和使用：
 * 在hibernate.cfg.xml文件中启用查询缓存，如：
 <property name="hibernate.cache.use_query_cache">true</property>
 * 在程序中必须手动启用查询缓存，如：
 query.setCacheable(true);

 1<!DOCTYPE hibernate-configuration PUBLIC
 2    "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 3    "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
 4<hibernate-configuration>
 5 <session-factory>
 6  <property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate_cache</property> 
 7  <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> 
 8  <property name="hibernate.connection.username">root</property> 
 9  <property name="hibernate.connection.password">bjsxt</property> 
  <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> 
  <property name="hibernate.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> 
 <!--  启用查询缓存 --> 
  <property name="hibernate.cache.use_query_cache">true</property> 
  <mapping resource="com/bjsxt/hibernate/Classes.hbm.xml" /> 
  <mapping resource="com/bjsxt/hibernate/Student.hbm.xml" /> 
  <class-cache class="com.bjsxt.hibernate.Student" usage="read-only" include="all" /> 
  </session-factory>
  </hibernate-configuration>

 

  1package com.bjsxt.hibernate;
  2
  3import java.io.Serializable;
  4import java.util.Iterator;
  5import java.util.List;
  6
  7import org.hibernate.CacheMode;
  8import org.hibernate.Query;
  9import org.hibernate.Session;
 10import org.hibernate.SessionFactory;
 11
 12import junit.framework.TestCase;
 13
 14public class CacheLevel2Test extends TestCase {
 15
 16    /** *//**
 17     * 开启查询缓存，关闭二级缓存
 18     * 
 19     * 开启一个session，分别调用query.list
 20     */
 21    public void testCache1() {
 22        Session session = null;
 23        try {
 24            session = HibernateUtils.getSession();
 25            session.beginTransaction();
 26            
 27            Query query = session.createQuery("select s.name from Student s");
 28            //启用查询查询缓存
 29            query.setCacheable(true);
 30            
 31            List names = query.list(); 
 32            for (Iterator iter=names.iterator();iter.hasNext(); ) {
 33                String name = (String)iter.next();
 34                System.out.println(name);
 35            }
 36            
 37            System.out.println("-------------------------------------");
 38            query = session.createQuery("select s.name from Student s");
 39            //启用查询查询缓存
 40            query.setCacheable(true);
 41            
 42            //没有发出查询sql，因为启用了查询缓存
 43            names = query.list(); 
 44            for (Iterator iter=names.iterator();iter.hasNext(); ) {
 45                String name = (String)iter.next();
 46                System.out.println(name);
 47            }
 48
 49            session.getTransaction().commit();
 50        }catch(Exception e) {
 51            e.printStackTrace();
 52            session.getTransaction().rollback();
 53        }finally {
 54            HibernateUtils.closeSession(session);
 55        }
 56    }    
 57    
 58    /** *//**
 59     * 开启查询缓存，关闭二级缓存
 60     * 
 61     * 开启两个session，分别调用query.list
 62     */
 63    public void testCache2() {
 64        Session session = null;
 65        try {
 66            session = HibernateUtils.getSession();
 67            session.beginTransaction();
 68            
 69            Query query = session.createQuery("select s.name from Student s");
 70            //启用查询查询缓存
 71            query.setCacheable(true);
 72            
 73            List names = query.list(); 
 74            for (Iterator iter=names.iterator();iter.hasNext(); ) {
 75                String name = (String)iter.next();
 76                System.out.println(name);
 77            }
 78            session.getTransaction().commit();
 79        }catch(Exception e) {
 80            e.printStackTrace();
 81            session.getTransaction().rollback();
 82        }finally {
 83            HibernateUtils.closeSession(session);
 84        }
 85        
 86        System.out.println("-------------------------------------");
 87        
 88        try {
 89            session = HibernateUtils.getSession();
 90            session.beginTransaction();
 91            
 92            Query query = session.createQuery("select s.name from Student s");
 93            //启用查询查询缓存
 94            query.setCacheable(true);
 95            
 96            //不会发出查询sql，因为查询缓存的生命周期和session无关
 97            List names = query.list(); 
 98            for (Iterator iter=names.iterator();iter.hasNext(); ) {
 99                String name = (String)iter.next();
                System.out.println(name);
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }        
    
    /** *//**
     * 开启查询缓存，关闭二级缓存
     * 
     * 开启两个session，分别调用query.iterate
     */
    public void testCache3() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Query query = session.createQuery("select s.name from Student s");
            //启用查询查询缓存
            query.setCacheable(true);
             
            for (Iterator iter=query.iterate();iter.hasNext(); ) {
                String name = (String)iter.next();
                System.out.println(name);
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        
        System.out.println("-------------------------------------");
        
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Query query = session.createQuery("select s.name from Student s");
            //启用查询查询缓存
            query.setCacheable(true);
             
            //查询缓存只对query.list()起作用，query.iterate不起作用，也就是query.iterate不使用
            //查询缓存
            for (Iterator iter=query.iterate();iter.hasNext(); ) {
                String name = (String)iter.next();
                System.out.println(name);
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }
    
    /** *//**
     * 关闭查询缓存，关闭二级缓存
     * 
     * 开启两个session，分别调用query.list查询实体对象
     */
    public void testCache4() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Query query = session.createQuery("select s from Student s");
            //启用查询查询缓存
            //query.setCacheable(true);
            
            List students = query.list(); 
            for (Iterator iter=students.iterator();iter.hasNext(); ) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        
        System.out.println("-------------------------------------");
        
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Query query = session.createQuery("select s from Student s");
            //启用查询查询缓存
            //query.setCacheable(true);
            //会发出查询sql，因为list默认每次都会发出查询sql
            List students = query.list(); 
            for (Iterator iter=students.iterator();iter.hasNext(); ) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }        

    /** *//**
     * 开启查询缓存，关闭二级缓存
     * 
     * 开启两个session，分别调用query.list查询实体对象
     */
    public void testCache5() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Query query = session.createQuery("select s from Student s");
            //启用查询查询缓存
            query.setCacheable(true);
            
            List students = query.list(); 
            for (Iterator iter=students.iterator();iter.hasNext(); ) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        
        System.out.println("-------------------------------------");
        
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Query query = session.createQuery("select s from Student s");
            //启用查询查询缓存
            query.setCacheable(true);
            
            //会发出n条查询语句，因为开启了查询缓存，关闭了二级缓存，那么查询缓存会缓存实体对象的id
            //所以hibernate会根据实体对象的id去查询相应的实体，如果缓存中不存在相应的
            //实体那么将发出根据实体id查询的sql语句，否则不会发出sql使用缓存中的数据
            List students = query.list(); 
            for (Iterator iter=students.iterator();iter.hasNext(); ) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }    
    
    /** *//**
     * 开启查询缓存，开启二级缓存
     * 
     * 开启两个session，分别调用query.list查询实体对象
     */
    public void testCache6() {
        Session session = null;
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Query query = session.createQuery("select s from Student s");
            //启用查询查询缓存
            query.setCacheable(true);
            
            List students = query.list(); 
            for (Iterator iter=students.iterator();iter.hasNext(); ) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
        
        System.out.println("-------------------------------------");
        
        try {
            session = HibernateUtils.getSession();
            session.beginTransaction();
            
            Query query = session.createQuery("select s from Student s");
            //启用查询查询缓存
            query.setCacheable(true);
            
            //不会发出查询sql，因为开启了二级缓存和查询缓存，查询缓存缓存了实体对象的id列表
            //hibernate会根据实体对象的id列表到二级缓存中取得相应的数据
            List students = query.list(); 
            for (Iterator iter=students.iterator();iter.hasNext(); ) {
                Student student = (Student)iter.next();
                System.out.println(student.getName());
            }
            session.getTransaction().commit();
        }catch(Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        }finally {
            HibernateUtils.closeSession(session);
        }
    }        
}