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的查詢快取和二級快取的配合使用
2017-05-21
快取
方法快取與查詢
2018-06-11
快取
mysql的查詢快取說明
2017-05-29
MySql快取
redis 快取 singlefly 查詢
2024-06-01
Redis快取
[破解]為什麼hibernate插入快，查詢慢
2009-06-05
Hibernate 查詢
2018-03-07
【hibernate】Session快取
2017-07-02
Session快取
mysql查詢快取簡單使用
2021-03-06
MySql快取
Mysql 查詢快取 query_cache
2015-01-04
MySql快取
Hibernate 的一級快取
2018-02-06
快取
Hibernate的一級快取
2006-12-03
快取
查詢快取(query_cache)的影響
2015-06-28
快取
海量資料的查詢快取問題
2012-03-07
快取
Hibernate查詢方式
2017-12-06
Hibernate——Query查詢
2015-03-14
day03-商家查詢快取02
2023-04-20
快取
MySQL查詢快取引數詳解
2016-09-08
MySql快取
Hibernate 框架的查詢方式
2018-02-03
框架
MySQL加速查詢速度的獨門武器：查詢快取(QueryCache)
2013-03-02
MySql快取
Hibernate的一級快取Session和二級快取SessionFactory
2016-09-19
快取Session
微服務複雜查詢之快取策略
2021-03-15
微服務快取
day02-2-商鋪查詢快取
2023-04-19
快取
老司機使用 Redis 快取複雜查詢
2016-04-19
Redis快取
mybatis入門基礎(八)-----查詢快取
2015-07-11
MyBatis快取
hibernate中hql查詢
2018-11-09
Hibernate hql 多表查詢
2014-11-06
Hibernate 查詢語句
2007-07-17
MySQL的查詢快取功能何時該開啟
2020-05-14
MySql快取
hibernate的三種查詢方式
2021-04-21
hibernate查詢的方式都有哪些
2020-11-01
Hibernate的查詢方式與策略
2017-03-09
hibernate的native sql查詢
2013-10-19
SQL
Hibernate的Criteria查詢問題。
2008-09-18
Hibernate中的Session快取問題
2014-11-06
Session快取
關於 Hibernate快取的問題
2005-12-13
快取
Hibernate---快取機制四(一，二級快取的比較)
2010-03-31
快取
關於分頁查詢結果的快取問題
2011-03-03
快取
Laravel Eloquent 關聯模型查詢快取資料
2020-11-15
Laravel模型快取

hibernate的查詢快取薦

相關文章