主要內容
1. Hibernate關聯關係映射
2. Hibernate的查詢方式
3. Hibernate的查詢策略
Hibernate的關聯關係映射之一對多映射（重點）
1. JavaWEB中一對多的設計及其建表原則
2. 編寫客戶和聯繫人的JavaBean程序（注意一對多的編寫規則）
* 客戶的JavaBean如下
public class Customer {
private Long cust_id;
private String cust_name;
private Long cust_user_id;
private Long cust_create_id;
private String cust_source;
private String cust_industry;
private String cust_level;
private String cust_linkman;
private String cust_phone;
private String cust_mobile;
private Set<Linkman> linkmans = new HashSet<Linkman>();
}
* 聯繫人的JavaBean如下
public class Linkman {
private Long lkm_id;
private String lkm_name;
private String lkm_gender;
private String lkm_phone;
private String lkm_mobile;
private String lkm_email;
private String lkm_qq;
private String lkm_position;
private String lkm_memo;
private Customer customer;
}
3. 編寫客戶和聯繫人的映射配置文件（注意一對多的配置編寫）
* 客戶的映射配置文件如下
<class name="com.itheima.domain.Customer" table="cst_customer">
<id name="cust_id" column="cust_id">
<generator class="native"/>
</id>
<property name="cust_name" column="cust_name"/>
<property name="cust_user_id" column="cust_user_id"/>
<property name="cust_create_id" column="cust_create_id"/>
<property name="cust_source" column="cust_source"/>
<property name="cust_industry" column="cust_industry"/>
<property name="cust_level" column="cust_level"/>
<property name="cust_linkman" column="cust_linkman"/>
<property name="cust_phone" column="cust_phone"/>
<property name="cust_mobile" column="cust_mobile"/>
<set name="linkmans">
<key column="lkm_cust_id"/>
<one-to-many class="com.itheima.domain.Linkman"/>
</set>
</class>
* 聯繫人的映射配置文件如下
<class name="com.itheima.domain.Linkman" table="cst_linkman">
<id name="lkm_id" column="lkm_id">
<generator class="native"/>
</id>
<property name="lkm_name" column="lkm_name"/>
<property name="lkm_gender" column="lkm_gender"/>
<property name="lkm_phone" column="lkm_phone"/>
<property name="lkm_mobile" column="lkm_mobile"/>
<property name="lkm_email" column="lkm_email"/>
<property name="lkm_qq" column="lkm_qq"/>
<property name="lkm_position" column="lkm_position"/>
<property name="lkm_memo" column="lkm_memo"/>
<many-to-one name="customer" class="com.itheima.domain.Customer" column="lkm_cust_id"/>
</class>
4.注意上面配置文件的標籤，一端爲set標籤，多端爲mang-to-one標籤
保存客戶和聯繫人的數據
1.進行雙向關聯完成數據的保存
級聯保存
1. 測試：如果現在代碼只插入其中的一方的數據
* 如果只保存其中的一方的數據，那麼程序會拋出異常。
* 如果想完成只保存一方的數據，並且把相關聯的數據都保存到數據庫中，那麼需要配置級聯！！
* 級聯保存是方向性
2. 級聯保存效果
* 級聯保存：保存一方同時可以把關聯的對象也保存到數據庫中！！
* 使用cascade="save-update"
/**
* 級聯保存:保存聯繫人 關聯客戶
*/
@Test
public void run4(){
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
//保存客戶和聯繫人的數據
Customer c1 = new Customer();
c1.setCust_name("美美");
Linkman l1 = new Linkman();
l1.setLkm_name("熊大");
Linkman l2 = new Linkman();
l2.setLkm_name("熊二");
//使用聯繫人關聯客戶
l1.setCustomer(c1);
l2.setCustomer(c1);
session.save(l1);
session.save(l2);
tr.commit();
}
級聯刪除
1. 先來給大家在數據庫中演示含有外鍵的刪除客戶功能，那麼SQL語句是會報出錯誤的
* 例如：delete from customers where cid = 1;
2. 如果使用Hibernate框架直接刪除客戶的時候，測試發現是可以刪除的
3. 上述的刪除是普通的刪除，那麼也可以使用級聯刪除，注意：級聯刪除也是有方向性的！！
* <many-to-one cascade="delete" />
總結：
要想達到級聯保存的效果，需要在“多”的一方配置cascade=“save-update”；“一”的一方配置inverse=“true”
要想達到級聯刪除的結果，需要在“多”的一方配置cascade=“delete”
級聯的取值（cascade的取值）和孤兒刪除
1. 需要大家掌握的取值如下
* none -- 不使用級聯
* save-update -- 級聯保存或更新
* delete -- 級聯刪除
* delete-orphan -- 孤兒刪除.(注意：只能應用在一對多關係)
* all -- 除了delete-orphan的所有情況.（包含save-update delete）
* all-delete-orphan -- 包含了delete-orphan的所有情況.（包含save-update delete delete-orphan）
2. 孤兒刪除（孤子刪除），只有在一對多的環境下才有孤兒刪除
* 在一對多的關係中,可以將一的一方認爲是父方.將多的一方認爲是子方.孤兒刪除:在解除了父子關係的時候.將子方記錄就直接刪除。
* <many-to-one cascade="delete-orphan" />
某一方放棄外鍵的維護，爲多對多做準備
1. 先測試雙方都維護外鍵的時候，會產生多餘的SQL語句。
* 想修改客戶和聯繫人的關係，進行雙向關聯，雙方都會維護外鍵，會產生多餘的SQL語句。
* 產生的原因：session的一級緩存中的快照機制，會讓雙方都更新數據庫，產生了多餘的SQL語句。
2. 如果不想產生多餘的SQL語句，那麼需要一方來放棄外鍵的維護！（主席和人民的例子）
* 在<set>標籤上配置一個inverse=”true”.true:放棄.false:不放棄.默認值是false
* <inverse="true">
cascade和inverse的區別
1. cascade用來級聯操作（保存、修改和刪除）
2. inverse用來維護外鍵的
Hibernate的關聯關係映射之多對多映射
多對多JavaBean的編寫
1. 編寫用戶和角色的JavaBean
* 用戶的JavaBean代碼如下
public class User {
private Long user_id;
private String user_code;
private String user_name;
private String user_password;
private String user_state;
private Set<Role> roles = new HashSet<Role>();
}
* 角色的JavaBean代碼如下
public class Role {
private Long role_id;
private String role_name;
private String role_memo;
private Set<User> users = new HashSet<User>();
}
2. 用戶和角色的映射配置文件如下
* 用戶的映射配置文件如下
<class name="com.oracle.domain.User" table="sys_user">
<id name="user_id" column="user_id">
<generator class="native"/>
</id>
<property name="user_code" column="user_code"/>
<property name="user_name" column="user_name"/>
<property name="user_password" column="user_password"/>
<property name="user_state" column="user_state"/>
<set name="roles" table="sys_user_role">
<key column="user_id"/>
<many-to-many class="com.oracle.domain.Role" column="role_id"/>
</set>
</class>
* 角色的映射配置文件如下
<class name="com.oracle.domain.Role" table="sys_role">
<id name="role_id" column="role_id">
<generator class="native"/>
</id>
<property name="role_name" column="role_name"/>
<property name="role_memo" column="role_memo"/>
<set name="users" table="sys_user_role">
<key column="role_id"/>
<many-to-many class="com.oracle.domain.User" column="user_id"/>
</set>
</class>
3. 多對多進行雙向關聯的時候:必須有一方去放棄外鍵維護權
多對多的級聯保存與刪除
1. 級聯保存
* <set cascade="save-update"> 與前面一對多類似
2. 級聯刪除
在多對多中很少使用
Hibernate的查詢方式
Hibernate框架的查詢方式
1. 唯一標識OID的檢索方式
* session.get(對象.class,OID)
2. 對象的導航的方式
3. HQL的檢索方式
* Hibernate Query Language -- Hibernate的查詢語言
4. QBC的檢索方式
* Query By Criteria -- 條件查詢
5. SQL檢索方式（瞭解）
* 本地的SQL檢索
HQL的查詢方式概述
1. HQL的介紹
* HQL(Hibernate Query Language) 是面向對象的查詢語言, 它和 SQL 查詢語言有些相似
* 在 Hibernate 提供的各種檢索方式中, HQL 是使用最廣的一種檢索方式
2. HQL與SQL的關係
* HQL 查詢語句是面向對象的,Hibernate負責解析HQL查詢語句, 然後根據對象-關係映射文件中的映射信息, 把 HQL 查詢語句翻譯成相應的 SQL 語句.
* HQL 查詢語句中的主體是域模型中的類及類的屬性
* SQL 查詢語句是與關係數據庫綁定在一起的. SQL查詢語句中的主體是數據庫表及表的字段
HQL的查詢演示
1. HQL基本的查詢格式
* 支持方法鏈的編程，即直接調用list()方法
* 簡單的代碼如下
* session.createQuery("from Customer").list();
2. 使用別名的方式
* 可以使用別名的方式
* session.createQuery("from Customer c").list();
* session.createQuery("select c from Customer c").list();
3. 排序查詢
* 排序查詢和SQL語句中的排序的語法是一樣的
* 升序
* session.createQuery("from Customer order by cust_id").list();
* 降序
* session.createQuery("from Customer order by cust_id desc").list();
4. 分頁查詢
* Hibernate框架提供了分頁的方法，咱們可以調用方法來完成分頁
* 兩個方法如下
* setFirstResult(a) -- 從哪條記錄開始，如果查詢是從第一條開啓，值是0
* setMaxResults(b) -- 每頁查詢的記錄條數
* 演示代碼如下
* List<LinkMan> list = session.createQuery("from LinkMan").setFirstResult(0).setMaxResults().list();
5. 帶條件的查詢
* setParameter("?號的位置，默認從0開始","參數的值"); 不用考慮參數的具體類型
* 按位置綁定參數的條件查詢（指定下標值，默認從0開始）
* 按名稱綁定參數的條件查詢（HQL語句中的 ? 號換成 :名稱 的方式）
* 例如代碼如下
Query query = session.createQuery("from Linkman where lkm_name like ? order by lkm_id desc");
query.setFirstResult(0).setMaxResults(3);
query.setParameter(0, "%熊%");
List<Linkman> list = query.list();
for (Linkman linkman : list) {
System.out.println(linkman);
}
HQL的投影查詢
1. 投影查詢就是想查詢某一字段的值或者某幾個字段的值
2. 投影查詢的案例
* 如果查詢多個字段，例如下面這種方式
List<Object[]> list = session.createQuery("select c.cust_name,c.cust_level from Customer c").list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
* 如果查詢兩個字段，也可以把這兩個字段封裝到對象中
* 先在持久化類中提供對應字段的構造方法
* 使用下面這種HQL語句的方式
List<Customer> list = session.createQuery("select new Customer(c.cust_name,c.cust_level) from Customer c").list();
for (Customer customer : list) {
System.out.println(customer);
}
聚合函數查詢
1. 獲取總的記錄數
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Number> list = session.createQuery("select count(c) from Customer c").list();
Long count = list.get(0).longValue();
System.out.println(count);
tr.commit();
2. 獲取某一列數據的和
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Number> list = session.createQuery("select sum(c.cust_id) from Customer c").list();
Long count = list.get(0).longValue();
System.out.println(count);
tr.commit();
QBC檢索方式
0. QBC：Query By Criteria 按條件進行查詢
1. 簡單查詢，使用的是Criteria接口
List<Customer> list = session.createCriteria(Customer.class).list();
for (Customer customer : list) {
System.out.println(customer);
}
2. 排序查詢
* 需要使用addOrder()的方法來設置參數，參數使用org.hibernate.criterion.Order對象
* 具體代碼如下：
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 設置排序
criteria.addOrder(Order.desc("lkm_id"));
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
System.out.println(linkman);
}
tr.commit();
3. 分頁查詢
* QBC的分頁查詢也是使用兩個方法
* setFirstResult();
* setMaxResults();
* 代碼如下;
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 設置排序
criteria.addOrder(Order.desc("lkm_id"));
criteria.setFirstResult(0);
criteria.setMaxResults(3);
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
System.out.println(linkman);
}
tr.commit();
4. 條件查詢（Criterion是查詢條件的接口，Restrictions類是Hibernate框架提供的工具類，使用該工具類來設置查詢條件）
* 條件查詢使用Criteria接口的add方法，用來傳入條件。
* 使用Restrictions的添加條件的方法，來添加條件，例如：
* Restrictions.eq -- 相等
* Restrictions.gt -- 大於號
* Restrictions.ge -- 大於等於
* Restrictions.lt -- 小於
* Restrictions.le -- 小於等於
* Restrictions.between -- 在之間
* Restrictions.like -- 模糊查詢
* Restrictions.in -- 範圍
* Restrictions.and -- 並且
* Restrictions.or -- 或者
* 測試代碼如下
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
// 設置排序
criteria.addOrder(Order.desc("lkm_id"));
// 設置查詢條件
criteria.add(Restrictions.or(Restrictions.eq("lkm_gender", "男"), Restrictions.gt("lkm_id", 3L)));
List<Linkman> list = criteria.list();
for (Linkman linkman : list) {
System.out.println(linkman);
}
tr.commit();
5. 聚合函數查詢（Projection的聚合函數的接口，而Projections是Hibernate提供的工具類，使用該工具類設置聚合函數查詢）
* 使用QBC的聚合函數查詢，需要使用criteria.setProjection()方法
* 具體的代碼如下
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Criteria criteria = session.createCriteria(Linkman.class);
criteria.setProjection(Projections.rowCount());
List<Number> list = criteria.list();
Long count = list.get(0).longValue();
System.out.println(count);
tr.commit();
離線條件查詢
1. 離線條件查詢使用的是DetachedCriteria接口進行查詢，離線條件查詢對象在創建的時候，不需要使用Session對象，只是在查詢的時候使用Session對象即可。
2. 創建離線條件查詢對象
* DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
3. 具體的代碼如下
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
DetachedCriteria criteria = DetachedCriteria.forClass(Linkman.class);
// 設置查詢條件
criteria.add(Restrictions.eq("lkm_gender", "男"));
// 查詢數據
List<Linkman> list = criteria.getExecutableCriteria(session).list();
for (Linkman linkman : list) {
System.out.println(linkman);
}
tr.commit();
SQL查詢方式（瞭解）
1. 基本語法
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
SQLQuery sqlQuery = session.createSQLQuery("select * from cst_linkman where lkm_gender = ?");
sqlQuery.setParameter(0,"男");
sqlQuery.addEntity(Linkman.class);
List<Linkman> list = sqlQuery.list();
System.out.println(list);
tr.commit();
HQL多表查詢
1. 多表的查詢進來使用HQL語句進行查詢，HQL語句和SQL語句的查詢語法比較類似。
* 內連接查詢
* 顯示內連接
* select * from customers c inner join orders o on c.cid = o.cno;
* 隱式內連接
* select * from customers c,orders o where c.cid = o.cno;
* 外連接查詢
* 左外連接
* select * from customers c left join orders o on c.cid = o.cno;
* 右外連接
* select * from customers c right join orders o on c.cid = o.cno;
2. HQL的多表查詢
* 迫切和非迫切：
* 非迫切返回結果是Object[]
* 迫切連接返回的結果是對象，把客戶的信息封裝到客戶的對象中，把訂單的信息封裝到客戶的Set集合中。
3. 內連接查詢
* 內連接使用 inner join ，默認返回的是Object數組
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Object[]> list = session.createQuery("from Customer c inner join c.linkmans").list();
for (Object[] objects : list) {
System.out.println(Arrays.toString(objects));
}
tr.commit();
* 迫切內連接:inner join fetch ，返回的是實體對象
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Customer> list = session.createQuery("from Customer c inner join fetch c.linkmans").list();
Set<Customer> set = new HashSet<Customer>(list);
for (Customer customer : set) {
System.out.println(customer);
}
tr.commit();
4. 左外連接查詢
* 左外連接: 封裝成List<Object[]>
* 迫切左外連接
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
List<Customer> list = session.createQuery("from Customer c left join fetch c.linkmans").list();
Set<Customer> set = new HashSet<Customer>(list);
for (Customer customer : set) {
System.out.println(customer);
}
tr.commit();
對查詢功能優化
延遲加載
1. 延遲加載先獲取到代理對象，當真正使用到該對象中的屬性的時候，纔會發送SQL語句，是Hibernate框架提升性能的方式
2. 類級別的延遲加載
* Session對象的load方法默認就是延遲加載
* Customer c = session.load(Customer.class, 1L);沒有發送SQL語句，當使用該對象的屬性時，才發送SQL語句
* 使類級別的延遲加載失效
* 在<class>標籤上配置lazy=”false”
* Hibernate.initialize(Object proxy);
3. 關聯級別的延遲加載（查詢某個客戶，當查看該客戶下的所有聯繫人是是否是延遲加載）
* 默認是延遲加載
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
Customer c = session.get(Customer.class, 1L);
System.out.println("=============");
System.out.println(c.getLinkmans().size());
tr.commit();
Hibernate框架的查詢策略
1. 查詢策略：使用Hibernate查詢一個對象的時候，查詢其關聯對象.應該如何查詢.是Hibernate的一種優化手段!!!
2. Hibernate框架的檢索策略解決的問題
* 查詢的時機
Customer c1 = (Customer) session.get(Customer.class, 1);
System.out.println(c1.getLinkmans().size());
* lazy屬性解決查詢的時機的問題，需要配置是否採用延遲加載！！
* 查詢的語句形式
List<Customer> list = session.createQuery("from Customer").list();
for(Customer c : list){
System.out.println(c.getLinkmans());
}
* fetch屬性就可以解決查詢語句的形式的問題！！
在set標籤上配置策略
1. 在<set>標籤上使用fetch和lazy屬性
* fetch的取值 -- 控制SQL語句生成的格式
* select -- 默認值.發送查詢語句
* join -- 連接查詢.發送的是一條迫切左外連接!!!配置了join.lazy就失效了
* subselect -- 子查詢.發送一條子查詢查詢其關聯對象.(需要使用list()方法進行測試)
* lazy的取值 -- 查找關聯對象的時候是否採用延遲!
* true -- 默認.延遲
* false -- 不延遲
* extra -- 及其懶惰
2. set標籤上的默認值是fetch="select"和lazy="true"
3. 總結：Hibernate框架都採用了默認值，開發中基本上使用的都是默認值。特殊的情況。
在man-to-one標籤上配置策略
1. 在<many-to-one>標籤上使用fetch和lazy屬性
* fetch的取值 -- 控制SQL的格式.
* select -- 默認。發送基本select語句查詢
* join -- 發送迫切左外連接查詢
* lazy的取值 -- 控制加載關聯對象是否採用延遲.
* false -- 不採用延遲加載.
* proxy -- 默認值.代理.現在是否採用延遲.
* 由另一端的<class>上的lazy確定.如果這端的class上的lazy=”true”.proxy的值就是true(延遲加載).
* 如果class上lazy=”false”.proxy的值就是false(不採用延遲.)
2. 在<many-to-one>標籤上的默認值是fetch="select"和proxy