本文所需的數據庫初始文件，Hibernate常用操作的完整示例代碼（包含所有Hibernate操作所需jar文件）提供下載學習：http://download.csdn.net/detail/daijin888888/9551724
1、Hibernate關聯映射
1）什麼是關聯映射？
如果表之間具有關聯關係，Hibernate允許我們在hbm.xml中描述他們的關聯關係，然後在我們操作其中一張表時，自動的根據這種關係操作到另外的關係表，那麼這種關聯關係的設置，我們稱之為關聯映射。
2）關聯映射的好處？
一次訪問可以關聯操作多張表
--關聯查詢出關係表的數據
--關聯新增、修改關係表的數據
--關聯刪除關係表的數據
3）關聯映射實現步驟
--了解表之間的關係，且明確關係字段
--在實體類中追加關聯屬性，用於封裝關聯的數據
--需要配置hbm.xml文件，設置關聯關係
*2、一對多關聯
例：假如一個Account有多條Service記錄，希望在查詢account數據時，自動連帶著查詢出它對應的service數據。
1）表關係
一對多的關係，關係字段是service.account_id。 （即Service表中要有與Account表關聯的字段account_id，該字段對應Account表中的id）
2）追加關係屬性
在Account類中，追加關聯屬性services，其類型為Set<Service>。
private Set<Service> services = new HashSet<Service>();
3）設置關聯關係
--文法
在Account.hbm.xml中，設置一對多關係
<set name="關聯屬性名"> <key column="關聯字段名"/> <one-to-many/> </set> --實現<set name="services"> <key column="account_id"/> <one-to-many/> </set>
4）示例代碼
已知:
--關聯屬性services
--關聯字段account_id
--關聯對象Service --> 表名service
<span style="font-size:14px;">public void testFind() { Session session = HibernateUtil.getSession(); Account a = (Account) session.load(Account.class, 1010); System.out.println("---顯示Account賬號信息---"); System.out.println(a.getId() + " " + a.getRealName() + " " + a.getIdcardNo()); System.out.println("---顯示當前賬號下的業務賬號---"); Set<Service> services = a.getServices(); for (Service s : services) { System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); } System.out.println(a.toString()); }</span>*3、多對一關聯
例：希望在查詢service數據後，可以自動的查詢出它對應的account數據。
1）關聯關係
service與account具有多對一的關係，關係字段為service.account_id
2）追加關聯屬性
--在Service實體類中追加關聯屬性account，其類型為Account。
private Account account;
此後accountId屬性可以去掉，可以通過getAccount().getId()方法來得到account_id的值
3）設置關聯關係
a、語法：
--在Service.hbm.xml中，追加關聯關係的配置
--<many-to-one name="關聯屬性名"
column="關係字段名"
/>
b、實現：
<many-to-one name="account"
column="account_id"
/>
4）示例代碼
已知：
--關聯屬性account
--關聯字段account_id
--關聯對象Account --> 表名account,主鍵id
<span style="font-size:14px;">public void testFind() { Session session = HibernateUtil.getSession(); Service s = (Service) session.get(Service.class, 2002); System.out.println("----顯示業務賬號信息---"); System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); System.out.println("----顯示相關賬務賬號信息---"); System.out.println(s.getAccount().getId() + " " + s.getAccount().getRealName()); }</span>*4、關聯操作
1）關聯查詢
如果需要當前對象和關聯屬性一起採用一個SQL語句實例化，可以採用下面方法：
a、（不推薦）修改hbm.xml中的關聯屬性映射
lazy屬性:
true表示啟用延遲加載；
false表示關閉延遲加載
fetch屬性:
join表示採用連接方法與主對像一起查詢，此時，lazy="false"失效；
select（默認）表示單獨發送一個SQL查詢關聯數據
b、(推薦)通過HQL及join fetch語法
--from Account a join fetch a.services where a.id=?
含義：在查詢Account對象時，將services關聯屬性數據採用表連接方式一併查出來。
--from Service s join fetch s.account where s.id=?
含義：在查詢Service對象時，將account關聯屬性數據採用表連接方式一併查出來。
--from Service s join fetch s.account where s.account.id=?
注意：
-- HQL中寫的是對象和屬性
--join fetch後面沒有on子句，而fetch的是關聯屬性
--query.setInteger來設置整型參數值，下標從0開始。
--如果明確該HQL只會返回一條記錄，可以使用query.uniqueResult()方法返回唯一的記錄
c、示例代碼（改寫上述一對多關聯的查詢代碼）
<span style="font-size:14px;">public void testFind() { Session session = HibernateUtil.getSession(); // Account a = (Account) session.load(Account.class, 1010); String hql = "from Account a join fetch a.services where a.id=?"; Query query = session.createQuery(hql); query.setInteger(0, 1010);// ?從0開始Account a = (Account) query.uniqueResult();// 單行查詢可採用System.out.println("---顯示Account賬號信息---"); System.out.println(a.getId() + " " + a.getRealName() + " " + a.getIdcardNo()); System.out.println("---顯示當前賬號下的業務賬號---"); Set<Service> services = a.getServices(); for (Service s : services) { System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); } System.out.println(a.toString()); }</span> 2）級聯添加、級聯修改
a、當表具有關聯關係時，Hibernate不僅僅提供關聯查詢的功能，還具有關聯添加、修改、刪除關聯表中數據的能力，這種能力稱之為級聯操作。
b、如何實現級聯操作
需要在關聯屬性設置的位置，追加屬性cascade
--none：默認不支持級聯
--save-update：支持級聯添加與更新
--delete：支持級聯刪除
--all：支持級聯添加、更新、刪除
c、說明
通常1對多的表關係，1的一方是主表，多的一方是從表，往往是需要在添加、更新、刪除主表時連帶添加、更新、刪除從表的數據。如：刪除賬務賬號時，要連帶刪除業務賬號的數據
3）級聯刪除
a、設置cascade="delete"或cascade="all"就可以支持級聯刪除
b、通常情況下，需要在1的一方set標籤處，追加屬性inverse="true"
c、session.delete(obj);obj需要是持久對象，不能new，需要load/get取出
d、批量刪除的方法：
級聯刪除採用n+1個delete語句清除主表和外鍵表的關聯數據。
如果是批量刪除，不推薦級聯刪除，建議採用HQL編寫delete刪除語句。
delete from Service where account.id=?//刪除Service表中所有account.id=?的數據，（該句替代級聯操作中的n個delete語句）
delete from Account where id=?
4）inverse屬性（理解）詳細說明點這裡
是否交出關係維護的控制權。即默認情況下，Account和Service對象之間的關係由雙方負責維護。意思是對Account或Service對像做級聯操作時，需要執行update語句將關聯字段設置成相同ID。如果需要取消某一方的關係維護工作，可以在關聯屬性部分添加inverse="true"設置，這樣可以避免update語句執行。
true：交出控制權，當前的對像不負責維護兩張表的關聯關係
false：不交出控制權，當前的對像要負責維護兩張表的關聯關係
提示：往往是一的一方（即<one-to-many>映射部分）設置為inverse="true"，這樣在對一方級聯操作時，可以避免大量的update更新語句。
*5、多對多關聯
例：管理員admin_info和角色role_info具有多對多的關係，希望在查詢管理員時能夠連帶著查詢出他對應的角色。 數據庫設計時，需採用3張表表示。
ADMIN_INFO(管理員)
ADMIN_ROLE(管理員和角色關係)
ROLE(角色)
1）關係字段
關係字段位於他們的中間表admin_role中，
admin_id=admin_info.id
role_id=role_info.id
2）追加關聯屬性在管理員的實體類中追加角色相關屬性
Set<Role> roles
3）在Admin.hbm.xml中追加關聯映射配置
--語法<set name="關聯屬性名" table="中間表名"> <key column="Admin的關聯字段名"/> <many-to-many column="關聯表的關係字段名"/> </set> --代碼<set name="roles" table="admin_role"> <key column="admin_id"/> <many-to-many column="role_id"/> </set>
4）級聯操作
cascade表示支持級聯操作，操作的是另一方的表，而並不是表示級聯操作中間表。對於中間表的維護，不需要寫cascade屬性。
5）inverse
通常情況下，多對多關聯，不需要寫inverse="true"，原因是另一方在插入數據時，可能沒有管中間表的數據，需要當前的一方來維護，因此不能寫inverse="true"，否則的話，雙方都不維護這個關係，數據上有問題。
6）示例Java代碼
<span style="font-size:14px;"> // 移除角色@Test public void testDeleteRole() { Session session = HibernateUtil.getSession(); Transaction tx = session.beginTransaction(); try { Admin a = (Admin) session.load(Admin.class, 1); Role r1 = (Role) session.load(Role.class, 1); a.getRoles().remove(r1); session.update(a); tx.commit(); } catch (HibernateException e) { e.printStackTrace(); tx.rollback(); } finally { session.close(); } } // 追加角色@Test public void testAddRole() { Session session = HibernateUtil.getSession(); Transaction tx = session.beginTransaction(); try { Admin a = (Admin) session.load(Admin.class, 1); Role r1 = (Role) session.load(Role.class, 1); Role r2 = (Role) session.load(Role.class, 43); Role r3 = (Role) session.load(Role.class, 44); a.getRoles().add(r1); a.getRoles().add(r2); a.getRoles().add(r3); session.update(a); tx.commit(); } catch (HibernateException e) { e.printStackTrace(); tx.rollback(); } finally { session.close(); } } @Test public void testFind() { Session session = HibernateUtil.getSession(); Transaction tx = session.beginTransaction(); try { Admin a = (Admin) session.load(Admin.class, 1); System.out.println("----顯示管理員信息---"); System.out.println(a.getId() + " " + a.getName() + " " + a.getTelephone()); System.out.println("----顯示管理員角色信息---"); for (Role role : a.getRoles()) { System.out.println(role.getName() + " "); } tx.commit(); } catch (HibernateException e) { e.printStackTrace(); tx.rollback(); } finally { session.close(); } }</span>6、繼承關聯
例：在電商網站上搜索商品，比如輸入iphone來搜索，搜索結果中可以包含手機、手機膜、手機殼、充電器、耳機等等相關的產品信息。這種功能，我們可以在設計表時用一種特殊的一對一的關係來表現。即將所有商品通用的屬性提取到一張公共的表中product，具體商品表中只保存該商品特有的屬性，那麼具體商品表和product表具有一對一的關係。在搜索時只搜索product表，就可以將相關的信息模糊查找出來。
--通用信息表product(id,name,price,desc)
--書的商品表book(id,authod,publishing,words)
--希望在操作book表時，能夠自動的將通用的字段維護到product表中。
1）明確表的關係
book與product具有一對一的關係，這種關係的目的是為了復用product表中的字段，像是一種繼承關係
2）實體類
Book extends Product
3）配置文件中體現關聯關係
--父類型同原先的配置文件寫法一致
--子類型具有特殊性
<joined-subclass name="類型名" table="表名" extends="父類名稱"> <key column="關聯字段名"/> <property name="" type="" column=""/> ... </joined-subclass>
4）繼承關係中，由於2張表具有類似於父子的關係，那麼子表中必須引用父表中的數據，不存在不引用的情況，即必須在維護子表同時維護父表。所以這是固定的情況，就不用寫cascade，inverse。
5）描述類別（了解）
<joined-subclass>數據庫有父類表和子類表
<union-subclass>數據庫有子類表、沒有父類表（子類表已包含父類表字段，無父類表，但有父類實體對象）
<subclass>數據庫有父類子類都用一個表（設計較亂，即沒有進行表拆分，很少用）
*7、Hibernate查詢
1）*HQL查詢(Hibernate Query Language)
屬於面向對象查詢語句，針對Hibernate映射過來的POJO進行查詢，從而實現對數據庫的查詢。
a、以非主鍵做條件查詢
--條件參數以？表示，query.setString(0,"");
--條件參數以:x表示，query.setString("x","");
示例代碼：
<span style="font-size:14px;"> // 測試按非主鍵做條件查詢@Test public void testFind1() { String hql = "from Service where account.id=? and unixHost=?"; Session session = HibernateUtil.getSession(); Query query = session.createQuery(hql); query.setInteger(0, 1011); query.setString(1, "192.168.0.23"); List<Service> list = query.list(); for (Service s : list) { System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); } session.close(); } // 等價於testFind1，採用“：標識符”替代@Test public void testFind2() { String hql = "from Service where account.id=:aid and unixHost=:host"; Session session = HibernateUtil.getSession(); Query query = session.createQuery(hql); query.setInteger("aid", 1011); query.setString("host", "192.168.0.23"); List<Service> list = query.list(); for (Service s : list) { System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); } session.close(); }</span> b、只查詢一部分屬性
--默認返回的集合中封裝的是Object[]
--new Service(id,unixHost,osUserName)使返回的結合中封裝的是Service對象，
注意：
Service中需要追加響應的構造器；
不要丟掉無參構造器；
示例代碼：
<span style="font-size:14px;"> // 獲取部分字段結果，默認採用Object[]封裝數據@Test public void testFind3() { String hql = "select s.id,s.unixHost,s.osUserName from Service s where s.account.id=?"; Session session = HibernateUtil.getSession(); Query query = session.createQuery(hql); query.setInteger(0, 1011); List<Object[]> list = query.list(); for (Object[] objs : list) { System.out.println(objs[0] + " " + objs[1] + " " + objs[2] + " "); } session.close(); } // 等價於testFind3，需要添加對應的構造方法@Test public void testFind4() { String hql = "select new Service(s.id,s.unixHost,s.osUserName) from Service s where s.account.id=?"; Session session = HibernateUtil.getSession(); Query query = session.createQuery(hql); query.setInteger(0, 1011); List<Service> list = query.list(); for (Service s : list) { System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); } session.close(); }</span> c、HQL定義在配置文件中（了解即可）
--通過query元素在配置文件中定義HQL
--query元素寫在class的後面
--session.getNamedQuery(HQL名);
示例代碼：<query/>與<class/>在hbm.xml中同級擺放
<span style="font-size:14px;"><query name="findAll"><!-- CDATA內包括純文本字段，防止出現特殊字符--> <![CDATA[ from Service ]]> </query></span> <span style="font-size:14px;"> // 將HQL定義到hbm.xml中（只適用靜態HQL語句結構） @Test public void testFind5() { Session session = HibernateUtil.getSession(); // 獲取hbm.xml中<query>定義的hql語句Query query = session.getNamedQuery("findAll"); List<Service> list = query.list(); for (Service s : list) { System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); } session.close(); }</span> d、分頁查詢
--查詢記錄
query.setFirstResult((page-1)*pageSize);
query.setMaxResults(pageSize);
--查詢總頁數
select count(*) from Service
示例代碼：
<span style="font-size:14px;"> // 測試分頁查詢@Test public void testFind6() { int page = 2; String hql = "from Service order by id"; Session session = HibernateUtil.getSession(); Query query = session.createQuery(hql); // 追加分頁參數設置query.setFirstResult((page - 1) * 3);// 設置抓起記錄的起點，從0開始query.setMaxResults(3);// 設置最大抓取數量List<Service> list = query.list();// 執行查詢，如果沒有分頁設置就查所有值for (Service s : list) { System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); } session.close(); } // select count(*) from SERVICE @Test public void testFind7() { String hql = "select count(*) from Service"; Session session = HibernateUtil.getSession(); Query query = session.createQuery(hql); Long size = (Long) query.uniqueResult(); System.out.println("記錄總數：" + size); session.close(); }</span> e、關聯查詢（記住一種即可）
--from Service s,Account a
where s.account.id=a.id
--from Service s inner join s.account a
--select s.account.realName from Service s
總結：
HQL與SQL的相同點：
--支持select,from,where,group,order by子句
--支持inner join,left join等連接
--支持>,<,>=,<=,in,not in,between,like等條件
--支持分組統計函數count,sum,max,min,avg
HQL與SQL的不同點：
--HQL語句區分大小寫，即大小寫敏感。關鍵字不區分。
--HQL中寫的是對象名和屬性名，而不是表名和字段名
--不支持join on中的on子句
--不支持select *
--不支持數據庫函數，比如日期函數to_date()、字符函數to_char()等
2）Criteria查詢（不夠直觀，了解即可）
使用Hibernate的API來拼一個HQL
Criteria c = session.createCriteria(Service.class);
示例代碼：
<span style="font-size:14px;"> // 使用Hibernate的API來拼一個HQL @Test public void testFind1() { Session session = HibernateUtil.getSession(); Criteria c = session.createCriteria(Service.class); c.add(Restrictions.and(Restrictions.like("osUserName", "huang%"), Restrictions.eq("unixHost", "192.168.0.26")));// 追加查詢條件List<Service> list = c.list();// 執行查詢，如果沒有分頁設置就查所有值c.addOrder(Order.desc("id"));// 追加排序// c.setFirstResult(arg0);//分頁// c.setMaxResults(arg0); for (Service s : list) { System.out.println(s.getId() + " " + s.getOsUserName() + " " + s.getUnixHost()); } session.close(); }</span> 3）SQL查詢
直接幫助我們調用JDBC來執行SQL查詢
SQLQuery sqlQuery = session.createSQLQuery(sql);
示例代碼：
<span style="font-size:14px;"> @Test public void testFind1() { String sql = "select * from Service"; Session session = HibernateUtil.getSession(); SQLQuery sqlQuery = session.createSQLQuery(sql); sqlQuery.setFirstResult(0);// 分頁sqlQuery.setMaxResults(3); // 默認採用數組封裝一條記錄List<Object[]> list = sqlQuery.list(); for (Object[] objs : list) { System.out.println(objs[0] + " " + objs[2]); } session.close(); } //同testFind1()，指定封裝記錄的實體@Test public void testFind2() { String sql = "select * from Service"; Session session = HibernateUtil.getSession(); SQLQuery sqlQuery = session.createSQLQuery(sql); sqlQuery.setFirstResult(0);// 分頁sqlQuery.setMaxResults(3); // 指定封裝記錄的實體類sqlQuery.addEntity(Service.class); // 採用指定的Service類型封裝一條記錄List<Service> list = sqlQuery.list(); for (Service s : list) { System.out.println(s.getId() + " " + s.getOsUserName()); } session.close(); }</span>8、Hibernate高級特性（了解）
1）二級緩存
a、二級緩存（默認關閉）
--二級緩存是SessionFactory級別的緩存，由SessionFactory負責管理
--緩存的也是實體對象
--緩存數據可以被不同的Session間共享
--適用環境：對像數據頻繁共享；對像數據變化頻率小
b、二級緩存的使用步驟
--導緩存包ehcache.jar
--導入緩存配置文件ehcache.xml
--在hibernate.cfg.xml中，設置開啟二級緩存，並且設置緩存驅動類
<span style="font-size:14px;"><!-- 使用二級緩存--> <property name="hibernate.cache.use_second_level_cache">true</property> <!-- 指定二級緩存組件的驅動類ehcache.jar --> <property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property></span>
--在要緩存的POJO的關係映射文件hbm.xml中設置元素<cache usage="readonly"/>
示例代碼：
<span style="font-size:14px;"><span style="font-size:14px;"> @Test public void testFind1() { // 第一次查詢，使用session1 Session session1 = HibernateUtil.getSession(); Service s1 = (Service) session1.get(Service.class, 2002); System.out.println(s1.getOsUserName() + " " + s1.getUnixHost()); session1.close(); // 第二次查詢，使用session2（配置二級緩存後，兩次查詢均到二級緩存中取數據） // HibernateUtil.getSessionFactory().evict(Service.class);// 移除後則還是查詢兩次Session session2 = HibernateUtil.getSession(); Service s2 = (Service) session2.get(Service.class, 2002); System.out.println(s2.getOsUserName() + " " + s2.getUnixHost()); }</span></span> 2）查詢緩存
a、查詢緩存
一級和二級緩存只能是緩存單個對象。如果遇到某個字符串結果、數組結果或者List集合，可以使用查詢緩存存儲。
--可以看成是特殊的二級緩存
--使用的是二級緩存的緩存空間
--緩存的是除實體對象之外的數據類型
--依賴於二級緩存，默認是關閉的，需開啟二級緩存才能使用。
b、使用步驟
--開啟二級緩存
--在hibernate.cfg.xml中設置開啟查詢緩存
<span style="font-size:14px;"><!-- 開啟查詢緩存--> <property name="hibernate.cache.use_query_cache">true</property></span>
--query.list()查詢之前，設置允許進行查詢緩存，query.setCacheable(true);
c、使用環境
--需要頻繁執行的相同的查詢語句
--查詢結果集內容改變頻率小
--結果集數據量不要太多提示：相同的SQL，第一次去數據庫查詢，後續幾次從緩存取出。因為緩存的是SQL+結果集內容
示例代碼：
<span style="font-size:14px;"><span style="font-size:14px;"> @Test public void testFind() { find(); System.out.println("-------"); find(); } private void find() { String hql = "from Service where account.id=?"; Session session = HibernateUtil.getSession(); Query query = session.createQuery(hql); query.setInteger(0, 1011); // 啟用查詢緩存執行query.setCacheable(true); List<Service> list = query.list(); for (Service s : list) { System.out.println(s.getId() + " " + s.getOsUserName()); } }</span></span>9、Hibernate並發處理-加鎖
舉例：
模擬12306購票機制，假設當前有一張火車票的表tickets(id,line,amount,version)，模擬多人同時購票的場景。
1）悲觀鎖
--程序悲觀的認為，每個訪問者都存在並發的問題，於是會對每條數據加鎖，那麼只有當前持有鎖的訪問者釋放該鎖時，下一個訪問者才能訪問數據，這種機制稱之為悲觀鎖。
--就是說無論如何都要給一條數據加鎖，不管該數據是否會發生並發的問題。
--特點
效率低，安全性高
--實現：
get(Class,id,LockMode.UPGRADE)
select * from emp for update
注：這裡利用的是數據庫自帶的for update子句進行加鎖，並非是Hibernate自己發明的加鎖機制。
2）樂觀鎖
--程序樂觀的認為，每個訪問者都不會有並發的問題產生，因此不去加鎖。而是當數據更新時，判斷該數據是否發生了版本的變化，如果發生變化，則說明在此期間有並發產生，因此報錯給予提示，本次更新失敗。
--借助版本字段，當第一個用戶更新提交後，Hibernate會將該字段更新加1，這樣後續用戶提交的對象版本字段比數據庫中的小，即在更新時發現版本變了，就拋出異常並更新失敗。
--一個成功，其他失敗
--特點
效率高，用戶體驗差
--實現
a、需要在表中追加版本字段，用於記錄數據的版本；
b、實體類中追加版本屬性；
c、hbm.xml中追加版本的配置<version name="" type="" column="">
3）如何選擇
--如果是並發量大的情況，應選擇樂觀鎖
--如果是並發量小的情況，應選擇悲觀鎖
以上所述是小編給大家介紹的全面解析Hibernate關聯操作、查詢操作、高級特性、並發處理機制的相關知識，希望對大家有所幫助，如果大家有任何疑問請給我留言，小編會及時回復大家的。在此也非常感謝大家對武林網網站的支持！