Hibernate原理與應用
主要內容
1、引入
2、安裝配置
3、基本概念和CURD
4、HQL和Criteria
5、關聯對映
6、繼承對映
7、集合對映
8、懶載入
9、快取
10、事務
11、其他
12、Hibernate不適合的場景
13、與JPA的整合(annotation方式)
14、最佳實踐
1、引入
模型不匹配(阻抗不匹配)
Java面嚮物件語言，物件模型，其主要概念有：繼承、關聯、多型等；資料庫是關係模型，其主要概念有：表、主鍵、外來鍵等。
解決辦法
1使用JDBC手工轉換。
2使用ORM(Object Relation Mapping物件關係對映)框架來解決，主流的ORM框架有Hibernate、TopLink、OJB。
安裝配置
將下載目錄/hibernate3.jar和/lib下的hibernate執行時必須的包加入classpath中：
antlr.jar,cglib.jar,asm.jar,commons-collections.jar,commons-logging.jar,jta.jar,dom4j.jar
配置檔案hibernate.cfg.xml和hibernate.properties，XML和properties兩種，這兩個檔案的作用一樣，提供一個即可，推薦XML格式，下載目錄/etc下是示例配置檔案。
可以在配置檔案指定：
資料庫的URL、使用者名稱、密碼、JDBC驅動類、方言等。
啟動時Hibernate會在CLASSPATH裡找這個配置檔案。
對映檔案(hbm.xml，物件模型和關係模型的對映)。在/eg目錄下有完整的hibernate示例。
快速開始小例子
基本概念和CURD
開發流程
1由Domain object -> mapping->db。(官方推薦)
2由DB開始，用工具生成mapping和Domain object。(使用較多)
3由對映檔案開始。
基本概念和CURD
Domain Object限制
1.預設的構造方法(必須的)。
2有無意義的標示符id（主鍵）(可選)
3非final的，對懶載入有影響（可選）
Domain Java Object(User)
public class User {
private int id;
private String name;
private Date birthDay;
//getter setter…
}
1.hbm.xml
<?xml version="1.0"?>
<hibernate-mapping package=“cn.itcast.domain">
<class name="User" table="user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="birthday”/>
</class>
</hibernate-mapping>
Java程式碼
1.初始化程式碼(只做一次)
Configuration cfg = new Configuration();
cfg.configure(“config.cfg.xml”);
也可以通過cfg.setProperty設定屬性。
SessionFactory sessionFactory = cfg.buildSessionFactory();
2.模板程式碼
Session session = null;Transaction tx = null;
try{
session = sessionFactory.openSession();
tx = session.beginTransaction();
//…你的程式碼save,delete,update,get…
tx.commit();
}catch(Exception e){
if(tx !=null)tx.rollback();throw e;
}finally{
if(session != null)session.close();
}
Session的幾個主要方法
1.save,persist儲存資料，persist在事務外不會產生insert語句。
2.delete,刪除物件
3.update,更新物件，如果資料庫中沒有記錄，會出現異常。
4.get,根據ID查，會立刻訪問資料庫。
5.Load，根據ID查，(返回的是代理，不會立即訪問資料庫)。
6.saveOrUpdate,merge(根據ID和version的值來確定是save或update),呼叫merge你的物件還是託管的。
7.lock(把物件變成持久物件，但不會同步物件的狀態)。
物件狀態
瞬時(transient)：資料庫中沒有資料與之對應，超過作用域會被JVM垃圾回收器回收，一般是new出來且與session沒有關聯的物件。
持久(persistent)：資料庫中有資料與之對應，當前與session有關聯，並且相關聯的session沒有關閉，事務沒有提交；持久物件狀態發生改變，在事務提交時會影響到資料庫(hibernate能檢測到)。
脫管(detached)：資料庫中有資料與之對應，但當前沒有session與之關聯；託管物件狀態發生改變，hibernate不能檢測到。
HQL和Criteria
HQL(Hibernate Query Language)
物件導向的查詢語言，與SQL不同，HQL中的物件名是區分大小寫的（除了JAVA類和屬性其他部分不區分大小寫）；HQL中查的是物件而不是和表，並且支援多型；HQL主要通過Query來操作，Query的建立方式：
Query q = session.createQuery(hql);
from Person
from User user where user.name=:name
from User user where user.name=:name and user.birthday < :birthday
Criteria
Criteria是一種比HQL更物件導向的查詢方式；Criteria的建立方式：
Criteria crit = session.createCriteria(DomainClass.class);
簡單屬性條件如：criteria.add(Restrictions.eq(propertyName, value)),
criteria.add(Restrictions.eqProperty(propertyName,otherPropertyName))
基本功能練習
實現UserDao
public interface UserDao {
public void saveUser(User user);
public User findUserById(int id);
public User findUserByName(String name);
public void updateUser(User user);
public void remove(User user);
}
實驗步驟：
1.設計domain物件User。
2.設計UserDao介面。
3.加入hibernate.jar和其依賴的包。
4.編寫User.hbm.xml對映檔案，可以基於hibernate/eg目錄下的org/hibernate/auction/User.hbm.xml修改。
5.編寫hibernate.cfg.xml配置檔案，可以基於hibernate/etc/hibernate.cfg.xml修改；必須提供的幾個引數：
connection.driver_class、connection.url、connection.username、connection.password、dialect、hbm2ddl.auto。
6.編寫HibernateUtils類，主要用來完成Hibnerate初始化和提供一個獲得Session的方法；這步可選。
7.實現UserDao介面。
關聯對映
多對一(Employee - Department)
一對多(Department-Employee)
一對一(room - door)
多對多(teacher - student)
元件對映(User-Name)
集合對映(set, list, map, bag)
inverse和cascade(Employee– Department)
多對一(Employee - Department)
對映檔案<many-to-one name=”depart” column=”depart_id”/>
ER圖
關聯對映
一對多(Department-Employee)
<set name=”employees”>
<key column=”depart_id”/>
<one-to-many class=”Employee”/>
</set>
一對一(Person - IdCard)
1)基於主鍵的one-to-one(person的對映檔案)
<id name=”id”>
<generator class=”foreign”><param name=”property”>idCard</param></generator>
<id>
<one-to-one name=”idCard” constrained=”true”/>
一對一(Person - IdCard)
2)基於外健的one-to-one，可以描述為多對一，加unique=“true”約束
<one-to-one name=”idCard” property-ref=“person”/>
property-ref用於指定關聯類的一個屬性，這個屬性將會和本外來鍵相對應
<many-to-one name=”person” column=”person_id” unique=”true” not-null=”true”/>
<!-唯一的多對一，其實就便成了一對一了-->
關聯對映
多對多(teacher - student)
在操作和效能方面都不太理想，所以多對多的對映使用較少，實際使用中最好轉換成一對多的物件模型；Hibernate會為我們建立中間關聯表，轉換成兩個一對多。
<set name="teacher" table="teacher_student">
<key column="teacher_id"/>
<many-to-many class="Student" column="student_id"/>
</set>
關聯對映
元件對映(User-Name)
關聯的屬性是個複雜型別的持久化類，但不是實體即：資料庫中沒有表與該屬性對應，但該類的屬性要之久儲存的。
<component name=”name” class=”com.test.hibernate.domain.Name”>
<property name=”initial”/>
<property name=”first”/>
<property name=”last”/>
</component>
當元件的屬性不能和表中的欄位簡單對應的時候可以選擇實現：
org.hibernate.usertype. UserType或
org.hibernate.usertype. CompositeUserType
對於一些不是複雜的實體類我們可以在資料庫中沒有表與之相對應
這時可選用Component元件
繼承對映
物件模型(Java類結構)
繼承對映
一個類繼承體系一張表(subclass)(表結構)
繼承對映
一個類繼承體系一張表(subclass)(對映檔案)
<class name="Employee" table="employee" discriminator-value="0">
<id name="id">
<generator class="native"/>
</id>
<discriminator column="type" type="int"/>
<property name="name"/>
<many-to-one name=”depart” column=”depart_id”/>
<subclass name="Skiller" discriminator-value="1">
<property name=”skill”/>
</subclass>
<subclass name="Sales" discriminator-value="2">
<property name="sell"/>
</subclass>
</class>
一張表對映出一個繼承樹 操作就是一張表查詢的效率高
缺點：對於新增加某一個型別時就要修改表結構資訊且有的欄位必須可以為NULL
繼承對映
每個子類一張表(joined-subclass) (表結構)
多型查詢效率會很低要將所有的表來查詢一遍
每個子類都儲存為一張表
這是當每個子類的屬性差別都很大時會用該種方式來處理
繼承對映
每個子類一張表(joined-subclass) (對映檔案)
<class name="Employee" table="employee">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<joined-subclass name="Skiller" table="skiller">
<key column="employee_id"/>
<property name="skill"/>
</joined-subclass>
<joined-subclass name="Sales" table="sales">
<key column="employee_id"/>
<property name="sell"/>
</joined-subclass>
</class>
繼承對映
混合使用“一個類繼承體系一張表”和“每個子類一張表” (表結構)
繼承對映
混合使用“一個類繼承體系一張表”和“每個子類一張表” (對映檔案)
<class name="Employee" table="employee">
<id name="id">
<generator class="native"/>
</id>
<discriminator column="type"/>
<property name="name"/>
<subclass name="Skiller">
<property name="net"/>
</subclass>
<subclass name=”Sales”">
<join table="sales">
<key column="employee_id"/>
<property name="sell"/>
</join>
</subclass>
</class>
繼承對映
每個具體類一張表(union-subclass) (表結構)
根據主鍵來查詢
要求三張表的id都是不同的如果用這種結構來實現()
增刪改都是直接對單表進行操作
進行查詢時有可能對三張表來進行查詢（但hibernate會進行子查詢連線查詢）
繼承對映
每個具體類一張表(union-subclass) (對映檔案)
<class name="Employee" abstract="true">
<id name="id">
<generator class="hilo"/>
</id>
<property name="name"/>
<union-subclass name="Skiller" table="skiller">
<property name="skill"/>
</union-subclass>
<union-subclass name="Sales" table="sales">
<property name="sell"/>
</union-subclass>
</class>
主健不能是identity型別，如果父類是abstract=”true”就不會有表與之對應。
隱式多型，對映檔案沒有聯絡，限制比較多很少使用。
集合對映
集合對映(set, list, array,bag, map)
<set name=”employees” >
<key column=”depart_id”/>
<one-to-many class=”Employee”/>
<!-- <element type="string" column="name"/> -->
<!--
<composite-element class=”YourClass”>
<property name=”prop1”/>
<property name=”prop2”/>
</composite>
-->
</set>
集合對映(set, list, array,bag, map)
<list name=”employees” >
<key column=”depart_id”/>
<!—表中有單獨的整型列表示list-index
<list-index column=”order_column”/>
<one-to-many class=”Employee”/>
</list>
<array name=”employees” >
<key column=”depart_id”/>
<!—表中有單獨的整型列表示list-index
<list-index column=”order_column”/>
<one-to-many class=”Employee”/>
</array>
集合對映(set, list, array,bag, map)
<bag name="employees " order-by="id desc">
<key column=”depart_id”/>
<one-to-many class=”Employee”/>
</bag>
<map name="employees ">
<key column=”depart_id”/>
<map-key type="string" column="name"/>
<one-to-many class=”Employee”/>
</map>
集合對映(set, list, array,bag, map)
這些集合類都是Hibernate實現的類和JAVA中的集合類不完全一樣，set,list,map分別和JAVA中的Set,List,Map介面對應，bag對映成JAVA的List；這些集合的使用和JAVA集合中對應的介面基本一致；在JAVA的實體類中集合只能定義成介面不能定義成具體類，因為集合會在執行時被替換成Hibernate的實現。
集合的簡單使用原則：大部分情況下用set，需要保證集合中的順序用list，想用java.util.List又不需要保證順序用bag。
集合對映
cascade和inverse (Employee– Department)
Casade用來說明當對主物件進行某種操作時是否對其關聯的從物件也作類似的操作，常用的cascade:
none,all,save-update ,delete, lock,refresh,evict,replicate,persist,
merge,delete-orphan(one-to-many)。一般對many-to-one,many-to-many不設定級聯，在<one-to-one>和<one-to-many>中設定級聯。
inverse表“是否放棄維護關聯關係”(在Java裡兩個物件產生關聯時，對資料庫表的影響)，在one-to-many和many-to-many的集合定義中使用，inverse=”true”表示該物件不維護關聯關係；該屬性的值一般在使用有序集合時設定成false（注意hibernate的預設值是false）。
one-to-many維護關聯關係就是更新外來鍵。many-to-many維護關聯關係就是在中間表增減記錄。
注:配置成one-to-one的物件不維護關聯關係
懶載入
通過asm和cglib二個包實現；Domain是非final的。
1.session.load懶載入。
2.one-to-one(元素)懶載入：
必需同時滿足下面三個條件時才能實現懶載入
(主表不能有constrained=true,所以主表沒有懶載入)
lazy!=false 2)constrained=true 3)fetch=select
3.one-to-many (元素)懶載入：1)lazy!=false 2)fetch=select
4.many-to-one (元素)：1)lazy!=false 2)fetch=select
5.many-to-many (元素)：1)lazy!=false 2)fetch=select
6.能夠懶載入的物件都是被改寫過的代理物件，當相關聯的session沒有關閉時，訪問這些懶載入物件（代理物件）的屬性（getId和getClass除外）hibernate會初始化這些代理，或用Hibernate.initialize(proxy)來初始化代理物件；當相關聯的session關閉後，再訪問懶載入的物件將出現異常。
初始時就建立了一個物件
如果你不需要那麼它就不會去訪問資料庫
只有要真正需要資料時則需在session未關閉時去訪問下資料庫
對於一對一的情況下 主表的查詢沒有懶載入會從資料庫中將從表查詢出來 從表預設是不會載入而是返回代理形式會有懶載入的形式
對於一對多預設是懶載入的如果不是就會當我們例如查詢部門時會將所有的員工資訊都查出來
對於getID() 和 getClass() 這都是不需要訪問資料庫的 不會初始化代理物件
對於相應對映關係時存在懶載入的機制
快取
快取的作用主要用來提高效能，可以簡單的理解成一個Map；使用快取涉及到三個操作：把資料放入快取、從快取中獲取資料、刪除快取中的無效資料。
一級快取，Session級共享。
save,update,saveOrUpdate,load,get,list,iterate,lock這些方法都會將物件放在一級快取中，一級快取不能控制快取的數量，所以要注意大批量運算元據時可能造成記憶體溢位；可以用evict,clear方法清除快取中的內容。
快取
二級快取，SessionFactory級共享。
實現為可插拔，通過修改cache.provider_class引數來改變;
hibernate內建了對EhCache,OSCache,TreeCache,SwarmCache的支援，可以通過實現CacheProvider和Cache介面來加入Hibernate不支援的快取實現。
在hibernate.cfg.xml中加入:
<class-cache class="className" usage="read-only"/>
或在對映檔案的class元素加入子元素:
<cache usage="read-write"/>
其中usage:read-only,read-write,nonstrict-read-write,transactional
Session的:save(這個方法不適合native生成方式的主鍵),
update,saveOrUpdate,list,iterator,get,load,以及Query,Criteria都會填充二級快取，但只有(沒開啟查詢快取時)Session的iterator,get,load會從二級快取中取資料(iterator可能存在N+1次查詢)。
Query,Criteria(查詢快取)由於命中率較低，所以hibernate預設是關閉；修改cache.use_query_cache為true開啟對查詢的快取，並且呼叫query.setCacheable(true)或criteria.setCacheable(true)。
SessionFactory中提供了evictXXX()方法用來清除快取中的內容。
統計資訊開啟generate_statistics，用sessionFactory.getSatistics()獲取統計資訊。
快取
分散式快取和中央快取。
使用快取的條件
1.讀取大於修改。
2.資料量不能超過記憶體容量。
3.對資料要有獨享的控制。
4.可以容忍出現無效資料。
事務
JDBCTransaction
單個資料庫（一個SesisonFactory對應一個資料庫），由JDBC實現。
Session session = null;
Transaction tx =null;
try {
session = sessionFactory.openSession();
tx = session.beginTransaction();
//process
tx.commit();
} catch(HibernateException e){
if(tx != null)tx.rollback();throw e;
}finally {
if (session != null)session.close();
}
connection.setAutoCommit(false);
connection.commit();conn.rollback();
JTATransaction
可以簡單的理解成跨資料庫的事物，由應用JTA容器實現；使用JTATransaction需要配置hibernate.transaction.factory_class引數，該引數預設值是org.hibernate.transaction. JDBCTransactionFactory，當使用JTATransaction時需要將該引數改成org.hibernate.transaction.JTATransactionFactory，並配置jta.UserTransaction引數JNDI名(Hibernate在啟動JTATransaction時要用該值到JNDI的上下文Context中去找javax.transaction.UserTransaction)。
javax.transaction.UserTransactin tx = context.lookup(“jndiName”);
try{
tx.begin();
//多個資料庫的session操作;
//session1….
//session2….
tx.commit();
}catch(Exception e){
tx.rollback(); throw e;
}
session context和事務邊界
用current_session_context_class屬性來定義context（用sessionFactory.getCurrentSession()來獲得session），其值為：
1.thread：ThreadLocal來管理Session實現多個操作共享一個Session，避免反覆獲取Session，並控制事務邊界，此時session不能呼叫close當commit或rollback的時候session會自動關閉(connection.release_mode:after_transaction)。
Open session in view：在生成（渲染）頁面時保持 session開啟。
2.jta：由JTA事務管理器來管理事務(connection.release_mode:after_statement)。
悲觀鎖和樂觀鎖
悲觀鎖由資料庫來實現；樂觀鎖hibernate用version和timestamp來實現
事務邊界 開啟提交 回滾
如想在業務邏輯層控制事務 但業務邏輯層不會與資料訪問層有相當大的耦合
Transaction因為是業務邏輯層的物件
悲觀鎖我讀取到資訊時會對資訊進行加鎖操作等資料修改完後對資料鎖進行釋放其他才能修改（不可取）
看資料庫的版本號與提交的版本號哪個更加新如果資料庫的新則不允許提交的
其他問題
hibernate.cfg.xml和hbm.xml內容解釋
資料型別
1.<property name=“name” type=“java.lang.String”/>
type可以是hibernate、java型別或者你自己的型別(需要實現hibernate的一個介面)。
2.基本型別一般不需要在對映檔案(hbm.xml)中說明，只有在一個JAVA型別和多個資料庫資料型別相對應時並且你想要的和hibernate預設對映不一致時，需要在對映檔案中指明型別(如:java.util.Date,資料庫DATE,TIME,DATATIME,TIMESTAMP，hibernate預設會把java.util.Date對映成DATATIME型，而如果你想對映成TIME，則你必須在對映檔案中指定型別)。
3.資料型別的對應關係見參考文件5.2.2
Session是非執行緒安全的，生命週期較短，代表一個和資料庫的連線，在B/S系統中一般不會超過一個請求；內部維護一級快取和資料庫連線，如果session長時間開啟，會長時間佔用記憶體和資料庫連線。
SessionFactory是執行緒安全的，一個資料庫對應一個SessionFactory，生命週期長，一般在整個系統生命週期內有效；SessionFactory儲存著和資料庫連線的相關資訊（user，password，url）和對映資訊，以及Hibernate執行時要用到的一些資訊。
session內部封裝了connection連線
對於session儘量晚的獲得儘量早的釋放
對於主鍵為自動增長型別因為要從資料庫中獲取才能進行插入所以會直接進入資料庫
而不像其他型別先進入快取等提交時才與資料庫互動
其他問題
flush時將一級快取與資料庫同步
大批處理
大量運算元據時可能造成記憶體溢位，解決辦法如下：
1.清除session中的資料
for(int i=0;i<100000;i++)session.save(obj);
for(int i=0;i<100000;i++){
session.save(obj);
if(i% 50 == 0){session.flush(); session.clear();}
}
2.用StatelessSession介面：它不和一級快取、二級快取互動，也不觸發任何事件、監聽器、攔截器，通過該介面的操作會立刻傳送給資料庫，與JDBC的功能一樣。
StatelessSession s = sessionFactory.openStatelessSession();該介面的方法與Session類似。
3.Query.executeUpdate()執行批量更新，會清除相關聯的類二級快取(sessionFactory.evict(class))，也可能會造成級聯，和樂觀鎖定出現問題
其他問題
HQL
1查詢多個物件select art, user from Article art, User user where art.author.id=user.id and art.id=:id這種方式返回的是Object[]，Object[0]:article,Object[1]:user。
2分頁query.setFirstResult,query.setMaxResults.
查詢記錄總數query.iterate(“select count(*) from Person”).next()
3批量更新query.executeUpdate()可能造成二級快取有實效資料。
Criteria
1排序Criteria.addOrder(Order.desc(propertyName));
2關聯查詢criteria.setFetchMode(“propertyName”, FetchMode.SELECT)與對映檔案中關聯關係的fetch作用一致。
3投影Projections.rowCount(),max(propertyName), avg, groupProperty…
4分頁Projections.rowCount(),criteria.setFirstResult(),criteria.setMaxResults()
5DetachedCriteria可在session外建立（在其他層建立比如在Service中建立）然後用getExecutableCriteria(session)方法建立Criteria物件來完成查詢。
6Example查詢,Example.create(obj);criteria.add(example)。
查詢表示式是不會利用快取來進行查詢的（預設情況下）
離線查詢實現動態查詢DetachedCriteria 他構造時不需要session
而Cruteria構造時需要
其他問題
N+1次查詢和懶載入
1.用Query.iterator可能會有N+1次查詢。
2.懶載入時獲取關聯物件。
3.如果開啟對查詢的快取即使用list也可能有N+1次查詢。
攔截器與事件
攔截器與事件都是hibernate的擴充套件機制，Interceptor介面是老的實現機制，現在改成事件監聽機制；他們都是hibernate的回撥介面，hibernate在save,delete,update…等會回撥這些類。
SQL和命名查詢
用Map代替Domain物件；將物件轉化為XML。
命名查詢是將查詢語句集中起來到配置檔案中更方便的修改
Hibernate不適合的場景
不適合OLAP(On-Line Analytical Processing聯機分析處理)，以查詢分析資料為主的系統；適合OLTP（on-line transaction processing聯機事務處理）。
對於些關係模型設計不合理的老系統，也不能發揮hibernate優勢。
資料量巨大，效能要求苛刻的系統，hibernate也很難達到要求,批量運算元據的效率也不高。
與JPA的整合(annotation方式)
需要新增的包ejb3-persistence.jar, hibernate-entitymanager.jar, hibernate-annotations.jar, hibernate-commons-annotations.jar, jboss-archive-browsing.jar, javassist.jar
配置檔案%CLASSPATH%/META-INF/persistence.xml
JAVA程式碼：
EntityManagerFactory emf = Persistence.createEntityManagerFactory(name);
//(Name:在persistence.xml中指定。)
EntityManager em = emf.createEntityManager();
EntityTransaction tx = em.getTransaction();
Tx.begin();
Em.persist(entity);//remove,merge,find
Tx.commit();
Em.close();
Emf.close();
最佳實踐
見hibernate參考文件