2. 程式人生 > >hibernate一級快取詳解

hibernate一級快取詳解

阿新 • • 發佈：2019-01-30

一級快取的生命週期和session的生命週期一致，當前sessioin一旦關閉，一級快取就消失，session間不能共享一級快取的資料，因此一級快取也叫session級的快取或事務級快取。一級快取只存實體物件的 ，它不會快取一般的物件屬性（查詢快取可以），即當獲得物件後，就將該物件的快取起來，如果在同一session中如果再去獲取這個物件時，它會先判斷快取中有沒有該物件的id，如果有就直接從快取中取出，反之則去資料庫中取，取的同時將該物件的快取起來，有以下方法可以支援一級快取：
•get()
•save()
•load()
•iterate（查詢實體物件）

Query和Criteria的list()和uniqueResult()只會寫快取，但不會從快取中讀取（除非結合查詢快取）。一級快取無法取消，但可以管理，可以使用session.clear()、session.evict()清除或驅逐。

以下對hibernate的一級快取進行程式碼測試：hibernate.cfg.xml配置：

 
<hibernate-configuration> 
  <session-factory> 
    <property name="hibernate.connection.url"> jdbc:mysql://localhost/hibernate_testcache </property>
    <property name="hibernate.connection.driver_class"> com.mysql.jdbc.Driver</property> 
    <property name="hibernate.connection.username">root</property>
    <property name="hibernate.connection.password">root</property> 
    <property name="hibernate.dialect"> org.hibernate.dialect.MySQLDialect </property> 
    <property name="hibernate.show_sql">true</property> 
    <mapping resource="com/sunyzc/hibernate/testcache/User.hbm.xml"/>
  </session-factory>
</hibernate-configuration>

實體Bean：User.java
package

com.sunyzc.hibernate.testcache; 
 

public class User {

  private int id;
 
  private String name;

 
  //getters、setters


}

User.hbm.xml
 
<?xml version="1.0"?>
 
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd

">

<hibernate-mapping>

  <class name="com.sunyzc.hibernate.testcache.User" table="t_user">

    <id name="id">
 
      <generator class="native"/>

    </id>

    <property name="name" column="name" type="java.lang.String"/>
 
  </class>

 
</hibernate-mapping>

建立表的工具：ExportDB.java


package com.sunyzc.hibernate.testcache;

 
import org.hibernate.cfg.Configuration;
 
import org.hibernate.tool.hbm2ddl.SchemaExport;


public class ExportDB {


 
  public static  void main(String[] args) {


    //讀取hibernate.cfg.xml檔案

    Configuration cfg = new Configuration().configure();
 
    SchemaExportexport = new SchemaExport(cfg);

    export.create(true,true); 
  }
 
}

HibernateUtils.java


 
package com.sunyzc.hibernate.testcache;


 
import org.hibernate.Session;
 
import org.hibernate.SessionFactory;
 
import org.hibernate.cfg.Configuration;


 
public class HibernateUtils {
 
  private static SessionFactory factory;


  static{
 
    try{
 
      factory = new Configuration().configure().buildSessionFactory();
 
    }catch(Exception e) {
 
      e.printStackTrace(); 
    } 
  }


 
  public static Session getSession() {

    return factory.openSession(); 
  }


 
  public static void closeSession(Session session) {
 
    if(session != null&& session.isOpen()) { 
      session.close(); 
    }
  }
}

測試1：在同一個session中發出兩次load查詢


public void testCache1() {

  Session session = null;
 
  try{
 
    session= HibernateUtils.getSession();
    session.beginTransaction();
    User user = (User) session.load(User.class,1);
    System.out.println("user.name="+ user.getName());

    //不會發出sql，因為load使用快取 
    user= (User) session.load(User.class,1);
 
    System.out.println("user.name="+ user.getName());
 
    session.getTransaction().commit(); 
  }catch(Exception e) {
 
    e.printStackTrace(); 
    session.getTransaction().rollback(); 
  }
finally

{ 
    HibernateUtils.closeSession(session);
 
  }
 
}

輸出結果：


Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user.name=user0
 user.name=user0


測試2：在同一個session中發出兩次get查詢

public void testCache2() {
 
  Session session = null; 
  try{
    session= HibernateUtils.getSession();
 
    session.beginTransaction();
 
    User user = (User) session.get(User.class,1);
 
    System.out.println("user.name="+ user.getName());

    //不會發出sql，因為get使用快取
 
    user = (User) session.get(User.class,1);
 
    System.out.println("user.name="+ user.getName());
 
    session.getTransaction().commit();
 
  }catch(Exception e) {
 
    e.printStackTrace();
 
    session.getTransaction().rollback(); 
  }finally{
 
    HibernateUtils.closeSession(session);

  }
 
}

輸出結果：


Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user.name=user0
 user.name=user0

測試3：在同一個session中發出兩次iterate查詢實體物件

public void testCache3() {
 
  Session session = null; 
  try{
    session= HibernateUtils.getSession();
    session.beginTransaction(); 
    String hql = "from User u where u.id=1"; 
    User user = (User) session.createQuery(hql).iterate().next(); 
    System.out.println("user.name="+ user.getName());

    //會發出查詢id的sql，不會發出查詢實體物件的sql，因為iterate使用快取

    user= (User) session.createQuery(hql).iterate().next();

    System.out.println("user.name="+ user.getName());
 
    session.getTransaction().commit(); 
  }catch(Exception e) {
 
    e.printStackTrace();

    session.getTransaction().rollback(); 
  }finally{
 
    HibernateUtils.closeSession(session);
 
  }
 
}

輸出結果：


 Hibernate: select user0_.id as col_0_0_ from t_user user0_ where user0_.id=1
 Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user.name=user0
 Hibernate: select user0_.id as col_0_0_ from t_user user0_ where user0_.id=1
 user.name=user0

測試4：在通一個session中發出兩次uniqueResult查詢實體物件不會快取，如果第一次用uniqueResult 第二次用iterate查詢是會快取的


 
public void testCache4() {
 
  Session session = null;
 
  try{
    session = HibernateUtils.getSession();
 
    session.beginTransaction();
 
    String hql = "from User u where u.id=1";
 
    User user = (User) session.createQuery(hql).uniqueResult();
 
    System.out.println("user.name="+ user.getName());
 
    user= (User) session.createQuery(hql).uniqueResult();
 
    System.out.println("user.name="+ user.getName());
 
    session.getTransaction().commit();
 
  }catch(Exception e) {

    e.printStackTrace();
    session.getTransaction().rollback(); 
  }finally{

    HibernateUtils.closeSession(session);
 
  }


18
}

輸出結果：


 Hibernate: select user0_.id as id0_, user0_.name as name0_ from t_user user0_ where user0_.id=1
 user.name=user0
 Hibernate: select user0_.id as id0_, user0_.name as name0_ from t_user user0_ where user0_.id=1
 user.name=user0

測試5：在同一個session中發出兩次list查詢實體物件不會快取


public void testCache4() {
 
  Session session = null; 
  try{ 
    session= HibernateUtils.getSession(); 
    session.beginTransaction();
    List list = session.createQuery("from User u").list();
 
    System.out.println("user.name="+ list.get(0).getName());
 
    list= session.createQuery("from User u").list();
 
    System.out.println("user.name="+ list.get(0).getName()); 
    session.getTransaction().commit();
 
  }catch(Exception e) {
 
    e.printStackTrace(); 
    session.getTransaction().rollback(); 
  }finally{

    HibernateUtils.closeSession(session);
 
  }
 
}

輸出結果：


 Hibernate: select user0_.id as id0_, user0_.name as name0_ from t_user user0_
 user.name=user0
 Hibernate: select user0_.id as id0_, user0_.name as name0_ from t_user user0_
 user.name=user0

測試6：在同一個session中發出兩次iterate查詢普通屬性不會快取

 
public void testCache4() {

  Session session = null;
 
  try{ 
    session= HibernateUtils.getSession();

    session.beginTransaction();
 
    String hql = "select u.name from User u where u.id=1";
 
    String name = (String) session.createQuery(hql).iterate().next();

    System.out.println("user.name="+ name);
 
    //iterate查詢普通屬性，一級快取不會快取，所以發出sql
 
    //一級快取是快取實體物件的
 
    name = (String) session.createQuery(hql).iterate().next();
 
    System.out.println("user.name="+ name);
 
    session.getTransaction().commit(); 
  }catch(Exception e) {
 
    e.printStackTrace();
 
    session.getTransaction().rollback();
 
  }finally{
 
    HibernateUtils.closeSession(session);
 
  }
 
}

輸出結果：


 Hibernate: select user0_.name as col_0_0_ from t_user user0_ where user0_.id=1
 user.name=user0
 Hibernate: select user0_.name as col_0_0_ from t_user user0_ where user0_.id=1
 user.name=user0

測試7：開啟兩個session中發出load查詢
 
public void testCache7() {
 
  Session session1 = null; 
  Session session2 = null; 
  try{
 
    session1 = HibernateUtils.getSession();
 
    session2 = HibernateUtils.getSession();
 
    session1.beginTransaction();

    session2.beginTransaction();
  
    User user1 = (User) session1.load(User.class,1);
 
    System.out.println("user1.name="+ user1.getName());
 
    //會發出查詢語句，session間不能共享一級快取的資料
 
    //因為它會伴隨session的生命週期存在和消亡
 
    User user2 = (User) session2.load(User.class,1);

    System.out.println("user2.name="+ user2.getName());
 
    session1.getTransaction().commit();
 
    session2.getTransaction().commit(); 
  }catch(Exception e) {
    e.printStackTrace();
    session1.getTransaction().rollback();
    session2.getTransaction().rollback();
  }finally{
 
    HibernateUtils.closeSession(session1);
 
    HibernateUtils.closeSession(session2);
 
  }
 
}

輸出結果：


 Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user1.name=user0
 Hibernate: select user0_.id as id0_0_, user0_.name as name0_0_ from t_user user0_ where user0_.id=?
 user2.name=user0

測試8：在同一個session中先save，再發出load查詢save過的資料

 
public void testCache8() {
 
  Session session = null; 
  try{ 
    session= HibernateUtils.getSession();
    session.beginTransaction(); 
    User u = new User(); 
    u.setName("張三"); 
    Serializable id = session.save(u); 
    //不會發出sql，因為save是使用快取的 
    User user = (User) session.load(User.class,id);
    System.out.println("user.name="+ user.getName());
    session.getTransaction().commit(); 
  }catch(Exception e) { 
    e.printStackTrace(); 
    session.getTransaction().rollback(); 
  }finally{
 
    HibernateUtils.closeSession(session);

  } 
}

輸出結果：

 Hibernate: insert into t_user (name) values (?)
 user.name=張三

如何避免一次性大量的實體資料入庫導致記憶體溢位？

先flush()，再clear()。 save方法會將save的物件放入一級快取中，如果要save大批物件，則應該要及時清空一級快取，可以採用Session的clear()方法。若不清理快取，可發現javaw程序佔用記憶體持續增長，到一定程度會記憶體溢位的。如果資料量特別大，考慮採用jdbc實現，如果jdbc也不能滿足要求可以考慮採用資料本身的特定匯入工具。

測試9：向資料庫中批量加入1000條資料

 
public void testCache9() {

Session session = null;
 
  try{ 
    session = HibernateUtils.getSession(); 
    session.beginTransaction();

    for(int i = 0;i < 1000; i++) {
 
      User user = new User();
 
      user.setName("user"+ i);

      session.save(user);

      //每20條資料就強制session將資料持久化
 
      //同時清除快取，避免大量資料造成記憶體溢位
 
      if(i % 20== 0){
        session.flush();
        session.clear();
      }
 
    } 
    session.getTransaction().commit(); 
  }catch(Exception e) {

    e.printStackTrace(); 
    session.getTransaction().rollback(); 
  }finally{
 
    HibernateUtils.closeSession(session);
 
  }
 
}
 
 
 

相關推薦

hibernate一級快取詳解

一級快取的生命週期和session的生命週期一致，當前sessioin一旦關閉，一級快取就消失，session間不能共享一級快取的資料，因此一級快取也叫session級的快取或事務級快取。一級快取只存

JAVAWEB開發之Hibernate詳解（二）——Hibernate的持久化類狀態與轉換、以及一級快取詳解、關聯關係的對映（一對多、多對多、級聯）

package cn.test.hibernate3.demo2; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import cn.test.hibernate3.demo2.

Hibernate之快取詳解

Hibernate中提供了兩級快取，一級快取是Session級別的快取，它屬於事務範圍的快取，該級快取由hibernate管理，應用程式無需干預；二級快取是SessionFactory級別的快取，該級快取可以進行配置和更改，並且可以動態載入和解除安裝，hibernate還為查詢結果提供了一個查詢快取

Java程式設計師從笨鳥到菜鳥之（七十七）細談Hibernate（十九）Hibernate二級快取詳解

歡迎關注微信賬號：java那些事：csh624366188.每天一篇java相關的文章 java交流工作群1: 77800592（已滿） java交流學生群2：234897635（已滿） java交流工作群3：94507287 java交流工作群4: 272265434 我的郵箱：

cpu二級快取和一級快取詳解及區別(圖解)

　　錯誤觀點二：處理器快取是一個整體 【圖】生產技術對快取容量大小的影響 【圖】PCB上帶快取的PentiumIII處理器 　　事實上最早先的CPU快取確實是個整體，而且容量也很低。英特爾公司從Pentium時代開始後就把快取進行了分類，當時整合在CPU核心中的快取已不足以滿足CPU的需求，而製造工藝上

java Hibernate一級快取和二級快取概念案例詳解

　　一、一級快取二級快取的概念解釋 　　(1)一級快取就是Session級別的快取，一個Session做了一個查詢操作，它會把這個操作的結果放在一級快取中，如果短時間內這個 　　session(一定要同一個session)又做了同一個操作，那麼hibernate直接從一級快

Hibernate一級快取和二級快取詳解

一、一級快取二級快取的概念解釋 （1）一級快取就是Session級別的快取，一個Session做了一個查詢操作，它會把這個操作的結果放在一級快取中，如果短時間內這個 session（一定要同一個se

MyBatis一級快取和二級快取詳解

一級快取 　　Mybatis對快取提供支援，但是在沒有配置的預設情況下，它只開啟一級快取，一級快取只是相對於同一個SqlSession而言。所以在引數和SQL完全一樣的情況下，我們使用同一個SqlSession物件呼叫一個Mapper方法，往往只執行一次SQL，因為使用SelSession第一次

Mybatis的一級快取和二級快取詳解

注：本筆記是根據尚矽谷的MyBatis視訊記錄的 對於任何一個持久層框架，都有快取機制；快取在電腦中有一塊真實的儲存空間（https://baike.baidu.com/item/%E7%BC%93%E5%AD%98/100710?fr=aladdin）； 兩個關於mybatis快取額外的連

MyBatis(七):MyBatis快取詳解(一級快取/二級快取)

1. 一級快取 ​ MyBatis一級快取上SqlSession快取，即在統一SqlSession中，在不執行增刪改操作提交事務的前提下，對同一條資料進行多次查詢時，第一次查詢從資料庫中查詢，完成後會存入快取，其餘從快取中直接讀取。MyBatis一級快取預設開啟。 ![](https://i

Hibernate學習（2）- hibernate.cfg.xml詳解

source nec cfg 更新 閱讀 username 詳解 格式化sql BE 1：主配置文件主要分為三部分：　　　　註意：通常情況下，一個session-factory節點代表一個數據庫；　　　　1.1：第一部分　　　　　　　數據庫連接部分，註意"hibernate

Hibernate基礎知識詳解

seq 每次 事務 name rep cfg 默認 poj 產生 一、Hibernate框架 Hibernate是一個開放源代碼的對象關系映射框架，它對 JDBC進行了非常輕量級的對象封裝，它將POJO類與數據庫表建立映射關系，是一個 全自動的ORM框架

Hibernate的session詳解

有一個 ans 默認值 ola Opens bubuko 配置文件 update 映射 一、hibernate的session介紹 Session 具有一個緩存, 位於緩存中的對象稱為持久化對象, 它和數據庫中的相關記錄對應。Session 能夠在某些時間點, 按照緩存中對

Hibernate ---核心配置檔案(Hibernate.cfg.xml)詳解

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC     "-//Hibernate/Hibernate Configuration DTD

Hibernate----一級快取

1.  快取:Hibernate中也存在快取. Hibernate中存在的快取也是用來提高效率. 2.  Hibernate中存在兩種快取:               

Hibernate----一級快取 細節部分

package com.itheima.b_cache; import java.util.List; import org.hibernate.Session; import org.junit.Test; import com.itheima.domain.User; import

Hibernate懶載入詳解

兩邊關於hibernate懶載入的文章，轉過來收藏 轉自：https://www.cnblogs.com/cornucopia/articles/4541621.html 轉自：https://yq.aliyun.com/ziliao/281376     H

Yii2頁面快取詳解

頁面快取指的是在伺服器端快取整個頁面的內容。隨後當同一個頁面 被請求時，內容將從快取中取出，而不是重新生成。 舉例說明 class TestController extends Controller{     // 該方法會在其他方法之前執行   

Hibernate持久化類詳解

2 Hibernate持久化類詳解 上接Hibernate入門學習：https://blog.csdn.net/biggerchong/article/details/84229658  目錄 2 Hibernate持久化類詳解 2.1持久化類的編寫規

MySQL查詢快取詳解

參考文件：https://www.cnblogs.com/Alight/p/3981999.html 一：快取條件，原理 MySQL Query Cache是用來快取我們所執行的SELECT語句以及該語句的結果集，MySql在實現Query Cache的具體技術細節上類似典型的K