持久層框架--hibernate（2）

一 .持久化對象的oid 映射爲數據庫表的主鍵，惟一不重複

當數據庫表中的主鍵爲代理主鍵時，持久化對象的oid 要交給hibernate來維護（避免重複）

當數據庫中表的主鍵爲天然主鍵時，持久化對象的oid 要由程序自己來維護

主鍵生成策略(生成持久化oid的方式)：
1. increment 帶走+1
由hibernate來維護oid的值，
優勢：與底層數據庫類型無關
缺點：只適用於單線程對數據庫的訪問

2. identity +1帶走
優勢：適合多用戶訪問
缺點：因爲+1操做由數據庫完成，因此數據庫必須支持自增Mysql,sql server,db2

3. sequence
由數據庫來維護oid的值
數據庫要支持序列 Oracle，db2

4. native
根據底層數據庫的能力選擇 identity、sequence 或者 hilo 中的一個。
持久化對象的oid類型必須爲 long，short 或者 int 類型的，不能使用byte

5. uuid
數據庫表中數據量很是大，但不會常常進行查詢操做，就可使用字符串做爲表單主鍵。

6. assigned 手動分配id
適用於天然主鍵
好比：loginName做爲主鍵


三. 定義持久化對象屬性時，若是屬性爲基本數據類型，最好使用對應的包裝類型

int score;//0
Integer score;//null

 

四. 快照
session的一級緩存 存在快照區域
只有在查詢操做時，會產生快照區域
快照區域保存查詢對象的原始狀態
當session執行flush方法時，會用緩存中的對象和快照中的原始數據進行比較
若是兩組數據不一樣，則自動發送update來更新數據庫

 

數據庫中，本身手動建立序列

對應Customer.hbm.xml作的修改：

       <generator class="native">
              <param name="sequence">cus_id_seq</param>
        </generator>

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC 
 3     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 5 <hibernate-mapping>
 6     <class name="com.edu.oid.Customer" table="tab_customer">
 7         <id name="id" column="id" type="integer">
 8             <!-- 主鍵生成策略 
 9             <generator class="native">
10                 <param name="sequence">cus_id_seq</param>
11             </generator>
12             -->
13             <generator class="assigned"/>
14         </id>
15         
16         <!-- 配置普通屬性 -->
17         <property name="name" column="name" type="string"/>
18         <property name="age" column="age" type="integer"/>
19         <property name="des"/>
20     </class>
21 
22 </hibernate-mapping>

序列跟主鍵號才能一一對應

 

二 .持久化對象生命週期的4種狀態：

　　　　1. 臨時狀態（瞬時狀態）
　　　　2. 持久化狀態
　　　　3. 遊離狀態
　　　　4. 刪除狀態

session對象一級緩存 線程級別的緩存 內置的必須使用
sessionFactory對象 二級緩存 進程級別的緩存 可配置（插拔）

  1 package com.edu.cache;
  2 
  3 import org.hibernate.SessionFactory;
  4 import org.hibernate.Transaction;
  5 import org.hibernate.cfg.Configuration;
  6 import org.hibernate.classic.Session;
  7 import org.junit.Test;
  8 
  9 /**
 10  * 使用單元測試工具，測試hibernate 的增刪改查（CRUD）操做
 11  * 
 12  * @author Administrator
 13  * 
 14  */
 15 public class TestHibernate {
 16 
 17     private static SessionFactory sf;
 18     static {
 19         // 1. 加載配置文件
 20         Configuration cfg = new Configuration();
 21         cfg.configure("com/edu/cache/hibernate.cfg.xml");
 22 
 23         // 2. 得到SessionFactory
 24         sf = cfg.buildSessionFactory();
 25     }
 26     
 27 
 28     @Test
 29     public void find() {
 30         
 31         
 32         Session session = sf.openSession();
 33         Transaction tran = session.beginTransaction();
 34         
 35         Customer c1 = (Customer) session.get(Customer.class, 1);//發生sql
 36         Customer c3 = (Customer) session.get(Customer.class, 2);//發生sql
 37         Customer c2 = (Customer) session.get(Customer.class, 1);//不發生sql
 38         
 39         tran.commit();
 40         session.close();
 41     }
 42     
 43     @Test
 44     public void flush() {
 45         
 46         
 47         Session session = sf.openSession();
 48         Transaction tran = session.beginTransaction();
 49         
 50         //臨時狀態    新建對象   不被session緩存管理，oid的值爲null
 51         Customer c = new Customer();
 52         c.setName("張三");
 53         
 54         /*
 55          *  歸入到session緩存管理，併爲其分配了oid的值，由臨時狀態轉變爲持久化狀態
 56          *  數據庫中沒有與之關聯的記錄
 57          */
 58         session.save(c);//不發送insert
 59         
 60         //刷新緩存，被生產sql語句發送給數據庫，並準備執行
 61         session.flush();//發送
 62         
 63         /*
 64          * 執行sql語句，影響數據庫中的記錄
 65          * 若是程序中沒有手動調用flush方法，
 66          * commit提交事務前，會自動調用flush.
 67          */
 68         tran.commit();
 69         //session關閉，緩存釋放，由持久化狀態轉換爲遊離狀態。處於遊離狀態的對象生命週期並無結束
 70         session.close();
 71         System.out.println(c.getName());
 72         c = null;//對象c的生命週期結束
 73     }
 74     
 75     //清空緩存
 76     @Test
 77     public void clear() {
 78         
 79         
 80         Session session = sf.openSession();
 81         Transaction tran = session.beginTransaction();
 82         
 83         Customer c1 = (Customer) session.get(Customer.class, 1);//發生sql
 84         session.clear();
 85         Customer c2 = (Customer) session.get(Customer.class, 1);//發生sql
 86         
 87         tran.commit();
 88         session.close();
 89     }
 90     //清除
 91     @Test
 92     public void evict() {
 93         
 94         
 95         Session session = sf.openSession();
 96         Transaction tran = session.beginTransaction();
 97         
 98         Customer c1 = (Customer) session.get(Customer.class, 1);//發生sql
 99         Customer c2 = (Customer) session.get(Customer.class, 2);//發生sql
100         session.evict(c1);
101         
102         Customer c3 = (Customer) session.get(Customer.class, 1);//發生sql
103         //Customer c4 = (Customer) session.get(Customer.class, 2);//不發生sql
104         session.update(c1);//c1從遊離狀態轉爲持久化狀態
105         
106         tran.commit();
107         session.close();
108     }
109     
110     //批量插入50萬條記錄
111     /*@Test
112     public void batchSave() {
113         
114         
115         Session session = sf.openSession();
116         Transaction tran = session.beginTransaction();
117         
118         for(int i=0;i<500001;i++) {
119             Customer c = new Customer();
120             c.setName("tom"+i);
121             session.save(c);
122             
123             if(i%10000==0) {
124                 session.flush();//向數據庫發送了10000條insert語句
125                 session.clear();//清空緩存
126             }
127         }
128         
129         tran.commit();
130         session.close();
131     }*/
132     
133     //快照
134     @Test
135     public void kuaiZhao() {
136         
137         
138         Session session = sf.openSession();
139         Transaction tran = session.beginTransaction();
140         
141         Customer c = (Customer) session.get(Customer.class, 1);
142         c.setName("tom");
143         System.out.println(c.getId());
144         
145         
146         //更新前查詢，避免由此操做更名了持久化對象的狀態，二影響數據庫中的記錄。
147     //    session.refresh(c);
148     //    session.update(c);
149         
150         tran.commit();
151         session.close();
152     }
153     
154 }