1. 回顧以及hibernate執行流程
1. hibernate開發環境搭建
----》 引入jar： hibernate.jar + required + jpa + 驅動包
---》 hibernate.cfg.xml
---》 javabean/*.hbm.xml
---》 Application 測試
2.hibernate api
----》 Configuration
----》 SessionFactory
----》 Session
---》 Transaction
---》Query
---》Criteria
---》SQLQuery
3.配置
---》 主配置
---》映射配置
*.hbm.xml
4. hibernate 程式執行流程
1. 集合映射、儲存
a. 集合映射
開發流程：
需求分析/資料庫設計、項目設計/ 編碼/測試/實施部署上線/驗收
需求:
使用者購買， 填寫位址！
資料庫：
代碼：
package com.xp.a_collection;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
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>();
public Map<String, String> getAddressMap() {
return addressMap;
}
public void setAddressMap(Map<String, String> addressMap) {
this.addressMap = addressMap;
}
public List<String> getAddressList() {
return addressList;
}
public void setAddressList(List<String> addressList) {
this.addressList = addressList;
}
public int getUserId() {
return userId;
}
public void setUserId(int userId) {
this.userId = userId;
}
public String getUserName() {
return userName;
}
public void setUserName(String userName) {
this.userName = userName;
}
public Set<String> getAddress() {
return address;
}
public void setAddress(Set<String> address) {
this.address = address;
}
}
<?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="com.xp.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>
package com.xp.a_collection;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;
public class App {
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();
}
b. 儲存
// 儲存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);
// 使用者對象 -- Map
user.getAddressMap().put("A0001", "廣州");
user.getAddressMap().put("A0002", "深圳");
// 儲存
session.save(user);
session.getTransaction().commit();
session.close();
}
// 擷取
@Test
public void testGet() throws Exception {
Session session = sf.openSession();
session.beginTransaction();
3. 集合映射、集合資料的擷取
// 擷取
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();
}
}
1. 一對多與多對一映射
需求1：
部門與員工
一個部門有多個員工; 【一對多】
多個員工，屬于一個部門 【多對一】
需求2：
項目與開發員工
一個項目，有多個開發人員！
一個開發人員，參與多個項目！ 【多對多】
需求：員工與部門
資料庫：
設計javabean封裝：
映射：
package com.xp.b_one2many;
public class Employee {
private int empId;
private String empName;
private double salary;
// 【多對一】員工與部門
private Dept dept;
public int getEmpId() {
return empId;
}
public void setEmpId(int empId) {
this.empId = empId;
}
public String getEmpName() {
return empName;
}
public void setEmpName(String empName) {
this.empName = empName;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
public Dept getDept() {
return dept;
}
public void setDept(Dept dept) {
this.dept = dept;
}
}
package com.xp.b_one2many;
import java.util.HashSet;
import java.util.Set;
public class Dept {
private int deptId;
private String deptName;
// 【一對多】 部門對應的多個員工
private Set<Employee> emps = new HashSet<Employee>();
public int getDeptId() {
return deptId;
}
public void setDeptId(int deptId) {
this.deptId = deptId;
}
public String getDeptName() {
return deptName;
}
public void setDeptName(String deptName) {
this.deptName = deptName;
}
public Set<Employee> getEmps() {
return emps;
}
public void setEmps(Set<Employee> emps) {
this.emps = emps;
}
}
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="com.xp.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>
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="com.xp.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>
測試
package com.xp.b_one2many;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
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();
/*
* 結果
* 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();
/*
* 結果
* 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
*/
}
}
5. 小結
package com.xp.b_one2many;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
public class App2_get {
private static SessionFactory sf;
static {
sf = new Configuration()
.configure()
.addClass(Dept.class)
.addClass(Employee.class) // 測試時候使用
.buildSessionFactory();
}
@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();
}
}
在一對多與多對一的關聯關系中，儲存資料最好的通過多的一方來維護關系，這樣可以減少update語句的生成，進而提高hibernate的執行效率！
配置一對多與多對一，這種叫“雙向關聯”
隻配置一對多， 叫“單項一對多”
隻配置多對一， 叫“單項多對一”
注意：
配置了哪一方，哪一方才有維護關聯關系的權限！
6. Inverse屬性用法
Inverse屬性，是在維護關聯關系的時候起作用的。
表示控制權是否轉移。(在一的一方起作用)
Inverse , 控制反轉。
Inverse = false 不反轉； 目前方有控制權
True 控制反轉； 目前方沒有控制權
維護關聯關系中，是否設定inverse屬性：
1. 儲存資料
有影響。
如果設定控制反轉,即inverse=true, 然後通過部門方維護關聯關系。在儲存部門的時候，同時儲存員工， 資料會儲存，但關聯關系不會維護。即外鍵字段為NULL
2. 擷取資料
無。
3. 解除關聯關系？
有影響。
inverse=false， 可以解除關聯
inverse=true， 目前方(部門)沒有控制權，不能解除關聯關系
(不會生成update語句,也不會報錯)
4. 删除資料對關聯關系的影響？
有影響。
inverse=false, 有控制權， 可以删除。先清空外鍵引用，再删除資料。
inverse=true, 沒有控制權: 如果删除的記錄有被外鍵引用，會報錯，違反主外鍵引用限制！ 如果删除的記錄沒有被引用，可以直接删除。
package com.xp.b_one2many;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
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();
}
@Test
public void bak() {
Session session = sf.openSession();
session.beginTransaction();
session.getTransaction().commit();
session.close();
}
}
7. Cascade級聯操作
cascade 表示級聯操作 【可以設定到一的一方或多的一方】
none 不級聯操作， 預設值
save-update 級聯儲存或更新
delete 級聯删除
save-update,delete 級聯儲存、更新、删除
all 同上。級聯儲存、更新、删除
package com.xp.b_one2many;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
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();
}
@Test
public void bak() {
Session session = sf.openSession();
session.beginTransaction();
session.getTransaction().commit();
session.close();
}
}
8. 多對多映射配置
需求：項目與開發人員
Project Developer
電商系統
曹吉
王春
OA系統
王春
老張
資料庫
package com.xp.c_manytomany;
import java.util.HashSet;
import java.util.Set;
public class Project {
private int prj_id;
private String prj_name;
// 項目下的多個員工
private Set<Developer> developers = new HashSet<Developer>();
public int getPrj_id() {
return prj_id;
}
public void setPrj_id(int prjId) {
prj_id = prjId;
}
public String getPrj_name() {
return prj_name;
}
public void setPrj_name(String prjName) {
prj_name = prjName;
}
public Set<Developer> getDevelopers() {
return developers;
}
public void setDevelopers(Set<Developer> developers) {
this.developers = developers;
}
}
<?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="com.xp.c_manytomany">
<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="true">
<key column="prjId"></key>
<many-to-many column="did" class="Developer"></many-to-many>
</set>
</class>
</hibernate-mapping>
package com.xp.c_manytomany;
import java.util.HashSet;
import java.util.Set;
public class Developer {
private int d_id;
private String d_name;
// 開發人員，參數的多個項目
private Set<Project> projects = new HashSet<Project>();
public int getD_id() {
return d_id;
}
public void setD_id(int dId) {
d_id = dId;
}
public String getD_name() {
return d_name;
}
public void setD_name(String dName) {
d_name = dName;
}
public Set<Project> getProjects() {
return projects;
}
public void setProjects(Set<Project> projects) {
this.projects = projects;
}
}
<?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="com.xp.c_manytomany">
<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>
package com.xp.c_manytomany;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;
public class App1_save {
private static SessionFactory sf;
static {
sf = new Configuration().configure().addClass(Project.class)
.addClass(Developer.class) // 測試時候使用
.buildSessionFactory();
}
// 1. 多對多，儲存 【隻能通過一方維護另外一方，不能重複維護！】
@Test
public void save() {
Session session = sf.openSession();
session.beginTransaction();
/*
* 模拟資料： 電商系統（曹吉，王春） OA系統（王春，老張）
*/
// 建立項目對象
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(dev_cj);
// session.save(dev_wc);
// session.save(dev_lz);
session.save(prj_ds);
session.save(prj_oa); // 必須要設定級聯儲存
session.getTransaction().commit();
session.close();
}
@Test
public void bak() {
Session session = sf.openSession();
session.beginTransaction();
session.getTransaction().commit();
session.close();
}
}
package com.xp.c_manytomany;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.hibernate.classic.Session;
import org.junit.Test;
public class App2_inverse {
private static SessionFactory sf;
static {
sf = new Configuration().configure().addClass(Project.class)
.addClass(Developer.class) // 測試時候使用
.buildSessionFactory();
}
// 多對多
// 1. 設定inverse屬性，對儲存資料影響?
// 有影響。
// inverse=false ，有控制權，可以維護關聯關系； 儲存資料的時候會把對象關系插入中間表；
// inverse=true, 沒有控制權， 不會往中間表插入資料。
@Test
public void save() {
Session session = sf.openSession();
session.beginTransaction();
/*
* 模拟資料： 電商系統（曹吉，王春） OA系統（王春，老張）
*/
// 建立項目對象
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(dev_cj);
// session.save(dev_wc);
// session.save(dev_lz);
session.save(prj_ds);
session.save(prj_oa); // 必須要設定級聯儲存
session.getTransaction().commit();
session.close();
}
// 2 .設定inverse屬性， 對擷取資料影響？ 無
@Test
public void get() {
Session session = sf.openSession();
session.beginTransaction();
Project prj = (Project) session.get(Project.class, 1);
System.out.println(prj.getPrj_name());
System.out.println(prj.getDevelopers());
session.getTransaction().commit();
session.close();
}
// 3. 設定inverse屬性， 對解除關系影響？
// 有影響。
// inverse=false ,有控制權， 解除關系就是删除中間表的資料。
// inverse=true, 沒有控制權，不能解除關系。
@Test
public void removeRelation() {
Session session = sf.openSession();
session.beginTransaction();
Project prj = (Project) session.get(Project.class, 7);
prj.getDevelopers().clear();
session.getTransaction().commit();
session.close();
}
// 3. 設定inverse屬性，對删除資料的影響?
// inverse=false, 有控制權。 先删除中間表資料，再删除自身。
// inverse=true, 沒有控制權。 如果删除的資料有被引用，會報錯！ 否則，才可以删除
@Test
public void deleteData() {
Session session = sf.openSession();
session.beginTransaction();
Project prj = (Project) session.get(Project.class, 1);
session.delete(prj);
session.getTransaction().commit();
session.close();
}
}
9. 多對多關聯關系的維護
設定inverse屬性，在多對多種維護關聯關系的影響？
1） 儲存資料
有影響。
inverse=false ，有控制權，可以維護關聯關系； 儲存資料的時候會把對象關系插入中間表；
inverse=true, 沒有控制權， 不會往中間表插入資料。
2） 擷取資料
無。
3） 解除關系
// 有影響。
// inverse=false ,有控制權， 解除關系就是删除中間表的資料。
// inverse=true, 沒有控制權，不能解除關系。
4） 删除資料
有影響。
// inverse=false, 有控制權。 先删除中間表資料，再删除自身。
// inverse=true, 沒有控制權。 如果删除的資料有被引用，會報錯！ 否則，才可以删除