1 web內容回顧
（1）javaee三層結構
（2）mvc思想
2 hibernate概述
3 hibernate入門案例
4 hibernate配置文件
5 hibernate的api使用
Hibernate概述
什么是hibernate框架（重點）
1 hibernate框架應用在javaee三層結構中 dao層框架
2 在dao層里面做對數據庫crud操作，使用hibernate實現crud操作，hibernate底層代碼就是jdbc，hibernate對jdbc進行封裝，使用hibernate好處，不需要寫復雜jdbc代碼了，
不需要寫sql語句實現
3 hibernate開源的輕量級的框架
4 hibernate版本
Hibernate3.x
Hibernate4.x
Hibernate5.x（學習）
什么是orm思想（重點）
1 hibernate使用orm思想對數據庫進行crud操作
2 在web階段學習 javabean，更正確的叫法 實體類
3 orm：object relational mapping，對象關系映射
文字描述：
（1）讓實體類和數據庫表進行一一對應關系
讓實體類首先和數據庫表對應
讓實體類屬性 和 表里面字段對應
（2）不需要直接操作數據庫表，而操作表對應實體類對象
畫圖描述
Hibernate入門
搭建hibernate環境（重點）
第一步 導入hibernate的jar包
因為使用hibernate時候，有日志信息輸出，hibernate本身沒有日志輸出的jar包，導入其他日志的jar包
不要忘記還有mysql驅動的jar包
第二步創建實體類
package cn.itcast.entity; public class User { /*hibernate要求實體類有一個屬性唯一的*/ // private int uid; private String uid; private String username; private String password; private String address; // public int getUid() { // return uid; // } // public void setUid(int uid) { // this.uid = uid; // } public String getUsername() { return username; } public String getUid() { return uid; } public void setUid(String uid) { this.uid = uid; } public void setUsername(String username) { this.username = username; } public String getPassword() { return password; } public void setPassword(String password) { this.password = password; } public String getAddress() { return address; } public void setAddress(String address) { this.address = address; } }
（1）使用hibernate時候，不需要自己手動創建表，hibernate幫把表創建
第三步 配置實體類和數據庫表一一對應關系（映射關系）
使用配置文件實現映射關系
（1）創建xml格式的配置文件
- 映射配置文件名稱和位置沒有固定要求
- 建議：在實體類所在包里面創建，實體類名稱.hbm.xml
（2）配置是是xml格式，在配置文件中首先引入xml約束
- 學過約束dtd、schema，在hibernate里面引入的約束dtd約束
（3）配置映射關系
<hibernate-mapping> <!-- 1 配置類和表對應 class標簽 name屬性：實體類全路徑 table屬性：數據庫表名稱 --> <class name="cn.itcast.entity.User" table="t_user"> <!-- 2 配置實體類id和表id對應 hibernate要求實體類有一個屬性唯一值 hibernate要求表有字段作為唯一值 --> <!-- id標簽 name屬性：實體類里面id屬性名稱 column屬性：生成的表字段名稱 --> <id name="uid" column="uid"> <!-- 設置數據庫表id增長策略 native:生成表id值就是主鍵自動增長 --> <generator class="native"></generator> </id> <!-- 配置其他屬性和表字段對應 name屬性：實體類屬性名稱 column屬性：生成表字段名稱 --> <property name="username" column="username"></property> <property name="password" column="password"></property> <property name="address" column="address"></property> </class> </hibernate-mapping>
第四步 創建hibernate的核心配置文件
（1）核心配置文件格式xml，但是核心配置文件名稱和位置固定的
- 位置：必須src下面
- 名稱：必須hibernate.cfg.xml
（2）引入dtd約束
（3）hibernate操作過程中，只會加載核心配置文件，其他配置文件不會加載
第一部分： 配置數據庫信息 必須的
第二部分：配置hibernate信息 可選的
第三部分：把映射文件放到核心配置文件中
<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configuration> <session-factory> <!-- 第一部分： 配置數據庫信息 必須的 --> <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property> <property name="hibernate.connection.url">jdbc:mysql:///hibernate_day01</property> <property name="hibernate.connection.username">root</property> <property name="hibernate.connection.password">root</property> <!-- 第二部分： 配置hibernate信息 可選的--> <!-- 輸出底層sql語句 --> <property name="hibernate.show_sql">true</property> <!-- 輸出底層sql語句格式 --> <property name="hibernate.format_sql">true</property> <!-- hibernate幫創建表，需要配置之后 update: 如果已經有表，更新，如果沒有，創建 --> <property name="hibernate.hbm2ddl.auto">update</property> <!-- 配置數據庫方言 在mysql里面實現分頁 關鍵字 limit，只能使用mysql里面 在oracle數據庫，實現分頁rownum 讓hibernate框架識別不同數據庫的自己特有的語句 --> <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property> <!-- 第三部分： 把映射文件放到核心配置文件中 必須的--> <mapping resource="cn/itcast/entity/User.hbm.xml"/> </session-factory> </hibernate-configuration>
實現添加操作
第一步 加載hibernate核心配置文件
第二步 創建SessionFactory對象
第三步 使用SessionFactory創建session對象
第四步 開啟事務
第五步 寫具體邏輯 crud操作
第六步 提交事務
第七步 關閉資源
@Test public void testAdd() { // 第一步 加載hibernate核心配置文件 // 到src下面找到名稱是hibernate.cfg.xml //在hibernate里面封裝對象 Configuration cfg = new Configuration(); cfg.configure(); // 第二步 創建SessionFactory對象 //讀取hibernate核心配置文件內容，創建sessionFactory //在過程中，根據映射關系，在配置數據庫里面把表創建 SessionFactory sessionFactory = cfg.buildSessionFactory(); // 第三步 使用SessionFactory創建session對象 // 類似於連接 Session session = sessionFactory.openSession(); // 第四步 開啟事務 Transaction tx = session.beginTransaction(); // 第五步 寫具體邏輯 crud操作 //添加功能 User user = new User(); user.setUsername("小王"); user.setPassword("250"); user.setAddress("日本"); //調用session的方法實現添加 session.save(user); // 第六步 提交事務 tx.commit(); // 第七步 關閉資源 session.close(); sessionFactory.close(); }
內容目錄
1 實體類編寫規則
2 hibernate主鍵生成策略
（1）native
（2）uuid
3 實體類操作
（1）crud操作
（2）實體類對象狀態
4 hibernate的一級緩存
5 hibernate的事務操作
（1）事務代碼規范寫法
6 hibernate其他的api（查詢）
（1）Query
（2）Criteria
（3）SQLQuery
實體類編寫規則
1 實體類里面屬性私有的
2 私有屬性使用公開的set和get方法操作
3 要求實體類有屬性作為唯一值（一般使用id值）
4 實體類屬性建議不使用基本數據類型，使用基本數據類型對應的包裝類
（1）八個基本數據類型對應的包裝類
- int – Integer
- char—Character、
- 其他的都是首字母大寫 比如 double – Double
（2）比如 表示學生的分數，假如 int score;
- 比如學生得了0分 ，int score = 0;
- 如果表示學生沒有參加考試，int score = 0;不能准確表示學生是否參加考試
l 解決：使用包裝類可以了， Integer score = 0，表示學生得了0分，
表示學生沒有參加考試，Integer score = null;
Hibernate主鍵生成策略
1 hibernate要求實體類里面有一個屬性作為唯一值，對應表主鍵，主鍵可以不同生成策略
2 hibernate主鍵生成策略有很多的值
3 在class屬性里面有很多值
（1）native： 根據使用的數據庫幫選擇哪個值
（2）uuid：之前web階段寫代碼生成uuid值，hibernate幫我們生成uuid值
實體類操作
對實體類crud操作
添加操作
1 調用session里面的save方法實現
根據id查詢
1 調用session里面的get方法實現
修改操作
1 首先查詢，修改值
（1）根據id查詢，返回對象
刪除操作
1 調用session里面delete方法實現
實體類對象狀態（概念）
1 實體類狀態有三種
（1）瞬時態：對象里面沒有id值，對象與session沒有關聯
（2）持久態：對象里面有id值，對象與session關聯
（3）托管態：對象有id值，對象與session沒有關聯
2 演示操作實體類對象的方法
（1）saveOrUpdate方法：實現添加、實現修改
Hibernate的一級緩存
什么是緩存
1 數據存到數據庫里面，數據庫本身是文件系統，使用流方式操作文件效率不是很高。
（1）把數據存到內存里面，不需要使用流方式，可以直接讀取內存中數據
（2）把數據放到內存中，提供讀取效率
Hibernate緩存
1 hibernate框架中提供很多優化方式，hibernate的緩存就是一個優化方式
2 hibernate緩存特點：
第一類 hibernate的一級緩存
（1）hibernate的一級緩存默認打開的
（2）hibernate的一級緩存使用范圍，是session范圍，從session創建到session關閉范圍
（3）hibernate的一級緩存中，存儲數據必須 持久態數據
第二類 hibernate的二級緩存
（1）目前已經不使用了，替代技術 redis
（2）二級緩存默認不是打開的，需要配置
（3）二級緩存使用范圍，是sessionFactory范圍
驗證一級緩存存在
1 驗證方式
（1）首先根據uid=1查詢，返回對象
（2）其次再根據uid=1查詢，返回對象
第一步執行get方法之后，發送sql語句查詢數據庫
第二個執行get方法之后，沒有發送sql語句，查詢一級緩存內容
Hibernate一級緩存執行過程
Hibernate一級緩存特性
1 持久態自動更新數據庫
Hibernate事務操作
事務相關概念
1 什么是事務
2 事務特性
3 不考慮隔離性產生問題
（1）臟讀
（2）不可重復讀
（3）虛讀
4 設置事務隔離級別
（1）mysql默認隔離級別 repeatable read
Hibernate事務代碼規范寫法
1 代碼結構
try {
開啟事務
提交事務
}catch() {
回滾事務
}finally {
關閉
}
@Test public void testTx() { SessionFactory sessionFactory = null; Session session = null; Transaction tx = null; try { sessionFactory = HibernateUtils.getSessionFactory(); session = sessionFactory.openSession(); //開啟事務 tx = session.beginTransaction(); //添加 User user = new User(); user.setUsername("小馬"); user.setPassword("250"); user.setAddress("美國"); session.save(user); int i = 10/0; //提交事務 tx.commit(); }catch(Exception e) { e.printStackTrace(); //回滾事務 tx.rollback(); }finally { //關閉操作 session.close(); sessionFactory.close(); } }
Hibernate綁定session
session類似於jdbc的connection，之前web階段學過 ThreadLocal
2 幫實現與本地線程綁定session
3 獲取與本地線程session
（1）在hibernate核心配置文件中配置
（2）調用sessionFactory里面的方法得到
4 獲取與本地線程綁定session時候，關閉session報錯，不需要手動關閉了
Hibernate的api使用
Query對象
1 使用query對象，不需要寫sql語句，但是寫hql語句
（1）hql：hibernate query language，hibernate提供查詢語言，這個hql語句和普通sql語句很相似
（2）hql和sql語句區別：
- 使用sql操作表和表字段
- 使用hql操作實體類和屬性
2 查詢所有hql語句：
（1）from 實體類名稱
3 Query對象使用
（1）創建Query對象
（2）調用query對象里面的方法得到結果
Criteria對象
1 使用這個對象查詢操作，但是使用這個對象時候，不需要寫語句，直接調用方法實現
2 實現過程
（1）創建criteria對象
（2）調用對象里面的方法得到結果
SQLQuery對象
1 使用hibernate時候，調用底層sql實現
2 實現過程
（1）創建對象
（2）調用對象的方法得到結果
返回list集合每部分是數組
返回list中每部分是對象形式
1 表與表之間關系回顧
（1）一對多（客戶和聯系人）
（2）多對多（用戶和角色）
2 hibernate一對多操作
（1）一對多映射配置
（2）一對多級聯保存
（3）一對多級聯刪除
（4）inverse屬性
3 hibernate多對多操作
（1）多對多映射配置
（2）多對多級聯保存（重點）
（3）多對多級聯刪除
（4）維護第三張表
客戶列表功能
1 sessionFactory已經關閉了，不需要關閉
2 dao里面代碼
//使用hibernate實現查詢列表 public List<Customer> findAll() { SessionFactory sessionFactory = null; Session session = null; Transaction tx = null; try { //得到sessionFactory sessionFactory = HibernateUtils.getSessionFactory(); //得到session session = sessionFactory.openSession(); //開啟事務 tx = session.beginTransaction(); //查詢所有記錄 Criteria criteria = session.createCriteria(Customer.class); List<Customer> list = criteria.list(); //提交事務 tx.commit(); return list; }catch(Exception e) { tx.rollback(); }finally { session.close(); //sessionFactory不需要關閉 // sessionFactory.close(); } return null; }
表與表之間關系回顧（重點）
1 一對多
（1）分類和商品關系，一個分類里面有多個商品，一個商品只能屬於一個分類
（2）客戶和聯系人是一對多關系
- 客戶：與公司有業務往來，百度、新浪、360
- 聯系人：公司里面的員工，百度里面有很多員工，聯系員工
** 公司和公司員工的關系
- 客戶是一，聯系人是多
- 一個客戶里面有多個聯系人，一個聯系人只能屬於一個客戶
（3）一對多建表：通過外鍵建立關系
2 多對多
（1）訂單和商品關系，一個訂單里面有多個商品，一個商品屬於多個訂單
（2）用戶和角色多對多關系
- 用戶： 小王、小馬、小宋
- 角色：總經理、秘書、司機、保安
** 比如小王 可以 是總經理，可以是司機
** 比如小宋 可以是司機，可以是秘書，可以保安
** 比如小馬 可以是 秘書，可以是總經理
- 一個用戶里面可以有多個角色，一個角色里面可以有多個用戶
（3）多對多建表：創建第三張表維護關系
3 一對一
（1）在中國，一個男人只能有一個妻子，一個女人只能有一個丈夫
Hibernate的一對多操作（重點）
一對多映射配置（重點）
以客戶和聯系人為例：客戶是一，聯系人是多
第一步 創建兩個實體類，客戶和聯系人
第二步 讓兩個實體類之間互相表示
（1）在客戶實體類里面表示多個聯系人
- 一個客戶里面有多個聯系人
（2）在聯系人實體類里面表示所屬客戶
- 一個聯系人只能屬於一個客戶
第三步配置映射關系
（1）一般一個實體類對應一個映射文件
（2）把映射最基本配置完成
（3）在映射文件中，配置一對多關系
- 在客戶映射文件中，表示所有聯系人
- 在聯系人映射文件中，表示所屬客戶
第四步創建核心配置文件，把映射文件引入到核心配置文件中
一對多級聯操作
級聯操作
1 級聯保存
（1）添加一個客戶，為這個客戶添加多個聯系人
2 級聯刪除
（1）刪除某一個客戶，這個客戶里面的所有的聯系人也刪除
一對多級聯保存
1 添加客戶，為這個客戶添加一個聯系人
（1）復雜寫法：
//演示一對多級聯保存 @Test public void testAddDemo1() { SessionFactory sessionFactory = null; Session session = null; Transaction tx = null; try { //得到sessionFactory sessionFactory = HibernateUtils.getSessionFactory(); //得到session session = sessionFactory.openSession(); //開啟事務 tx = session.beginTransaction(); // 添加一個客戶，為這個客戶添加一個聯系人 //1 創建客戶和聯系人對象 Customer customer = new Customer(); customer.setCustName("傳智播客"); customer.setCustLevel("vip"); customer.setCustSource("網絡"); customer.setCustPhone("110"); customer.setCustMobile("999"); LinkMan linkman = new LinkMan(); linkman.setLkm_name("lucy"); linkman.setLkm_gender("男"); linkman.setLkm_phone("911"); //2 在客戶表示所有聯系人，在聯系人表示客戶 // 建立客戶對象和聯系人對象關系 //2.1 把聯系人對象 放到客戶對象的set集合里面 customer.getSetLinkMan().add(linkman); //2.2 把客戶對象放到聯系人里面 linkman.setCustomer(customer); //3 保存到數據庫 session.save(customer); session.save(linkman); //提交事務 tx.commit(); }catch(Exception e) { tx.rollback(); }finally { session.close(); //sessionFactory不需要關閉 sessionFactory.close(); } }
（2）簡化寫法
- 一般根據客戶添加聯系人
第一步 在客戶映射文件中進行配置
- 在客戶映射文件里面set標簽進行配置
第二步創建客戶和聯系人對象，只需要把聯系人放到客戶里面就可以了，最終只需要保存客戶就可以了
//演示一對多級聯保存 @Test public void testAddDemo2() { SessionFactory sessionFactory = null; Session session = null; Transaction tx = null; try { //得到sessionFactory sessionFactory = HibernateUtils.getSessionFactory(); //得到session session = sessionFactory.openSession(); //開啟事務 tx = session.beginTransaction(); // 添加一個客戶，為這個客戶添加一個聯系人 //1 創建客戶和聯系人對象 Customer customer = new Customer(); customer.setCustName("百度"); customer.setCustLevel("普通客戶"); customer.setCustSource("網絡"); customer.setCustPhone("110"); customer.setCustMobile("999"); LinkMan linkman = new LinkMan(); linkman.setLkm_name("小宏"); linkman.setLkm_gender("男"); linkman.setLkm_phone("911"); //2 把聯系人放到客戶里面 customer.getSetLinkMan().add(linkman); //3 保存客戶 session.save(customer); //提交事務 tx.commit(); }catch(Exception e) { tx.rollback(); }finally { session.close(); //sessionFactory不需要關閉 sessionFactory.close(); } }
一對多級聯刪除
1 刪除某個客戶，把客戶里面所有的聯系人刪除
2 具體實現
第一步 在客戶映射文件set標簽，進行配置
（1）使用屬性cascade屬性值 delete
第二步在代碼中直接刪除客戶
（1）根據id查詢對象，調用session里面delete方法刪除
一對多修改操作（inverse屬性）
2 inverse屬性
（1）因為hibernate雙向維護外鍵，在客戶和聯系人里面都需要維護外鍵，修改客戶時候修改一次外鍵，修改聯系人時候也修改一次外鍵，造成效率問題
（2）解決方式：讓其中的一方不維護外鍵
- 一對多里面，讓其中一方放棄外鍵維護
- 一個國家有總統，國家有很多人，總統不能認識國家所有人，國家所有人可以認識總統
（3）具體實現：
在放棄關系維護映射文件中，進行配置，在set標簽上使用inverse屬性
Hibernate多對多操作
多對多映射配置
以用戶和角色為例演示
第一步 創建實體類，用戶和角色
第二步 讓兩個實體類之間互相表示
（1）一個用戶里面表示所有角色，使用set集合
（2）一個角色有多個用戶，使用set集合
第三步配置映射關系
（1）基本配置
（2）配置多對多關系
- 在用戶里面表示所有角色，使用set標簽
- 在角色里面表示所有用戶，使用set標簽
第四步在核心配置文件中引入映射文件
多對多級聯保存
根據用戶保存角色
第一步 在用戶配置文件中set標簽進行配置，cascade值save-update
第二步寫代碼實現
（1）創建用戶和角色對象，把角色放到用戶里面，最終保存用戶就可以了
//演示多對多修級聯保存 @Test public void testSave() { SessionFactory sessionFactory = null; Session session = null; Transaction tx = null; try { //得到sessionFactory sessionFactory = HibernateUtils.getSessionFactory(); //得到session session = sessionFactory.openSession(); //開啟事務 tx = session.beginTransaction(); //添加兩個用戶，為每個用戶添加兩個角色 //1 創建對象 User user1 = new User(); user1.setUser_name("lucy"); user1.setUser_password("123"); User user2 = new User(); user2.setUser_name("mary"); user2.setUser_password("456"); Role r1 = new Role(); r1.setRole_name("總經理"); r1.setRole_memo("總經理"); Role r2 = new Role(); r2.setRole_name("秘書"); r2.setRole_memo("秘書"); Role r3 = new Role(); r3.setRole_name("保安"); r3.setRole_memo("保安"); //2 建立關系，把角色放到用戶里面 // user1 -- r1/r2 user1.getSetRole().add(r1); user1.getSetRole().add(r2); // user2 -- r2/r3 user2.getSetRole().add(r2); user2.getSetRole().add(r3); //3 保存用戶 session.save(user1); session.save(user2); //提交事務 tx.commit(); }catch(Exception e) { tx.rollback(); }finally { session.close(); //sessionFactory不需要關閉 sessionFactory.close(); } }
多對多級聯刪除（了解）
第一步 在set標簽進行配置，cascade值delete
第二步 刪除用戶
維護第三張表關系
1 用戶和角色多對多關系，維護關系通過第三張表維護
2 讓某個用戶有某個角色
第一步 根據id查詢用戶和角色
第二步 把角色放到用戶里面
（1）把角色對象放到用戶set集合
3 讓某個用戶沒有某個角色
第一步 根據id查詢用戶和角色
第二步從用戶里面把角色去掉
（1）從set集合里面把角色移除
Hibernate五種查詢方式
1 對象導航查詢
（1）根據id查詢某個客戶，再查詢這個客戶里面所有的聯系人
2 OID查詢
（1）根據id查詢某一條記錄，返回對象
3 HQL查詢
（1）Query對象，寫hql語句實現查詢
4 QBC查詢
（1）Criteria對象
5 本地sql查詢
（1）SQLQuery對象，使用普通sql實現查詢
對象導航查詢
1 查詢某個客戶里面所有聯系人過程，使用對象導航實現
2 代碼
OID查詢
1 根據id查詢記錄
（1）調用session里面的get方法實現
HQL查詢
1 hql：hibernate query language，hibernate提供一種查詢語言，hql語言和普通sql很相似，區別：普通sql操作數據庫表和字段，hql操作實體類和屬性
2 常用的hql語句
（1）查詢所有： from 實體類名稱
（2）條件查詢： from 實體類名稱 where 屬性名稱=?
（3）排序查詢： from 實體類名稱 order by 實體類屬性名稱 asc/desc
3 使用hql查詢操作時候，使用Query對象
（1）創建Query對象，寫hql語句
（2）調用query對象里面的方法得到結果
Query query = session.createQuery(
“from User user where user.group.name=‘zte’”);
查詢所有
1 查詢所有客戶記錄
（1）創建Query對象，寫hql語句
（2）調用query對象里面的方法得到結果
2 查詢所有： from 實體類名稱
條件查詢
1 hql條件查詢語句寫法：
（1） from 實體類名稱 where 實體類屬性名稱=? and實體類屬性名稱=?
from 實體類名稱 where 實體類屬性名稱 like ?
2 代碼
模糊查詢
排序查詢
1 hql排序語句寫法
（1）from 實體類名稱 order by 實體類屬性名稱 asc/desc
分頁查詢
1 mysql實現分頁
（1）使用關鍵字 limit實現
2 在hql中實現分頁
（1）在hql操作中，在語句里面不能寫limit，hibernate的Query對象封裝兩個方法實現分頁操作
投影查詢
1 投影查詢：查詢不是所有字段值，而是部分字段的值
2 投影查詢hql語句寫法：
（1）select 實體類屬性名稱1, 實體類屬性名稱2 from 實體類名稱
（2）select 后面不能寫 * ，不支持的
3 具體實現
聚集函數使用
1 常用的聚集函數
（1）count、sum、avg、max、min
2 hql聚集函數語句寫法
（1）查詢表記錄數
- select count(*) from 實體類名稱
QBC查詢
1 使用hql查詢需要寫hql語句實現，但是使用qbc時候，不需要寫語句了，使用方法實現
2 使用qbc時候，操作實體類和屬性
3 使用qbc，使用Criteria對象實現
查詢所有
1 創建Criteria對象
2 調用方法得到結果
條件查詢
1 沒有語句，使用封裝的方法實現
排序查詢
分頁查詢
開始位置計算公式：（當前頁-1）*每頁記錄數
統計查詢
離線查詢
1 servlet調用service，service調用dao
（1）在dao里面對數據庫crud操作
（2）在dao里面使用hibernate框架，使用hibernate框架時候，調用session里面的方法實現功能
本地SQL查詢
SQLQuery sql=session.createSQLQuery("select * from user where id=1 ");
sql.addEntity(User.class);
List<User> list=sql.list();
System.out.println(list);
HQL多表查詢
Mysql里面多表查詢
1 內連接
2 左外連接
3 右外連接
HQL實現多表查詢
Hql多表查詢
（1）內連接
（2）左外連接
（3）右外連接
（4）迫切內連接
（5）迫切左外連接
HQL內連接
1 內連接查詢hql語句寫法：以客戶和聯系人為例
（1）from Customer c inner join c.setLinkMan
返回list，list里面每部分是數組形式
2 演示迫切內連接
（1）迫切內連接和內連接底層實現一樣的
（2）區別：使用內連接返回list中每部分是數組，迫切內連接返回list每部分是對象
（3）hql語句寫法
- from Customer c inner join fetch c.setLinkMan
HQL左外連接
1 左外連接hql語句：
（1）from Customer c left outer join c.setLinkMan
（2）迫切左外連接from Customer c left outer join fetch c.setLinkMan
2 左外連接返回list中每部分是數組，迫切左外連接返回list每部分是對象
1 右外連接hql語句：
（1）from Customer c right outer join c.setLinkMan
Hibernate檢索策略
檢索策略的概念
1 hibernate檢索策略分為兩類：
（1）立即查詢：根據id查詢，調用get方法，一調用get方法馬上發送語句查詢數據庫
（2）延遲查詢：根據id查詢，還有load方法，調用load方法不會馬上發送語句查詢數據，只有得到對象里面的值時候才會發送語句查詢數據庫
2 延遲查詢分成兩類：
（1）類級別延遲：根據id查詢返回實體類對象，調用load方法不會馬上發送語句
（2）關聯級別延遲：
- 查詢某個客戶，再查詢這個客戶的所有聯系人，查詢客戶的所有聯系人的過程是否需要延遲，這個過程稱為關聯級別延遲
關聯級別延遲操作
1 在映射文件中進行配置實現
（1）根據客戶得到所有的聯系人，在客戶映射文件中配置
2 在set標簽上使用屬性
（1）fetch：值select（默認）
（2）lazy：值
- true：延遲（默認）
- false：不延遲
- extra：極其延遲
（1）調用get之后，發送兩條sql語句
（1）極其懶惰，要什么值給什么值
批量抓取
1 查詢所有的客戶，返回list集合，遍歷list集合，得到每個客戶，得到每個客戶的所有聯系人
（1）上面操作代碼，發送多條sql語句
2 在客戶的映射文件中，set標簽配置
（1）batch-size值，值越大發送語句越少
