hibernate 缓存机制

hibernate缓存机制是hibernate中很重要的一个内容，因为有缓存的存在，使得效率得到了很大的提升，今天这个博客，我们就来学习一个hibernate中各种查询方式对应的缓存。

缓存分为：一级缓存、二级缓存、查询缓存。

1、一级缓存：

        又称为session缓存，生命周期相同，周期较短。也称为事务级别的缓存。

下面就用项目来演示一下，缓存问题，新建一个java项目，结构如下：

实体类Book代码：

package com.myeclipse.pojo;import java.util.Date;public class Book {private int id;private String author;private String name;private double price;private Date pubDate;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getAuthor() {return author;}public void setAuthor(String author) {this.author = author;}public String getName() {return name;}public void setName(String name) {this.name = name;}public double getPrice() {return price;}public void setPrice(double price) {this.price = price;}public Date getPubDate() {return pubDate;}public void setPubDate(Date pubDate) {this.pubDate = pubDate;}@Overridepublic String toString() {return "Book [id=" + id + ", author=" + author + ", name=" + name+ ", price=" + price + ", pubDate=" + pubDate + "]";}}

Book.hbm.xml代码：

<?xml version="1.0" encoding="utf-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"><hibernate-mapping package="com.myeclipse.pojo"><class name="Book" table="t_book" lazy="false"><id name="id"><generator class="identity" /></id><property name="author" /><property name="name" column="book_name" /><property name="price" /><property name="pubDate" /></class></hibernate-mapping>

HibernateUtil代码：

package com.robert.util;import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.boot.registry.StandardServiceRegistryBuilder;import org.hibernate.cfg.Configuration;/** * hibernate工具类 */public class HibernateUtil {private static Configuration cfg = null;private static SessionFactory factory = null;private static Session session = null ;static {init();}/** * 初始化获得Configuration和SessionFacroty对象 */public static void init() {cfg = new Configuration().configure();factory = cfg.buildSessionFactory(new StandardServiceRegistryBuilder().applySettings(cfg.getProperties()).build());}/** * 获得Session对象 * @return */public static Session getSession() {if (factory != null){return session = factory.openSession();}init();return session = factory.openSession();}/** * 关闭Session */public static void closeSession() {if(session!=null && session.isOpen())session.close();}}

hibernate.cfg.xml代码：

<!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="connection.driver_class">com.mysql.jdbc.Driver</property><property name="connection.url">jdbc:mysql:///hibernate4</property><property name="connection.username">root</property><property name="connection.password">root</property><!-- 数据库方言 --><property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property><!-- 是否打印sql语句 --><property name="show_sql">true</property><!-- 格式化sql语句 --><!-- 数据库更新方式： 1、create：每次更新都先把原有数据库表删除，然后创建该表；2、create-drop:使用create-drop时，在显示关闭SessionFacroty时（sessionFactory.close()），将drop掉数据库Schema（表） 3、validate：检测；4、update（常用）：如果表不存在则创建，如果存在就不创建--><property name="hbm2ddl.auto">update</property><!-- hbm映射文件 --><mapping resource="com/myeclipse/pojo/Book.hbm.xml" /></session-factory></hibernate-configuration>

HIbernateTest测试类中，根据实体类配置文件，生成对应的数据库表的方法，

@Testpublic void testCreateDB() {Configuration cfg = new Configuration().configure();SchemaExport se = new SchemaExport(cfg);// 第一个参数：是否生成ddl脚本// 第二个参数：是否执行到数据库中se.create(true, true);}

保存数据的方法testSave(),代码：

/** * 保存数据 */@Testpublic void testSave() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = new Book();book.setName("读者");book.setPrice(5.6);book.setAuthor("众人");book.setPubDate(new Date());Book book1 = new Book();book1.setName("傲慢与偏见");book1.setPrice(80.0);book1.setAuthor("简.奥斯汀");book1.setPubDate(new Date());Book book2 = new Book();book2.setName("中国历史");book2.setPrice(30.0);book2.setAuthor("人民出版社");book2.setPubDate(new Date());Book book3 = new Book();book3.setName("翩眇之旅");book3.setPrice(70.0);book3.setAuthor("萧鼎");book3.setPubDate(new Date());Book book4 = new Book();book4.setName("蓝血人");book4.setPrice(60.0);book4.setAuthor("卫斯理");book4.setPubDate(new Date());Book book5 = new Book();book5.setName("我的大学");book5.setPrice(60.5);book5.setAuthor("高尔基");book5.setPubDate(new Date());session.save(book);session.save(book1);session.save(book2);session.save(book3);session.save(book4);session.save(book5);tx.commit();HibernateUtil.closeSession();}

接下来就是测试各种查询的缓存问题

1）get方法，

测试代码如下：

/** * get方法使用了一级缓存，用get查数据时，首先检查缓存中是否有该数据， * 如果有，直接从缓存中获取数据；如果没有，再去数据库查数据，然后将数据放入缓存中 */@Testpublic void testGet() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.get(Book.class, 1);// 发出sql语句，取数据System.out.println(book.getName());System.out.println("-----------------------------------------");book = (Book) session.get(Book.class, 1);System.out.println(book.getName());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句如下：

Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?读者-----------------------------------------读者

由上面可以看出：

get方法使用了一级缓存，用get查数据时，首先检查缓存中是否有该数据，

如果有，直接从缓存中获取数据；如果没有，再去数据库查数据，然后将数据放入缓存中

2）load方法，

测试代码如下：

/** * load方法使用了一级缓存，用load查数据时，首先检查缓存中是否有该数据， * 如果有，直接从缓存中获取数据；如果没有，再去数据库查数据，然后将数据放入缓存中. load还支持lazy。 */@Testpublic void testLoad() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.load(Book.class, 1);// 发出sql语句，取数据System.out.println(book.getName());System.out.println("-----------------------------------------");book = (Book) session.load(Book.class, 1);System.out.println(book.getName());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句如下：

Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?读者-----------------------------------------读者

总结：

* load方法使用了一级缓存，用load查数据时，首先检查缓存中是否有该数据，
* 如果有，直接从缓存中获取数据；如果没有，再去数据库查数据，然后将数据放入缓存中. load还支持lazy。

3）先get，后load，

测试代码：

/** * 先用get，再用load，load同样从一级缓存中查数据，如果有数据，就不去数据库查语句了。 */@Testpublic void testGetLoad() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.get(Book.class, 1);// 发出sql语句，取数据System.out.println(book.getName());System.out.println("-----------------------------------------");book = (Book) session.load(Book.class, 1);// 如果这里使用了session.close()方法，关闭session，那么session就没有缓存的数据了，就会重新发出sql语句，去数据库查数据。System.out.println(book.getName());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句如下：

Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?读者-----------------------------------------读者

总结：

先用get，再用load，load同样从一级缓存中查数据，如果有数据，就不去数据库查语句了。

4）list方法，

测试代码如下：

/** * list 查数据不去缓存中查数据，但是list查出来的 ‘实体对象’ 数据，会放入缓存中。 */@Testpublic void testList() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();List<Book> list = session.createQuery("from Book").list();// 发出sql语句，取数据System.out.println("条数：" + list.size());System.out.println("-----------------------------------------");list = session.createQuery("from Book").list();System.out.println("条数：" + list.size());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句如下：

Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_条数：6-----------------------------------------Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_条数：6

总结：

list 查数据不去缓存中查数据，但是list查出来的 ‘实体对象’ 数据，会放入缓存中。

5）先list，再get，

测试代码：

/** * 先用list查，list查出来的 ‘实体对象’ 数据，放入缓存中。 然后用get查，get直接去缓存中查数据。 */@Testpublic void testListGet() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();List<Book> list = session.createQuery("from Book").list();// 发出sql语句，取数据System.out.println("条数：" + list.size());System.out.println("-----------------------------------------");Book book = (Book) session.get(Book.class, 2);System.out.println("书名：" + book.getName());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句：

Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_条数：6-----------------------------------------书名：傲慢与偏见

总结：

先用list查，list查出来的 ‘实体对象’ 数据，放入缓存中。 然后用get查，get直接去缓存中查数据。

6）先list ，后uniqueResult，

测试代码：

@Testpublic void testListUniqueResult() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();//这里list查询出来的不是 ‘实体对象’ ，所以这些数据不会存入缓存中//（备注：list查询出来的，只有当是 ‘实体对象’ 时，才会被存入缓存中）List<String> list = session.createQuery("select name from Book").list();// 发出sql语句，取数据System.out.println("条数：" + list.size());System.out.println("-----------------------------------------");Object bookName = session.createQuery("select name from Book where id =:id ").setInteger("id", 2).uniqueResult();//发出sql语句，取数据System.out.println("书名："+bookName);tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句如下：

Hibernate:     select        book0_.book_name as col_0_0_     from        t_book book0_条数：6-----------------------------------------Hibernate:     select        book0_.book_name as col_0_0_     from        t_book book0_     where        book0_.id=?书名：傲慢与偏见

总结：

  这里list查询出来的不是 ‘实体对象’ ，所以这些数据不会存入缓存中
（备注：list查询出来的，只有当是 ‘实体对象’ 时，才会被存入缓存中）

7）uniqueResult测试，

代码：

@Testpublic void testUnique() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.createQuery("from Book where id =:id ").setInteger("id", 2).uniqueResult();//发出sql语句，取数据System.out.println("书名："+book.getName());System.out.println("------------------------------------------");book = (Book) session.createQuery("from Book where id =:id ").setInteger("id", 2).uniqueResult();//发出sql语句，取数据System.out.println("书名："+book.getName());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句，如下：

Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_     where        book0_.id=?书名：傲慢与偏见------------------------------------------Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_     where        book0_.id=?书名：傲慢与偏见

总结：

uniqueResult 不会去缓存中查询数据

8）先uniqueResult，后get，

测试代码：

/** * unique 将 ‘实体对象’ 数据放入了 缓存中，get方法从缓存中把实体类对象取出。 * 但是unique不会去缓存中查数据 */@Testpublic void testUniqueGet() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.createQuery("from Book where id =:id ").setInteger("id", 2).uniqueResult();//发出sql语句，取数据System.out.println("书名："+book.getName());System.out.println("------------------------------------------");book = (Book) session.get(Book.class, 2) ;System.out.println("书名："+book.getName());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句如下：

Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_     where        book0_.id=?书名：傲慢与偏见------------------------------------------书名：傲慢与偏见

总结：

* unique 将 ‘实体对象’ 数据放入了 缓存中，get方法从缓存中把实体类对象取出。
* 但是unique不会去缓存中查数据

9）先list ，在iterator，

测试代码：

/** * iterator使用了缓存 */@Testpublic void testIterator() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();List<Book> list = session.createQuery("from Book").list();// 发出sql语句，取数据System.out.println("条数：" + list.size());System.out.println("-----------------------------------------");Iterator<Book> iter = session.createQuery("from Book").iterate();for(;iter.hasNext();) {Book book = iter.next() ;System.out.println("书名："+book.getName());}tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句：

Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_条数：6-----------------------------------------Hibernate:     select        book0_.id as col_0_0_     from        t_book book0_书名：读者书名：傲慢与偏见书名：中国历史书名：翩眇之旅书名：蓝血人书名：我的大学

iterator只查询了id，并没有查询实体类，

总结：

iterator使用了缓存

10）查询两次iterator，

测试代码：

/** * iterator 查询出来的 ‘实体对象’ 数据会放入缓存中，需要数据时，先到缓存中查询 */@Testpublic void testIteratorTow() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Iterator<Book> iter = session.createQuery("from Book").iterate();// 发出sql语句，取数据for(;iter.hasNext();) {Book book = iter.next() ;System.out.println("书名："+book.getName());}System.out.println("-----------------------------------------");iter = session.createQuery("from Book").iterate();for(;iter.hasNext();) {Book book = iter.next() ;System.out.println("书名："+book.getName());}tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句：

Hibernate:     select        book0_.id as col_0_0_     from        t_book book0_Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?书名：读者Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?书名：傲慢与偏见Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?书名：中国历史Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?书名：翩眇之旅Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?书名：蓝血人Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?书名：我的大学-----------------------------------------Hibernate:     select        book0_.id as col_0_0_     from        t_book book0_书名：读者书名：傲慢与偏见书名：中国历史书名：翩眇之旅书名：蓝血人书名：我的大学

总结：

iterator 查询出来的 ‘实体对象’ 数据会放入缓存中，需要数据时，先到缓存中查询

管理一级缓存：

flush：强制将数据存入数据库表中；

clear：关闭session；

evict：将对象从当前的session中清除；

一级缓存很难管理，我们不一定知道，什么时候该flush，clear，evict，如果需要实时性很强的数据，一般不用hibernate。

flush代码：

/** * 批量保存数据 */@Testpublic void testSaveBache() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();for(int i=0;i<10000;i++) {Book book = new Book();book.setName("测试_"+i);book.setPrice(5.6);book.setAuthor("作者_"+i);book.setPubDate(new Date());if (i%100==0) {//防止数据量过大，导致session缓存崩溃，强制将数据从session缓存中刷入数据库，清空session中存的数据session.flush() ;}session.save(book);}tx.commit();HibernateUtil.closeSession();}

evict代码：

@Testpublic void testEvict() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.get(Book.class, 1) ;//发出sql语句System.out.println(book.getName());//将book对象从session缓存中清除session.evict(book);System.out.println("----------------------------");book = (Book) session.get(Book.class, 1) ;//缓存中没有了book实体对象数据，需要重新发出sql语句查询System.out.println(book.getName());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句

Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?读者----------------------------Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?读者

clear将缓存清空，代码：

@Testpublic void testClear() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.get(Book.class, 1) ;//发出sql语句System.out.println(book.getName());//清空缓存session.clear() ;System.out.println("----------------------------");book = (Book) session.get(Book.class, 1) ;//缓存中没有了book实体对象数据，需要重新发出sql语句查询System.out.println(book.getName());tx.commit();HibernateUtil.closeSession();}

控制台打印的sql语句：

Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?读者----------------------------Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?读者

2、二级缓存

sessionFactory：进程级别的缓存，支持集群。

二级缓存使用个步骤：

1）、先在hibernate.cfg.xml中开启二级缓存（默认是开启）

代码如下：

<!-- 使用二级缓存 --><property name="cache.use_second_level_cache">true</property>

如图：

2）、配置二级缓存提供商cache.provider_class

<!-- 使用EHCache --><property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

来源于下图：

3）、导入ehcache.jar包

找到hibernate文件地址hibernate-release-4.3.11.Final\lib\optional\ehcache，里面有对应的jar包，如图：

将这三个jar包拷贝到项目中，

因为有slf4j-api-1.6.1.jar包，所以需要将slf4j的实现包也导入项目，实现包下载地址《slf4j-simple-1.7.25.jar》，

导入后的jar包如下

4）、将ehcache的配置文件放入src下

ehcache配置文件的地址是 hibernate-release-4.3.11.Final\project\etc

如图：

项目中的位置如图：

ehcache.xml中部分属性的含义如图：

5）、在*.hbm.xml或在hibernate.cfg.xml中指定二级缓存策略

  1）该项目中在Book.hbm.xml中增加配置，如图

     2）在hibernate.cfg.xml中指定，如图：

6）、测试

测试代码如下：

/** * 二级缓存 */@Testpublic void testGet_secondCache() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.get(Book.class, 1);// 发出sql语句，取数据System.out.println(book.getName());HibernateUtil.closeSession();System.out.println("-----------------------------------------");session = HibernateUtil.getSession();book = (Book) session.get(Book.class, 1);System.out.println(book.getName());tx.commit();HibernateUtil.closeSession();}

运行junit4报错了，错误如下：

调整hibernate.cfg.xml中的配置顺序，调整之后如图：

再次运行junit4，仍然报错，如下：

去查找文档，文档地址：hibernate-release-4.3.11.Final\documentation\manual\en-US\html

打开index.html，找到The Second Level Cache，如图：

发现文档中的EHCache是这样的：

EHCacheorg.hibernate.cache.ehcache.EhCacheRegionFactory

而我们在hibernate.cfg.xml中配置的是这样的

<!-- 使用EHCache --><property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

补充：现在配置的这个EHCache是hibernate3中的配置方式，在hibernate4中已经变了。

将这个属性值，重新修改为

org.hibernate.cache.ehcache.EhCacheRegionFactory

同时注意在错误提示中property名称也不是cache.provider_class了，而是错误提示中的，如图：

修改后，如图：

我们重新来看一下测试代码：

/** * 二级缓存 */@Testpublic void testGet_secondCache() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();Book book = (Book) session.get(Book.class, 1);// 发出sql语句，取数据System.out.println(book.getName());//关闭sessionHibernateUtil.closeSession();System.out.println("-----------------------------------------");//重新获得sessionsession = HibernateUtil.getSession();book = (Book) session.get(Book.class, 1);System.out.println(book.getName());tx.commit();HibernateUtil.closeSession();}

运行后，控制台打印sql语句如下：

Hibernate:     select        book0_.id as id1_0_0_,        book0_.author as author2_0_0_,        book0_.book_name as book_nam3_0_0_,        book0_.price as price4_0_0_,        book0_.pubDate as pubDate5_0_0_     from        t_book book0_     where        book0_.id=?读者-----------------------------------------读者

虽然我们关闭了session，又重新获得了一个session，但是获取第二个数据时，并没有去数据库查询数据，说明二级缓存起作用了。

3、查询缓存

查询缓存是在二级缓存的基础上设置的，也就是说要使用查询缓存，我们需要先把二级缓存配置好，然后再配置查询缓存。

 1）配置查询缓存

2）编写测试代码：

/** * 查询缓存 */@Testpublic void testQueryCache() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();//setCacheable(true)表示设置查询缓存List<Book> list = session.createQuery("from Book ").setCacheable(true).list() ;// 发出sql语句，取数据System.out.println(list.size());System.out.println("-----------------------------------------");//setCacheable(true)表示设置查询缓存list = session.createQuery("from Book ").setCacheable(true).list() ;// 发出sql语句，取数据System.out.println(list.size());tx.commit();HibernateUtil.closeSession();}

控制台打印sql语句

Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_[net.sf.ehcache.CacheManager@44739f3f] INFO net.sf.ehcache.util.UpdateChecker - New update(s) found: 2.4.7 [http://www.terracotta.org/confluence/display/release/Release+Notes+Ehcache+Core+2.4]. Please check http://ehcache.org for the latest version.10006-----------------------------------------10006

说明查询缓存起作用了。

将session关闭看一下时候仍然可以从二级缓存中使用查询缓存取出数据

测试代码：

/** * 测试关闭session的查询缓存 */@Testpublic void testQueryCacheClose() {Session session = HibernateUtil.getSession();Transaction tx = session.beginTransaction();//setCacheable(true)表示设置查询缓存List<Book> list = session.createQuery("from Book ").setCacheable(true).list() ;// 发出sql语句，取数据System.out.println(list.size());session.close() ;session = HibernateUtil.getSession() ;System.out.println("-----------------------------------------");//setCacheable(true)表示设置查询缓存list = session.createQuery("from Book ").setCacheable(true).list() ;// 发出sql语句，取数据System.out.println(list.size());tx.commit();HibernateUtil.closeSession();}

测试，控制台打印sql语句：

Hibernate:     select        book0_.id as id1_0_,        book0_.author as author2_0_,        book0_.book_name as book_nam3_0_,        book0_.price as price4_0_,        book0_.pubDate as pubDate5_0_     from        t_book book0_[net.sf.ehcache.CacheManager@370a5c21] INFO net.sf.ehcache.util.UpdateChecker - New update(s) found: 2.4.7 [http://www.terracotta.org/confluence/display/release/Release+Notes+Ehcache+Core+2.4]. Please check http://ehcache.org for the latest version.10006-----------------------------------------10006

说明数据确实是存在了二级缓存中，关闭session并不影响查询数据。