本文详细介绍了Hibernate框架中一对多及多对多关联关系的设计原则、JavaBean编写规则、映射配置方法以及级联操作等内容。
课程回顾：Hibernate第二天
1. 持久化类和一级缓存
* 持久化类：JavaBean + 映射的配置文件
* 持久化对象的三种状态
* 瞬时态
* 持久态：有自动更新数据的能力
* 托管态
* Session的一级缓存，快照机制
* 主键的生成策略
2. 管理事务
* 设置隔离级别
* 丢失更新的问题，乐观锁：添加属性version，配置<version name="version">
* 绑定本地的Session，事务需要service层开启，dao层需要使用Session对象
3. 查询的接口
* Query接口：HQL的查询
* Criteria接口：QBC查询（按条件进行查询）一对多(添加联系人案例)
因为客户和联系人是一对多的关系，在有客户的情况下，完成联系人的添加保存操作
javaWEB中一对多的设计以及建表原则
自己滚去复习
导入SQL的建表语句
编写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;
}编写客户和联系人的映射配置文件（注意一对多的配置编写）
客户的配置文件(一方)
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!--配置类跟表结构的映射-->
<class name="com.xiaoming.day01.domain.Customer" table="cst_customer">
<id name="cust_id" column="cust_id">
<!--主键生成策略-->
<generator class="native"/>
</id>
<!--配置乐观锁-->
<version name="version"/>
<!-- 配置其他的属性 -->
<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属性 :表示集合的名称
-->
<set name="linkmans">
<!--
需要出现的子标签
key: 多的一方的外键名称
-->
<key column="lkm_cust_id"></key>
<one-to-many class="com.xiaoming.day01.domain.Linkman"/>
</set>
</class>
</hibernate-mapping>联系人的配置文件(多方)
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<!--配置类跟表结构的映射-->
<class name="com.xiaoming.day01.domain.Linkman" table="cst_linkman">
<id name="lkm_id" column="lkm_id">
<!--主键生成策略-->
<generator class="native"/>
</id>
<!--配置乐观锁-->
<version name="version"/>
<!-- 配置其他的属性 -->
<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"/>
<!--
配置多方:
name JavaBean中的属性
class 属性对应类的类路径
column 表的外键字段(该文件上述配置中并没有配置表的外键)
-->
<many-to-one name="customer" class="com.xiaoming.day01.domain.Customer" column="lkm_cust_id"/>
</class>
</hibernate-mapping>操作客户和联系人的数据
进行双向关联进行数据的保存（不设置级联）
/**
* 最麻烦的方式双向关联的方式 保存数据
*/
@Test
public void fun1(){
Session session = HibernateUtils.getCurrentSession();
Transaction transaction = session.beginTransaction();
//保存客户和联系人的数据
Customer customer = new Customer();
customer.setCust_name("测试双向关联");
//创建两个联系人
Linkman l1 = new Linkman();
l1.setLkm_name("熊大");
Linkman l2 = new Linkman();
l2.setLkm_name("熊二");
//双向关联 客户关联联系人 联系人呢关联客户
Set<Linkman> linkmans = customer.getLinkmans();
linkmans.add(l1);
linkmans.add(l2);
l1.setCustomer(customer);
l2.setCustomer(customer);
//保存数据
session.save(customer);
session.save(l1);
session.save(l2);
//提交
transaction.commit();
}
@Test
//为客户增加联系人
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得要操作的客户对象
Customer c = session.get(Customer.class,1l);
//2> 创建联系人
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("郝强勇");
//3> 将联系人添加到客户,将客户设置到联系人中
c.getLinkMens().add(lm1);
lm1.setCustomer(c);
//4> 执行保存
session.save(lm1);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
@Test
//为客户删除联系人
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得要操作的客户对象
Customer c = session.get(Customer.class,1l);
//2> 获得要移除的联系人
LinkMan lm = session.get(LinkMan.class, 3l);
//3> 将联系人从客户集合中移除
c.getLinkMens().remove(lm);
lm.setCustomer(null);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
级联的取值（cascade的取值）
1. 级联操作是指当主控方执行保存更新或者删除操作时,其关联对象(被控方)也执行相同的操作
* 在映射文件中配置 cascade属性来设置是否采取级联操作
* 级联操作对各种关联关系(3种)都是有效的
* 级联保存是方向性
2. 需要大家掌握的取值如下
* none -- 不使用级联
* save-update -- 级联保存或更新
* delete -- 级联删除
* delete-orphan -- 孤儿删除.(注意：只能应用在一对多关系)
* all -- 除了delete-orphan的所有情况.（包含save-update delete）
* all-delete-orphan -- 包含了delete-orphan的所有情况.（包含save-update delete delete-orphan）
3. 孤儿删除（孤子删除），只有在一对多的环境下才有孤儿删除
* 在一对多的关系中,可以将一的一方认为是父方.将多的一方认为是子方.孤儿删除:在解除了父子关系的时候.将子方记录就直接删除。
* <many-to-one cascade="delete-orphan" />级联操作
1. 测试：如果现在代码只插入其中的一方的数据
* 如果只保存其中的一方的数据，那么程序会抛出异常。(瞬时态的对象没转成持久态的对象)
* 如果想完成只保存一方的数据，并且把相关联的数据都保存到数据库中，那么需要配置级联！！
. 级联保存效果
* 级联保存：保存一方同时可以把关联的对象也保存到数据库中！！
* 使用cascade="save-update"级联保存或更新 sascade = save-update
/**
* 级联保存：保存客户，级联联系人 (方向性)
* 在Customer的配置文件中配置级联属性 customer是主控方,linkman是被控方
* 级联客户同理
*/
@Test
public void run3(){
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
// 保存客户和联系人的数据
//创建一个客户
Customer c1 = new Customer();
c1.setCust_name("美美");
// 创建2个联系人
Linkman l1 = new Linkman();
l1.setLkm_name("熊大");
Linkman l2 = new Linkman();
l2.setLkm_name("熊二");
// 单向关联 在customer.hbm.xml中配置级联属性
//cascade="save-update"
c1.getLinkmans().add(l1);
c1.getLinkmans().add(l2);
// 保存数据
// 将c1设置为持久态
session.save(c1);
tr.commit();
} /**
* 深入探索双方之间的关系-1
*/
@Test
public void run5(){
Session session = HibernateUtils.getCurrentSession();
Transaction tr = session.beginTransaction();
// 保存客户和联系人的数据
Customer c1 = new Customer();
c1.setCust_name("美美");
// 创建2个联系人
Linkman l1 = new Linkman();
l1.setLkm_name("熊大");
Linkman l2 = new Linkman();
l2.setLkm_name("熊二");
l1.setCustomer(c1);
c1.getLinkmans().add(l2);
//两边映射文件都配置了级联属性
//保存联系人(l1)就把级联的客户保存进去了
//而客户还级联了l2所以就都保存进去了
session.save(l1);
tr.commit();
} /**
* 深入探索双方之间的关系-2
*/
@Test
public void run5(){
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("熊二");
Linkman l3 = new Linkman();
l3.setLkm_name("熊三");
//建立关系
l1.setCustomer(c1);
c1.getLinkmans().add(l2);
c1.getLinkmans().add(l3);
// 双方都配置了级联属性
//l1级联了c1,c1级联了l2,l3
session.save(l1) // 发送4条 insert语句
sesison.save(c1) // 发送3条 insert语句
session.sace(l2) // 发送1条 insert语句
tr.commit();
}
级联删除(慎用)
1. 先来给大家在数据库中演示含有外键的删除客户功能，那么SQL语句是会报出错误的
* 例如：delete from customers where cid = 1;
2. 如果使用Hibernate框架直接删除客户的时候，测试发现是可以删除的
*hibernate会先让外键=null,然后再删除
*删除客户但是联系人数据没删 只是外键没了 这些数据也没意义
3. 上述的删除是普通的删除，那么也可以使用级联删除，注意：级联删除也是有方向性的！！
* <many-to-one cascade="save-update,delete" /> @Test
//测试删除客户时,级联删除客户下的联系人
//cascade:delete
public void fun2(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//级联删除必须是先查询再删除
//因为查询到客户,这个时候客户的联系人的集合就会有数据
Customer c = session.get(Customer.class,1l);
//2>调用delete删除客户
session.delete(c);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}级联关系进阶 inverse属性
1. 先测试双方都维护外键的时候，会产生多余的SQL语句。
* 想修改客户和联系人的关系，进行双向关联，双方都会维护外键，会产生多余的SQL语句。
* 客户(一的一方)维护外键有点多余
* inverse属性可以优化sql语句提高性能
* 产生的原因：session的一级缓存中的快照机制，会让双方都更新数据库，产生了多余的SQL语句。
2. 如果不想产生多余的SQL语句，那么需要一方来放弃外键的维护！
* 在<set>标签上配置一个inverse=”true”.true:放弃.false:不放弃.默认值是false
* <inverse="true">
* 肯定是也只能是一的哪一方放弃外键维护,以为多的哪一方外键是它自己的属性
@Test
//保存客户 以及客户 下的联系人
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
Customer c = new Customer();
c.setCust_name("传智播客");
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("黎活明");
LinkMan lm2 = new LinkMan();
lm2.setLkm_name("刘悦东");
//表达一对多,客户下有多个联系人.
// 如果客户放弃维护与联系人的关系. 维护关系的代码可以省略
//c.getLinkMens().add(lm1);
//c.getLinkMens().add(lm2);
//联系人维护客户的关系
lm1.setCustomer(c);
lm2.setCustomer(c);
session.save(c);
session.save(lm1);
session.save(lm2);
//4提交事务
tx.commit();
//5关闭资源
session.close();
}cascade和inverse的区别
1. cascade用来级联操作（保存、修改和删除）
是用来简化代码的
2. inverse用来维护外键的
是用来提高效率的
3. 一对多的情况下 我们通常将一方设置inverse 将多放设置 cascade一的一方放弃主键维护另外设置级联删除
多对多(用户和角色为例)
多对多的建表原则
JavaWEB的多对多:
一个用户对应多个角色 ,一个角色对应多个用户
很明显多对多之间需要建立中间表
设立两个外键 分别指向两张表的主键
Hibernate框架:
只需要编写2个JavaBean编写两个配置文件
中间表会自动生成多对多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>();
}多对多映射配置文件
- 用户的映射配置文件如下
<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 关联的另一方集合的属性名称
table 中间表的名称
key标签
coiumn 当前对象在中间表中的外键名称
many-tomany标签
class 关联另一方的类的全路径
column 关联的另一方在中间表的外键名称
-->
<!--这里的配置中间表已全部维护-->
<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>注意多对多进行双向关联的时候:必须有一方去放弃外键维护权
多对多双向关联
@Test
//保存员工以及角色
public void fun1(){
Session session = HibernateUtils.openSession();
Transaction tx = session.beginTransaction();
// 创建两个 User
User u1 = new User();
u1.setUser_name("郝强勇");
User u2 = new User();
u2.setUser_name("金家德");
// 创建两个 Role
Role r1 = new Role();
r1.setRole_name("保洁");
Role r2 = new Role();
r2.setRole_name("保安");
<!--
如果多对多建立了双向关联,一定要有一方放弃外键维护
一般是由被动方放弃,用户主动选择角色,角色是
被动选择的
其实不放弃也可以,我们可以只描述其中一张表中的内容
只执行下面的 "用户表达关系" "角色表达式"
但是都得持久化
-->
<!--
之所以要一方放弃维护外键,是因为不放弃会报错因为
多对多关联维护外键是想中间表插入数据,双方都维护
相同的数据插入两次,但是插入的还都是主键信息,不能重复,
所以会保错
而一对多不报错的原因是因为外键维护是修改(先执行的insert)的而不是
直接insert
-->
//3> 用户表达关系
u1.getRoles().add(r1);
u1.getRoles().add(r2);
u2.getRoles().add(r1);
u2.getRoles().add(r2);
//4> 角色表达关系
r1.getUsers().add(u1);
r1.getUsers().add(u2);
r2.getUsers().add(u1);
r2.getUsers().add(u2);
//5> 调用Save方法一次保存
session.save(u1);
session.save(u2);
session.save(r1);
session.save(r2);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}多对多级联操作
@Test
//保存员工以及角色
public void fun1(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 创建两个 User
User u1 = new User();
u1.setUser_name("郝强勇");
User u2 = new User();
u2.setUser_name("金家德");
//2> 创建两个 Role
Role r1 = new Role();
r1.setRole_name("保洁");
Role r2 = new Role();
r2.setRole_name("保安");
//3> 用户表达关系
u1.getRoles().add(r1);
u1.getRoles().add(r2);
u2.getRoles().add(r1);
u2.getRoles().add(r2);
//4> 角色表达关系
r1.getUsers().add(u1);
r1.getUsers().add(u2);
r2.getUsers().add(u1);
r2.getUsers().add(u2);
//5> 调用Save方法一次保存
session.save(u1);
session.save(u2);
//没错配置级联之后就少了这么两句
//session.save(r1);
//session.save(r2);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
@Test
//为郝强勇新增一个角色
public void fun3(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得郝强勇用户
User user = session.get(User.class, 1l);
//2> 创建公关角色
Role r = new Role();
r.setRole_name("男公关");
//3> 将角色添加到用户中
user.getRoles().add(r);
//4> 将角色转换为持久化 级联之后就不用了
//session.save(r);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
@Test
//为郝强勇解除一个角色
public void fun4(){
//1 获得session
Session session = HibernateUtils.openSession();
//2 开启事务
Transaction tx = session.beginTransaction();
//-------------------------------------------------
//3操作
//1> 获得郝强勇用户
User user = session.get(User.class, 1l);
//2> 获得要操作的角色对象(保洁,保安)
Role r1 = session.get(Role.class, 1l);
Role r2 = session.get(Role.class, 2l);
//3> 将角色从用户的角色集合中移除
user.getRoles().remove(r1);
user.getRoles().remove(r2);
//-------------------------------------------------
//4提交事务
tx.commit();
//5关闭资源
session.close();
}
扫一扫
2329
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
