hibernate的查詢快取薦

CoHouse發表於2010-03-24

在hibernate的使用中，大家多數時間都在討論一級快取和二級快取，而往往忽略了查詢快取。其實hibernate的查詢快取在使用過程中也起著同樣重要的作用。hibernate的查詢快取是主要是針對普通屬性結果集的快取，而對於實體物件的結果集只快取id。在一級快取,二級快取和查詢快取都開啟的情況下作查詢操作時這樣的：查詢普通屬性，會先到查詢快取中取，如果沒有，則查詢資料庫；查詢實體，會先到查詢快取中取id，如果有，則根據id到快取(一級/二級)中取實體，如果快取中取不到實體，再查詢資料庫。

和一級/二級快取不同，查詢快取的生命週期，是不確定的，當前關聯的表發生改變時，查詢快取的生命週期結束。

     查詢快取的配置和使用也是很簡單的：
         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方法
}

2.對映檔案

Student.hbm.xml

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>

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);
    }
  }

Hibernate 查詢
2018-03-07
redis 快取 singlefly 查詢
2024-06-01
Redis快取
方法快取與查詢
2018-06-11
快取
hibernate中hql查詢
2018-11-09
hibernate查詢的方式都有哪些
2020-11-01
hibernate的三種查詢方式
2021-04-21
Hibernate-ORM:13.Hibernate中的連線查詢
2018-06-04
ORM
mysql查詢快取簡單使用
2021-03-06
MySql快取
Hibernate查詢自動更新
2019-01-19
Hibernate【快取】知識要點
2019-03-04
快取
day03-商家查詢快取02
2023-04-20
快取
Hibernate一級快取(session)與二級快取(sessionFactory)的知識點。
2018-07-17
快取Session
391、Java框架46 -【Hibernate - 查詢HQL、查詢Criteria、查詢標準SQL】 2020.10.19
2020-10-19
Java框架SQL
MySQL的查詢快取功能何時該開啟
2020-05-14
MySql快取
day02-2-商鋪查詢快取
2023-04-19
快取
微服務複雜查詢之快取策略
2021-03-15
微服務快取
如何使用Hibernate/JPA的JPQL/HQL查詢提取？
2019-02-09
Hibernate【查詢、連線池、逆向工程】
2019-03-04
Hibernate中二級快取(sessionFactory)的配置及其使用。
2018-07-17
快取Session
Hibernate 基本操作、懶載入以及快取
2023-05-17
快取
在 Linux/Unix/Mac 下清除 DNS 查詢快取
2023-11-24
LinuxMacDNS快取
Laravel Eloquent 關聯模型查詢快取資料
2020-11-15
Laravel模型快取
Hibernate5.1+Sqlserver2000分頁查詢
2021-09-09
SQLServer
hibernate異常之--count查詢異常
2020-04-04
Day64 Mybatis的多表查詢、ResultMap、註解以及快取
2018-05-02
MyBatis快取
錄取查詢
2024-07-28
直播賣貨系統，使用資料庫查詢快取
2021-07-28
資料庫快取
Laravel Passport OAuth 資料庫查詢改快取優化
2019-09-21
LaravelPassportOAuth資料庫快取優化
如何啟用Hibernate慢查詢日誌？ -Vlad Mihalcea
2020-02-26
快遞查詢 C#
2018-03-20
C#
Laravel Passport OAuth 資料庫查詢改快取最佳化
2019-09-21
LaravelPassportOAuth資料庫快取
CQengine高效能記憶體資料快取查詢框架
2020-05-20
記憶體快取框架
[20210202]計算標量子查詢快取數量2.txt
2021-02-02
快取
mybatis基礎系列（四）——關聯查詢、延遲載入、一級快取與二級快取
2018-11-17
MyBatis快取
基於快遞鳥的快遞物流查詢介面
2019-08-11
B站基於快取最佳化 PRESTO 叢集查詢效能
2023-02-13
快取REST
[20210201]19c計算標量子查詢快取數量.txt
2021-02-01
快取
如何在Hibernate/JPA的實體和查詢中使用Java 8 Optional？
2019-02-09
Java
快寶物流查詢API介面
2022-03-22
API

hibernate的查詢快取薦

相關文章