hibernate查询缓存

【hibernate查询缓存】
 一级与二级缓存只能缓存实体对象，查询缓存可以缓存查询的结果集，即可以缓存普通的属性.
注意：只有经常使用同样参数的查询才能获得好处，查询缓存的生命周期直到属性被修改了为止

 注意：查询缓存对实体对象的结果集只缓存id
 
   查询缓存的配置与使用：
     <!-- 开启查询缓存，默认是关闭的 -->
  <property name="hibernate.cache.use_query_cache">true</property>
 在程序中应开启：
  Query query = session.createQuery("select s.name from Student s");
  query.setCacheable(true);//开启查询缓存

 

package myHibernate;

import java.io.Serializable;
import java.util.Iterator;
import java.util.List;

import myHibernate.HibernateUtils;
import myHibernate.Student;

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

import junit.framework.TestCase;
/**
 * 2010年4月23日 21:26:17
 * 查询缓存测试
 * */
public class QueryCacheTest extends TestCase {

 public void testCache1() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   Query query = session.createQuery("select s.name from Student s");
   query.setCacheable(false);
   
   List names = query.list();
   for(Iterator iter = names.iterator();iter.hasNext();){
    String name = (String) iter.next();
    System.out.println(name);
   }
   System.out.println("-------------------------");
   //会发出SQL语句，因为没有使用查询缓存
      query = session.createQuery("select s.name from Student s");
   query.setCacheable(false);
   
   names = query.list();
   for(Iterator iter = names.iterator();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用 list进行查询
 public void testCache2() {
  Session session = null;
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   
   Query query = session.createQuery("select s.name from Student s");
   query.setCacheable(true);
   
   List names = query.list();
   for(Iterator iter = names.iterator();iter.hasNext();){
    String name = (String) iter.next();
    System.out.println(name);
   }
   System.out.println("-------------------------");
   //不会会发出SQL语句，因为启用查询缓存
      query = session.createQuery("select s.name from Student s");
      //启用了查询缓存
   query.setCacheable(true);
   
   names = query.list();
   for(Iterator iter = names.iterator();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用 list进行查询
  * */
 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);
   
   List names = query.list();
   for(Iterator iter = names.iterator();iter.hasNext();){
    String name = (String) iter.next();
    System.out.println(name);
   }
   System.out.println("-------------------------");
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
  //第二个session
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   //不会发出SQL语句，因为查询缓存与session无关，可以跨session
   Query query = session.createQuery("select s.name from Student s");
   query.setCacheable(true);
   
   List names = query.list();
   for(Iterator iter = names.iterator();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);
  }
 }
 
//开启查询缓存，但这次使用的不是query的list接口而是iterate接口
 public void testCache4() {
  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);
   }
   System.out.println("-------------------------");
   //会发出SQL语句，因为查询缓存只对query.list()起作用，也就是query.iterate()不使用查询缓存
   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);
  }
 }
 //开启查询缓存，关闭二级缓存，跨session查询实体对象
 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 s = (Student) iter.next();
    System.out.println(s.getName());
   }
   System.out.println("-------------------------");
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
  //第二个session
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   //会发出N条查询语句，因为查询缓存会缓存实体对象的id,所以hibernate会根据实体对象
   //的id去查询对应的实体，如果缓存中不存在对应的实体那么会根据实体的id去查询实体，
   //如果有相应的实体则不会发出sql
   Query query = session.createQuery("select s from Student s");
   query.setCacheable(true);
   List students = query.list();
   for(Iterator iter = students.iterator();iter.hasNext();){
    Student s = (Student) iter.next();
    System.out.println(s.getName());
   }
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 }
 
 //开启查询缓存，开启二级缓存，跨session查询实体对象
 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 s = (Student) iter.next();
    System.out.println(s.getName());
   }
   System.out.println("-------------------------");
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
  //第二个session
  try {
   session = HibernateUtils.getSession();
   session.beginTransaction();
   //不会发出sql，因为开启了二级缓存，查询缓存缓存了实体对象的id
   //hibernate会根据实体对象的id列表到二级缓存中取得相应的数据
   Query query = session.createQuery("select s from Student s");
   query.setCacheable(true);
   List students = query.list();
   for(Iterator iter = students.iterator();iter.hasNext();){
    Student s = (Student) iter.next();
    System.out.println(s.getName());
   }
   session.getTransaction().commit();
  }catch(Exception e) {
   e.printStackTrace();
   session.getTransaction().rollback();
  }finally {
   HibernateUtils.closeSession(session);
  }
 }
}