1.集合映射
Hibernate集合映射里面有set,list,map，具體的用法可以參見如下例
需求：一個用戶對應多個地址
User.java
// javabean設計
public class User {
private int userId;
private String userName;
// 一個用戶，對應的多個地址
private Set<String> address;
private List<String> addressList = new ArrayList<String>();
//private String[] addressArray; // 映射方式和list一樣 <array name=""></array>
private Map<String,String> addressMap = new HashMap<String, String>();
// get,set省略...
}
User.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.a_collection">
<class name="User" table="t_user">
<id name="userId" column="id">
<generator class="native"></generator>
</id>
<property name="userName"></property>
<!--
set集合屬性的映射
name 指定要映射的set集合的屬性
table 集合屬性要映射到的表
key 指定集合表(t_address)的外鍵字段
element 指定集合表的其他字段
type 元素類型，一定要指定
-->
<set name="address" table="t_address">
<key column="uid"></key>
<element column="address" type="string"></element>
</set>
<!--
list集合映射
list-index 指定的是排序列的名稱 (因為要保證list集合的有序)
-->
<list name="addressList" table="t_addressList">
<key column="uid"></key>
<list-index column="idx"></list-index>
<element column="address" type="string"></element>
</list>
<!--
map集合的映射
key 指定外鍵字段
map-key 指定map的key
element 指定map的value
-->
<map name="addressMap" table="t_addressMap">
<key column="uid"></key>
<map-key column="shortName" type="string" ></map-key>
<element column="address" type="string" ></element>
</map>
</class>
</hibernate-mapping>
set測試
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(User.class) // 測試時候使用
.buildSessionFactory();
}
// 保存set
@Test
public void testSaveSet() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
//-- 保存
Set<String> addressSet = new HashSet<String>();
addressSet.add("廣州");
addressSet.add("深圳");
// 用戶對象
User user = new User();
user.setUserName("Jack");
user.setAddress(addressSet);
// 保存
session.save(user);
session.getTransaction().commit();
session.close();
}
效果如下：
Hibernate: insert into t_user (userName) values (?)
Hibernate: insert into t_address (uid, address) values (?, ?)
Hibernate: insert into t_address (uid, address) values (?, ?)
list測試
// 保存list/map
@Test
public void testSaveList() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
User user = new User();
user.setUserName("Tom");
// 用戶對象 -- list
user.getAddressList().add("廣州");
user.getAddressList().add("深圳");
// 保存
session.save(user);
session.getTransaction().commit();
session.close();
}
效果如下：
Hibernate: insert into t_user (userName) values (?)
Hibernate: insert into t_addressList (uid, idx, address) values (?, ?, ?)
Hibernate: insert into t_addressList (uid, idx, address) values (?, ?, ?)
map測試
@Test
public void testSaveMap() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
User user = new User();
user.setUserName("Tom");
// 用戶對象 -- Map
user.getAddressMap().put("A0001", "廣州");
user.getAddressMap().put("A0002", "深圳");
// 保存
session.save(user);
session.getTransaction().commit();
session.close();
}
效果如下：
Hibernate: insert into t_user (userName) values (?)
Hibernate: insert into t_addressMap (uid, shortName, address) values (?, ?, ?)
Hibernate: insert into t_addressMap (uid, shortName, address) values (?, ?, ?)
獲取數據測試
@Test
public void testGet() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
// 獲取
User user = (User) session.get(User.class, 3); // 及時加載
System.out.println(user.getUserId());
System.out.println(user.getUserName());
// 當查詢用戶，同時可以獲取用戶關聯的list集合的數據 (因為有正確映射)
// 當使用到集合數據的使用，才向數據庫發送執行的sql語句 (懶加載)
System.out.println(user.getAddressList());
session.getTransaction().commit();
session.close();
}
效果如下：
Hibernate: select user0_.id as id0_0_, user0_.userName as userName0_0_ from t_user user0_ where user0_.id=?
3
Tom
Hibernate: select addresslis0_.uid as uid0_0_, addresslis0_.address as address0_, addresslis0_.idx as idx0_ from t_addressList addresslis0_ where addresslis0_.uid=?
[廣州, 深圳]
2.關聯映射
2.1 一對多與多對一
需求1：部門與員工
一個部門有多個員工; 【一對多】
多個員工，屬于一個部門 【多對一】
Employee.java
public class Employee {
private int empId;
private String empName;
private double salary;
// 【多對一】員工與部門
private Dept dept;
}
Employee.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.b_one2Many">
<class name="Employee" table="t_employee">
<id name="empId">
<generator class="native"></generator>
</id>
<property name="empName" length="20"></property>
<property name="salary" type="double"></property>
<!--
多對一映射配置
Employee 映射關鍵點：
1. 映射的部門屬性 ： dept
2. 映射的部門屬性，對應的外鍵字段: dept_id
3. 部門的類型
-->
<many-to-one name="dept" column="dept_id" class="Dept"></many-to-one>
</class>
</hibernate-mapping>
Dept.java
public class Dept {
private int deptId;
private String deptName;
// 【一對多】 部門對應的多個員工
private Set<Employee> emps = new HashSet<Employee>();
}
Dept.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.b_one2Many">
<class name="Dept" table="t_dept">
<id name="deptId">
<generator class="native"></generator>
</id>
<property name="deptName" length="20"></property>
<!--
一對多關聯映射配置 （通過部門管理到員工）
Dept 映射關鍵點：
1. 指定 映射的集合屬性： "emps"
2. 集合屬性對應的集合表： "t_employee"
3. 集合表的外鍵字段 "t_employee. dept_id"
4. 集合元素的類型
inverse=false set集合映射的默認值； 表示有控制權
-->
<set name="emps" cascade="save-update,delete" table="t_employee" inverse="true"> <!-- table="t_employee" -->
<key column="dept_id"></key>
<one-to-many class="Employee"/>
</set>
</class>
</hibernate-mapping>
測試
保存：
public class App1_save {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Dept.class)
.addClass(Employee.class) // 測試時候使用
.buildSessionFactory();
}
// 保存， 部門方 【一的一方法操作】
@Test
public void save() {
Session session = sf.openSession();
session.beginTransaction();
// 部門對象
Dept dept = new Dept();
dept.setDeptName("應用開發部");
// 員工對象
Employee emp_zs = new Employee();
emp_zs.setEmpName("張三");
Employee emp_ls = new Employee();
emp_ls.setEmpName("李四");
// 關系
dept.getEmps().add(emp_zs);
dept.getEmps().add(emp_ls);
// 保存
session.save(emp_zs);
session.save(emp_ls);
session.save(dept); // 保存部門，部門下所有的員工
session.getTransaction().commit();
session.close();
/*
* 結果 當Dept.hbm.xml里的inverse屬性為false時
* Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
Hibernate: insert into t_dept (deptName) values (?)
Hibernate: update t_employee set deptId=? where empId=? 維護員工引用的部門的id
Hibernate: update t_employee set deptId=? where empId=?
*/
}
// 【推薦】 保存， 部員方 【多的一方法操作】
@Test
public void save2() {
Session session = sf.openSession();
session.beginTransaction();
// 部門對象
Dept dept = new Dept();
dept.setDeptName("綜合部");
// 員工對象
Employee emp_zs = new Employee();
emp_zs.setEmpName("張三");
Employee emp_ls = new Employee();
emp_ls.setEmpName("李四");
// 關系
emp_zs.setDept(dept);
emp_ls.setDept(dept);
// 保存
session.save(dept); // 先保存一的方法
session.save(emp_zs);
session.save(emp_ls);// 再保存多的一方，關系回自動維護(映射配置完)
session.getTransaction().commit();
session.close();
/*
* 結果 當Dept.hbm.xml里的inverse屬性為true時此方式和上面無差別
* Hibernate: insert into t_dept (deptName) values (?)
Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
Hibernate: insert into t_employee (empName, salary, dept_id) values (?, ?, ?)
少生成2條update sql
*/
}
}
獲取：
@Test
public void get() {
Session session = sf.openSession();
session.beginTransaction();
// 通過部門方，獲取另外一方
// Dept dept = (Dept) session.get(Dept.class, 1);
// System.out.println(dept.getDeptName());
// System.out.println(dept.getEmps());// 懶加載
// 通過員工房，獲取另外一方
Employee emp = (Employee) session.get(Employee.class, 1);
System.out.println(emp.getEmpName());
System.out.println(emp.getDept().getDeptName());
session.getTransaction().commit();
session.close();
}
控制反轉：
package cn.itcast.b_one2Many;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;
import cn.itcast.a_collection.User;
public class App3_inverse {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Dept.class)
.addClass(Employee.class) // 測試時候使用
.buildSessionFactory();
}
// 1. 保存數據
@Test
public void save() {
Session session = sf.openSession();
session.beginTransaction();
// 部門對象
Dept dept = new Dept();
dept.setDeptName("應用開發部");
// 員工對象
Employee emp_zs = new Employee();
emp_zs.setEmpName("張三");
Employee emp_ls = new Employee();
emp_ls.setEmpName("李四");
// 關系
dept.getEmps().add(emp_zs);
dept.getEmps().add(emp_ls); // inverse=true, 不會設置關聯。
// 此時的關聯應該通過員工方維護。
// 保存
session.save(emp_zs);
session.save(emp_ls);
session.save(dept); // 保存部門，部門下所有的員工
session.getTransaction().commit();
session.close();
}
//2. 是否設置inverse，對獲取數據的影響？ 無.
@Test
public void get() {
Session session = sf.openSession();
session.beginTransaction();
Dept dept = (Dept) session.get(Dept.class, 1);
System.out.println(dept.getDeptName());
System.out.println(dept.getEmps());
session.getTransaction().commit();
session.close();
}
// 3. 是否設置inverse，對解除關聯關系影響？
// inverse=false， 可以解除關聯
// inverse=true， 當前方(部門)沒有控制權，不能解除關聯關系(不會生成update語句,也不會報錯)
//
@Test
public void removeRelation() {
Session session = sf.openSession();
session.beginTransaction();
// 獲取部門
Dept dept = (Dept) session.get(Dept.class, 2);
// 解除關系
dept.getEmps().clear();
session.getTransaction().commit();
session.close();
}
//3. 是否設置inverse屬性，在刪除數據中對關聯關系的影響?
// inverse=false, 有控制權， 可以刪除。先清空外鍵引用，再刪除數據。
// inverse=true, 沒有控制權: 如果刪除的記錄有被外鍵引用，會報錯，違反主外鍵引用約束！
// 如果刪除的記錄沒有被引用，可以直接刪除。
@Test
public void deleteData() {
Session session = sf.openSession();
session.beginTransaction();
// 查詢部門
Dept dept = (Dept) session.get(Dept.class, 8);
session.delete(dept);
session.getTransaction().commit();
session.close();
}
}
級聯刪除：
public class App4_cascade {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Dept.class)
.addClass(Employee.class) // 測試時候使用
.buildSessionFactory();
}
// 級聯保存
@Test
public void save() {
Session session = sf.openSession();
session.beginTransaction();
// 部門對象
Dept dept = new Dept();
dept.setDeptName("財務部");
// 員工對象
Employee emp_zs = new Employee();
emp_zs.setEmpName("張三");
Employee emp_ls = new Employee();
emp_ls.setEmpName("李四");
// 關系
dept.getEmps().add(emp_zs);
dept.getEmps().add(emp_ls);
// 保存
// session.save(emp_zs);
// session.save(emp_ls);
session.save(dept); // 需要設置級聯保存； 保存部門，部門下所有的員工
session.getTransaction().commit();
session.close();
}
// 級聯刪除
@Test
public void delete() {
Session session = sf.openSession();
session.beginTransaction();
Dept dept = (Dept) session.get(Dept.class,7);
session.delete(dept); // 級聯刪除
session.getTransaction().commit();
session.close();
}
}
總結：
在一對多與多對一的關聯關系中，保存數據最好的通過多的一方來維護關系，這樣可以減少update語句的生成，從而提高hibernate的執行效率！
配置一對多與多對一，這種叫“雙向關聯”
只配置一對多， 叫“單項一對多”
只配置多對一， 叫“單項多對一”
注意：
配置了哪一方，哪一方才有維護關聯關系的權限！
Inverse屬性
Inverse屬性，是在維護關聯關系的時候起作用的。
表示控制權是否轉移。(在一的一方起作用)
Inverse , 控制反轉。
Inverse = false 不反轉； 當前方有控制權
True 控制反轉； 當前方沒有控制權
維護關聯關系中，是否設置inverse屬性：
1. 保存數據
有影響。
如果設置控制反轉,即inverse=true, 然后通過部門方維護關聯關系。在保存部門的時候，同時保存員工， 數據會保存，但關聯關系不會維護。即外鍵字段為NULL
2. 獲取數據
無。
3. 解除關聯關系？
有影響。
inverse=false， 可以解除關聯
inverse=true， 當前方(部門)沒有控制權，不能解除關聯關系
(不會生成update語句,也不會報錯)
4. 刪除數據對關聯關系的影響？
有影響。
inverse=false, 有控制權， 可以刪除。先清空外鍵引用，再刪除數據。
inverse=true, 沒有控制權: 如果刪除的記錄有被外鍵引用，會報錯，違反主外鍵引用約束！ 如果刪除的記錄沒有被引用，可以直接刪除。
cascade 屬性
cascade 表示級聯操作 【可以設置到一的一方或多的一方】
none 不級聯操作， 默認值
save-update 級聯保存或更新
delete 級聯刪除
save-update,delete 級聯保存、更新、刪除
all
注意：inverse表示的是對象和關系之間的聯系，面cascade表示的是對象與對象之間的關系，二者區別參考鏈接：
一對多（多對一）關系中的inverse和cascade屬性
2.2 多對多
項目與開發員工
一個項目，有多個開發人員！
一個開發人員，參與多個項目！ 【多對多】
Developer.java
public class Developer {
private int d_id;
private String d_name;
// 開發人員，參數的多個項目
private Set<Project> projects = new HashSet<Project>();
}
Developer.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.c_many2many">
<class name="Developer" table="t_developer">
<id name="d_id">
<generator class="native"></generator>
</id>
<property name="d_name" length="20"></property>
<!--
多對多映射配置： 員工方
name 指定映射的集合屬性
table 集合屬性對應的中間表
key 指定中間表的外鍵字段(引用當前表t_developer主鍵的外鍵字段)
many-to-many
column 指定外鍵字段對應的項目字段
class 集合元素的類型
-->
<set name="projects" table="t_relation">
<key column="did"></key>
<many-to-many column="prjId" class="Project"></many-to-many>
</set>
</class>
</hibernate-mapping>
** Project .java**
public class Project {
private int prj_id;
private String prj_name;
// 項目下的多個員工
private Set<Developer> developers = new HashSet<Developer>();
}
Project.hbm.xml
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.itcast.c_many2many">
<class name="Project" table="t_project">
<id name="prj_id">
<generator class="native"></generator>
</id>
<property name="prj_name" length="20"></property>
<!--
多對多映射:
1. 映射的集合屬性： “developers”
2. 集合屬性，對應的中間表： “t_relation”
3. 外鍵字段: prjId
4. 外鍵字段，對應的中間表字段: did
5. 集合屬性元素的類型
-->
<set name="developers" table="t_relation" cascade="save-update" inverse="false">
<key column="prjId"></key>
<many-to-many column="did" class="Developer"></many-to-many>
</set>
</class>
</hibernate-mapping>
測試
Project prj_ds = new Project();
prj_ds.setPrj_name("電商系統");
Project prj_oa = new Project();
prj_oa.setPrj_name("OA系統");
// 創建員工對象
Developer dev_cj = new Developer();
dev_cj.setD_name("曹吉");
Developer dev_wc = new Developer();
dev_wc.setD_name("王春");
Developer dev_lz = new Developer();
dev_lz.setD_name("老張");
// 關系 【項目方】
prj_ds.getDevelopers().add(dev_cj);
prj_ds.getDevelopers().add(dev_wc); // 電商系統（曹吉，王春）
prj_oa.getDevelopers().add(dev_wc);
prj_oa.getDevelopers().add(dev_lz); // OA系統（王春，老張）
// 保存
session.save(prj_ds);
session.save(prj_oa); // 必須要設置級聯保存 ,且Project.hbm.xml 里的inverse屬性為false
效果如下：插入了兩個項目，三個開發者，四條記錄
Hibernate: insert into t_project (prj_name) values (?)
Hibernate: insert into t_developer (d_name) values (?)
Hibernate: insert into t_developer (d_name) values (?)
Hibernate: insert into t_project (prj_name) values (?)
Hibernate: insert into t_developer (d_name) values (?)
Hibernate: insert into t_relation (prjId, did) values (?, ?)
Hibernate: insert into t_relation (prjId, did) values (?, ?)
Hibernate: insert into t_relation (prjId, did) values (?, ?)
Hibernate: insert into t_relation (prjId, did) values (?, ?)
