在hibernate的使用中，大家多數時間都在討論一級緩存和二級緩存，而往往忽略了查詢緩存。其實hibernate的查詢緩存在使用過程中也起着同樣重要的作用。hibernate的查詢緩存是主要是針對普通屬性結果集的緩存， 而對於實體對象的結果集只緩存id。在一級緩存,二級緩存和查詢緩存都打開的情況下作查詢操作時這樣的：查詢普通屬性，會先到查詢緩存中取，如果沒有，則查詢數據庫；查詢實體，會先到查詢緩存中取id，如果有，則根據id到緩存(一級/二級)中取實體，如果緩存中取不到實體，再查詢數據庫。
和一級/二級緩存不同，查詢緩存的生命週期 ，是不確定的，當前關聯的表發生改變時，查詢緩存的生命週期結束。
查詢緩存的配置和使用也是很簡單的：
1>查詢緩存的啓用不但要在配置文件中進行配置
<property name="hibernate.cache.use_query_cache">true</property>
2>還要在程序中顯示的進行啓用
query.setCacheable(true);
1>查詢緩存的啓用不但要在配置文件中進行配置
<property name="hibernate.cache.use_query_cache">true</property>
2>還要在程序中顯示的進行啓用
query.setCacheable(true);
1.實體類：
Student.jsva
public class Student {
private Integer id;
private String name;
//一系列的setter.getter方法
}
private Integer id;
private String name;
//一系列的setter.getter方法
}
2.映射文件
Student.hbm.xml
<class
name="com.sxt.hibernate.cache.entity.Student"
table="sxt_hibernate_student">
<!-- 指定本類的對象使用二級緩存(這也可以放在hibernate.cfg.xml中統一指定) -->
<!--
<cache usage="read-only"/>
-->
<id name="id" length="4">
<generator class="native"></generator>
</id>
<property name="name" length="10"></property>
</class>
<!-- 指定本類的對象使用二級緩存(這也可以放在hibernate.cfg.xml中統一指定) -->
<!--
<cache usage="read-only"/>
-->
<id name="id" length="4">
<generator class="native"></generator>
</id>
<property name="name" length="10"></property>
</class>
3.hibernate配置文件：
hibernate.cfg.xml
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:ORCL10</property>
<property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="hibernate.connection.username">scott</property>
<property name="hibernate.connection.password">yf123</property>
<property name="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</property>
<property name="hibernate.show_sql">true</property>
<!-- 開啓二級緩存,其實hibernate默認就是開啓的,這裏顯示的指定一下 -->
<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/sxt/hibernate/cache/entity/Student.hbm.xml"/>
<!-- 指定那些類使用二級緩存 -->
<class-cache usage="read-only" class="com.sxt.hibernate.cache.entity.Student"/>
</session-factory>
</hibernate-configuration>
<session-factory>
<property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:ORCL10</property>
<property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="hibernate.connection.username">scott</property>
<property name="hibernate.connection.password">yf123</property>
<property name="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</property>
<property name="hibernate.show_sql">true</property>
<!-- 開啓二級緩存,其實hibernate默認就是開啓的,這裏顯示的指定一下 -->
<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/sxt/hibernate/cache/entity/Student.hbm.xml"/>
<!-- 指定那些類使用二級緩存 -->
<class-cache usage="read-only" class="com.sxt.hibernate.cache.entity.Student"/>
</session-factory>
</hibernate-configuration>
4.測試方法：
public static
void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 開啓查詢緩存,關閉二級緩存, 開啓一個session,分別調用query.list
*/
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
/*
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
query.setCacheable(true);
List<String> names = query.list();
for (Iterator<String> it = names.iterator(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
System.out.println("================================");
query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
query.setCacheable(true);
//沒有發出查詢語句,因爲這裏使用的查詢緩存
names = query.list();
for (Iterator<String> it = names.iterator(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
/* @SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 開啓查詢緩存,關閉二級緩存, 開啓兩個session,分別調用query.list
*//*
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
//query.setCacheable(true);
List<String> names = query.list();
for (Iterator<String> it = names.iterator(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
//query.setCacheable(true);
//不會發出查詢語句,因爲查詢緩存和session無關.
List<String> names = query.list();
for (Iterator<String> it = names.iterator(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
/* @SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 開啓查詢緩存,關閉二級緩存, 開啓兩個session,分別調用query.iterate
*//*
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
query.setCacheable(true);
for (Iterator<String> it = query.iterate(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
query.setCacheable(true);
//會發出查詢語句,因爲query.iterate不使用查詢緩存
for (Iterator<String> it = query.iterate(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
/* @SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 關閉查詢緩存,關閉二級緩存, 開啓兩個session,分別調用query.list查詢實體對象
*//*
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
//query.setCacheable(true);
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
//query.setCacheable(true);
//會發出查詢語句,因爲list默認每次都會發出sql語句
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
/* @SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 開啓查詢緩存,關閉二級緩存, 開啓兩個session,分別調用query.list查詢實體對象
*//*
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
query.setCacheable(true);
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
query.setCacheable(true);
//會發出根據id查詢實體的n條查詢語句,因爲這種情況下,查詢過程是這樣的：
// 在第一次執行list時,會把查詢對象的id緩存到查詢緩存裏
// 第二次執行list時, 會遍歷查詢緩存裏的id到緩存裏去找實體對象,由於這裏沒找到實體對象,
//所以就發出n條查詢語句到數據庫中查詢.
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
/**
* 開啓查詢緩存,開啓二級緩存, 開啓兩個session,分別調用query.list查詢實體對象
*/
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
query.setCacheable(true);
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
query.setCacheable(true);
//不會發出查詢語句,因爲這種情況下,查詢過程是這樣的：
// 在第一次執行list時,會把查詢對象的id緩存到查詢緩存裏
// 第二次執行list時, 會遍歷查詢緩存裏的id到緩存裏去找實體對象,由於這裏開啓了二級緩存,可以找到目標實體對象,
//所以就不會再發出n條查詢語句.
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
Session session = null;
Transaction t = null;
*//**
* 開啓查詢緩存,關閉二級緩存, 開啓一個session,分別調用query.list
*/
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
/*
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
query.setCacheable(true);
List<String> names = query.list();
for (Iterator<String> it = names.iterator(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
System.out.println("================================");
query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
query.setCacheable(true);
//沒有發出查詢語句,因爲這裏使用的查詢緩存
names = query.list();
for (Iterator<String> it = names.iterator(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
/* @SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 開啓查詢緩存,關閉二級緩存, 開啓兩個session,分別調用query.list
*//*
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
//query.setCacheable(true);
List<String> names = query.list();
for (Iterator<String> it = names.iterator(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
//query.setCacheable(true);
//不會發出查詢語句,因爲查詢緩存和session無關.
List<String> names = query.list();
for (Iterator<String> it = names.iterator(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
/* @SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 開啓查詢緩存,關閉二級緩存, 開啓兩個session,分別調用query.iterate
*//*
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
query.setCacheable(true);
for (Iterator<String> it = query.iterate(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s.name from Student s");
//啓用查詢緩存
query.setCacheable(true);
//會發出查詢語句,因爲query.iterate不使用查詢緩存
for (Iterator<String> it = query.iterate(); it.hasNext();) {
String name = it.next();
System.out.println(name);
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
/* @SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 關閉查詢緩存,關閉二級緩存, 開啓兩個session,分別調用query.list查詢實體對象
*//*
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
//query.setCacheable(true);
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
//query.setCacheable(true);
//會發出查詢語句,因爲list默認每次都會發出sql語句
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
/* @SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
*//**
* 開啓查詢緩存,關閉二級緩存, 開啓兩個session,分別調用query.list查詢實體對象
*//*
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
query.setCacheable(true);
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
query.setCacheable(true);
//會發出根據id查詢實體的n條查詢語句,因爲這種情況下,查詢過程是這樣的：
// 在第一次執行list時,會把查詢對象的id緩存到查詢緩存裏
// 第二次執行list時, 會遍歷查詢緩存裏的id到緩存裏去找實體對象,由於這裏沒找到實體對象,
//所以就發出n條查詢語句到數據庫中查詢.
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}*/
@SuppressWarnings("unchecked")
public static void main(String[] args) {
Session session = null;
Transaction t = null;
/**
* 開啓查詢緩存,開啓二級緩存, 開啓兩個session,分別調用query.list查詢實體對象
*/
//如果不用查詢緩存的話,那兩個都發出查詢語句,這也是默認的情況.
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
query.setCacheable(true);
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
System.out.println("================================");
try {
session = HibernateUtils.getSession();
t = session.beginTransaction();
Query query = session.createQuery("select s from Student s");
//啓用查詢緩存
query.setCacheable(true);
//不會發出查詢語句,因爲這種情況下,查詢過程是這樣的：
// 在第一次執行list時,會把查詢對象的id緩存到查詢緩存裏
// 第二次執行list時, 會遍歷查詢緩存裏的id到緩存裏去找實體對象,由於這裏開啓了二級緩存,可以找到目標實體對象,
//所以就不會再發出n條查詢語句.
List<Student> students = query.list();
for (Iterator<Student> it = students.iterator(); it.hasNext();) {
Student s = it.next();
System.out.println(s.getName());
}
t.commit();
} catch (Exception e) {
e.printStackTrace();
t.rollback();
} finally {
HibernateUtils.closeSession(session);
}
}
本文出自 “夜狼” 博客，請務必保留此出處http://yangfei520.blog.51cto.com/1041581/287380
