Hibernate 一对多关联映射& 多对多管理映射

心已赠人 2022-06-08 14:56 223阅读 0赞

\# Hibernate框架第三天  
  
  
\----------  
  
  
\*\*课程回顾：Hibernate第二天\*\*  
   
1. 持久化类和一级缓存  
\* 持久化类：JavaBean + 映射的配置文件  
\* 持久化对象的三种状态  
\* 瞬时态  
\* 持久态：有自动更新数据的能力  
\* 脱管态  
\* Session的一级缓存，快照机制   
\* 主键的生成策略  
  
2. 管理事务  
\* 设置隔离级别  
\* 丢失更新的问题，乐观锁：添加属性version，配置<version name="version">  
\* 绑定本地的Session，事务需要service层开启，dao层需要使用Session对象  
  
3. 查询的接口  
\* Query接口：HQL的查询  
\* Criteria接口：QBC查询（按条件进行查询）  
  
  
\----------  
  
  
\*\*今天内容\*\*  
   
1. Hibernate 一对多关联映射  
2. Hibernate 多对多管理映射  
\----------  
  
  
\#\#\# 案例一：完成CRM的联系人的保存操作 \#\#\#  
  
  
\----------  
  
  
\#\#\#\# \*\*1. 需求分析\*\*  
  
  
   
  
  
1. 因为客户和联系人是一对多的关系，在有客户的情况下，完成联系人的添加保存操作  
一个客户对应多个联系人，单独在联系人管理模块中对联系人信息进行维护，功能包括：  
添加联系人：添加联系人时指定所属客户，添加信息包括联系人名称、联系电话等  
修改联系人：允许修改联系人所属客户、联系人名称、联系人电话等信息  
删除联系人：删除客户的同时删除下属的联系人，可以单独删除客户的某个联系人  
如下图所示  
!\[002\](图片\\002.jpg)  
  
  
  
  
  
  
\#\#\#\# \*\*2. 相关知识点\*\*  
  
  
\#\#\#\#\# \*\*2.1 \*\*Hibernate的一对多关联映射\*\*（重点）\*\*  
  
  
\*\*2.1.1创建表、映射文件\*\*   
  
  
  
  
1. 先导入SQL的建表语句  
\* 创建今天的数据库：create database hibernate\_day03;  
\* 在资料中找到客户和联系人的SQL脚本  
\* 联系人表中存在外键（lkm\_cust\_id 即所属客户id），外键指向客户表  
  
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;  
// 一个客户对应多个联系人:放的是联系人的集合.(Hibernate默认使用的集合是Set集合.)记住要实例化  
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;  
  
\}  
  
4. 编写客户和联系人的映射配置文件（注意一对多的配置编写）  
\* 客户的映射配置文件如下  
<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>  
  
  
\----------  
  
  
\*\*2.1.2 双向关联进行数据的保存\*\*  
  
  
\`\`\`java  
@Test  
public void demo1()\{  
Session session = HibernateUtils.getCurrentSession();  
Transaction tx = session.beginTransaction();  
  
// 创建一个客户  
Customer customer = new Customer();  
customer.setCust\_name("张总");  
  
// 创建两个联系人:  
LinkMan linkMan1 = new LinkMan();  
linkMan1.setLkm\_name("秦助理");  
  
LinkMan linkMan2 = new LinkMan();  
linkMan2.setLkm\_name("胡助理");  
  
// 建立关系:  
customer.getLinkMans().add(linkMan1);  
customer.getLinkMans().add(linkMan2);  
  
linkMan1.setCustomer(customer);  
linkMan2.setCustomer(customer);  
  
session.save(customer);  
session.save(linkMan1);  
session.save(linkMan2);  
  
tx.commit();  
\}  
\`\`\`  
\----------  
  
  
\#\#\#\#\# 2.2 一对多的级联相关操作  
  
  
\#\#\#\#\#\# 2.2.1 级联保存  
  
  
操作一个对象的时候，将关联对象一并操作.  
  
  
级联是有方向性:  
  
  
\*\*（1）保存客户的时候级联保存联系人\*\*  
  
  
\`\`\`java  
@Test  
/\*\*  
\* 测试级联保存:  
\* \* 保存客户 同时 级联保存联系人.  
     \* 在set集合上配置cascade=”save-update”  
\*/  
public void demo3()\{  
Session session = HibernateUtils.getCurrentSession();  
Transaction tx = session.beginTransaction();  
  
// 保存客户:  
Customer customer = new Customer();  
customer.setCust\_name("陈总");  
// 保存联系人:  
LinkMan man1 = new LinkMan();  
man1.setLkm\_name("小花");  
  
  
// 建立关系:  
customer.getLinkMans().add(man1);  
man1.setCustomer(customer);  
  
// 执行保存操作:  
session.save(customer); // TransientObjectException:customer变为持久态对象,man 还是瞬时态对象.  
// session.save(man1);  
tx.commit();  
      session.close();  
\}  
\`\`\`  
  
  
\*\*（2）保存联系人的时候级联保存客户\*\*  
  
  
\`\`\`java  
@Test  
/\*\*  
\* 测试级联保存:  
\* \* 保存联系人 级联 保存客户.  
      \* 在many-to-one上配置cascade=”save-update”  
\*/  
public void demo4()\{  
Session session = HibernateUtils.getCurrentSession();  
Transaction tx = session.beginTransaction();  
  
// 保存客户:  
Customer customer = new Customer();  
customer.setCust\_name("肖总");  
// 保存联系人:  
LinkMan man1 = new LinkMan();  
man1.setLkm\_name("小娇");  
  
  
// 建立关系:  
customer.getLinkMans().add(man1);  
man1.setCustomer(customer);  
  
// 执行保存操作:  
// session.save(customer); // TransientObjectException:customer变为持久态对象,man 还是瞬时态对象.  
session.save(man1);  
  
tx.commit();  
         session.close();  
\}  
\`\`\`  
  
  
  
  
  
  
1. 测试结果：如果现在代码只插入其中的一方的数据  
\* 如果只保存其中的一方的数据，那么程序会抛出异常。  
\* 如果想完成只保存一方的数据，并且把相关联的数据都保存到数据库中，那么需要配置级联！！  
\* 级联保存是方向性  
  
2. 级联保存效果  
\* 级联保存：保存一方同时可以把关联的对象也保存到数据库中！！  
\* 使用cascade="save-update"  
  
  
\----------  
  
  
\*\*(3) 对象的导航问题\*\*  
  
  
\`\`\`java  
@Test  
/\*\*  
\* 测试关联对象的导航:  
\* \* 保存一个客户 和 3个联系人. 双方都配置了cascade="save-update"  
\*/  
public void demo5()\{  
Session session = HibernateUtils.getCurrentSession();  
Transaction tx = session.beginTransaction();  
  
// 保存客户:  
Customer customer = new Customer();  
customer.setCust\_name("肖老板");  
  
LinkMan linkMan1 = new LinkMan();  
linkMan1.setLkm\_name("大娇");  
LinkMan linkMan2 = new LinkMan();  
linkMan2.setLkm\_name("中娇");  
LinkMan linkMan3 = new LinkMan();  
linkMan3.setLkm\_name("小娇");  
  
// 设置关系：  
linkMan1.setCustomer(customer);  
  
customer.getLinkMans().add(linkMan2);  
customer.getLinkMans().add(linkMan3);  
  
// 执行如下的操作:  
// session.save(linkMan1);  // 执行几条  insert 语句. 4条.  
  
// session.save(customer); // 执行几条 insert 语句. 3条  
  
session.save(linkMan2); // 执行几条 insert语句  1条.  
tx.commit();  
         session.close();  
\}  
  
  
\`\`\`  
  
  
  
  
  
  
\#\#\#\#\#\# \*\*2.2.2 级联删除\*\*  
  
  
 \*\*(1)删除客户的时候同时删除客户的联系人\*\*  
  
  
\`\`\`java  
@Test  
/\*\*  
\* 测试级联删除  
\* 删除客户的时候 删除联系人：  
\* 需要在Customer.hbm.xml中set标签上配置cascade="delete"  
\*/  
public void demo6()\{  
Session session = HibernateUtils.getCurrentSession();  
Transaction tx = session.beginTransaction();  
  
Customer customer = session.get(Customer.class, 1l);  
session.delete(customer);  
  
// 不能级联删除的.  
/\*Customer customer = new Customer();  
customer.setCust\_id(1l);  
  
session.delete(customer);\*/  
tx.commit();  
         session.close();  
\}  
  
  
\`\`\`  
  
  
\*\*(2)删除联系人的时候同时删除客户\*\*  
  
  
\`\`\`java  
@Test  
/\*\*  
\* 测试级联删除  
\* 删除联系人 同时删除 客户：  
\* 需要在LinkMan.hbm.xml中many-to-one标签上配置cascade="delete"  
\*/  
public void demo7()\{  
Session session = HibernateUtils.getCurrentSession();  
Transaction tx = session.beginTransaction();  
  
LinkMan linkman = session.get(LinkMan.class, 1l);  
  
session.delete(linkman);  
  
tx.commit();  
    \}  
\`\`\`  
  
  
  
  
  
  
1. 先来给大家在数据库中演示含有外键的删除客户功能，那么SQL语句是会报出错误的  
\* 例如：delete from customers where cid = 1;  
  
2. 如果使用Hibernate框架直接删除客户的时候，测试发现是可以删除的  
  
3. 上述的删除是普通的删除，那么也可以使用级联删除，注意：级联删除也是有方向性的！！  
\* <many-to-one cascade="delete" />  
  
  
\----------  
  
  
\#\#\#\#\#\# \*\*2.2.3 级联的取值（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. 孤儿删除（孤子删除），只有在一对多的环境下才有孤儿删除  
\* 在一对多的关系中,可以将一的一方认为是父方.将多的一方认为是子方.孤儿删除:在解除了父子关系的时候.将子方记录就直接删除。  
\* <set name="linkmans" cascade="delete-orphan" />  
  
  
\----------  
  
  
\#\#\#\#\#\# \*\*2.2.4 某一方放弃外键的维护，为多对多做准备\*\*  
  
  
问题：双向关联产生多余的SQL语句  
  
  
\`\`\`java  
@Test  
/\*\*  
\* 更改联系人所属的客户  
\* 双向关联 会产生多余的SQL：  
\*/  
public void demo8()\{  
Session session = HibernateUtils.getCurrentSession();  
Transaction tx = session.beginTransaction();  
  
LinkMan linkman = session.get(LinkMan.class, 5L);  
  
Customer customer = session.get(Customer.class, 4L);  
// 双向关联:  
linkman.setCustomer(customer);  
customer.getLinkMans().add(linkman);  
  
tx.commit();  
\}  
\`\`\`  
  
  
!\[003\](图片\\003.jpg)  
  
  
1. 先测试双方都维护外键的时候，会产生多余的SQL语句。  
\* 想修改客户和联系人的关系，进行双向关联，双方都会维护外键，会产生多余的SQL语句。  
  
\* 产生的原因：session的一级缓存中的快照机制，会让双方都更新数据库，产生了多余的SQL语句。  
  
2. 如果不想产生多余的SQL语句，那么需要一方来放弃外键的维护！  
\* 在<set>标签上配置一个inverse=”true”.true:放弃.false:不放弃.默认值是false  
\* <inverse="true">  
  
  
\----------  
  
  
\*\*cascade和inverse的区别\*\*  
  
  
1. cascade用来级联操作（保存、修改和删除）  
2. inverse用来维护外键的  
  
  
\----------  
  
  
\#\#\# 案例二:  
  
  
\#\#\#\# 1. 需求分析  
  
  
\#\#\#\# 2. Hibernate的关联关系映射之多对多映射 \#\#\#\#  
  
  
\----------  
  
  
\*\*技术分析之多对多的建表原则\*\*  
  
  
1. JavaWEB的多对多  
\----------  
  
  
\*\*技术分析之多对多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.itheima.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.itheima.domain.Role" column="role\_id"/>  
</set>  
</class>  
  
\* 角色的映射配置文件如下  
<class name="com.itheima.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.itheima.domain.User" column="user\_id"/>  
</set>  
</class>  
  
3. 多对多进行双向关联的时候:必须有一方去放弃外键维护权  
  
  
\----------  
  
  
\*\*技术分析之多对多的级联保存\*\*  
   
1. 级联保存  
\* <set cascade="save-update">  
  
  
\----------  
  
  
\*\*级联删除（在多对多中是很少使用的）\*\*  
   
1. 级联删除