表关系的分析
数据库中多表之间存在着三种关系：
表关系
表与表的三种关系：
一对多|多对一
建表原则：在多的一方创建外键指向一的一方的主键
一对多
表中的表达
表中表达
实体中的表达
实体中的表达
orm元数据表达
- 多对一配置
<!--表示多对一-->
<many-to-one name="customer"
column="lkm_cust_id"
class="Customer">
</many-to-one>
这里的这个配置表示的是：当前的这个配置对象存在多对一的情况，其中name表示实体中多对一的一的名字，column表示外键的列名 class表示的是多个对一个的一的实体类名
- 一对多配置
<!--配置集合 一对多的关系-->
<set name="linkMens">
<!--指定外键列名-->
<key column="lkm_cust_id"></key>
<!--指定一对多还是多对多
class指定是与哪个类型一对多
-->
<one-to-many class="LinkMan"/>
</set>
这里的这个配置表示的是：当前的这个配置对象存在多对一的情况，其中name表示实体中多个的set集合，key column表示外键的列名 class表示的是一对多的多的实体类名
/**
*保存客户以及客户下的联系人
*/
@Test
public void fun1() {
//获得session
Session session = HibernateUtils.openSession();
//开启事物
Transaction tx = session.beginTransaction();
//----------------------------
//操作数据
Customer customer = new Customer();
customer.setCust_name("xxx");
LinkMan lm1 = new LinkMan();
lm1.setLkm_name("aaa1");
LinkMan lm2 = new LinkMan();
lm2.setLkm_name("aaa2");
//表达一对多关系 客户下有多个联系人
customer.getLinkMens().add(lm1);
customer.getLinkMens().add(lm2);
//表达多对一 联系人属于哪个客户
lm1.setCustomer(customer);
lm2.setCustomer(customer);
//瞬时状态对象---->持久化状态
session.save(customer);
session.save(lm1);
session.save(lm2);
//----------------------------
//提交事物
tx.commit();
//关闭资源
session.close();
}
/**
* 为客户添加联系人
*/
@Test
public void fun2() {
//获得session
Session session = HibernateUtils.openSession();
//开启事物
Transaction tx = session.beginTransaction();
//----------------------------
//操作数据
//获得要操作的客户对象
Customer customer = session.get(Customer.class, 1l);
//创建联系人
LinkMan lm1 = new LinkMan();
//将联系人添加到客户，将客户设置到联系人中
customer.getLinkMens().add(lm1);
lm1.setCustomer(customer);
//执行保存
session.save(customer);
session.save(lm1);
//----------------------------
//提交事物
tx.commit();
//关闭资源
session.close();
}
/**
* 从客户中删除某个联系人
*/
@Test
public void fun3() {
//获得session
Session session = HibernateUtils.openSession();
//开启事物
Transaction tx = session.beginTransaction();
//----------------------------
//操作数据
//获得客户
Customer c = session.get(Customer.class, 1l);
LinkMan lm = session.get(LinkMan.class, 3l);
//获得客户的联系人
//将要移除的联系人从客户的联系人集合中移除
c.getLinkMens().remove(lm);
//清空联系人的客户
lm.setCustomer(null);
//----------------------------
//提交事物
tx.commit();
//关闭资源
session.close();
}
上面的代码再删除某个联系人时由于数据都是查询出来的，都是出于持久态的对象，所以再事务进行提交时Hibernate会查看数据是否发生变化，发生变化后会将数据更新，所以不需要执行session.save()方法进行保存数据
操作进阶
在上面的操作中，我们在操作保存客户的联系人的时候，我们需要执行多条保存的代码，这样显然很麻烦，我们希望再保存客户的时候，将客户的联系人也一起保存。所以我们需要进行一些别的配置
- 级联操作
<!--级联操作：cascade
save-update:级联保存更新
delete:级联删除
all: save-update delete 级联保存更新和级联删除
级联操作:简化操作
-->
<set name="linkMens" cascade="all">
<!--配置集合 一对多的关系-->
<!--指定外键列名-->
<key column="lkm_cust_id"></key>
<!--指定一对多还是多对多
class指定是与哪个类型一对多
-->
<one-to-many class="LinkMan"/>
</set>
级联操作应用在一对多的多的时候，也可以实现保存联系人的时候将客户保存
- linkman.hbm.xml 配置级联操作
<!--表示多对一-->
<many-to-one name="customer"
column="lkm_cust_id"
class="Customer"
cascade="all"
>
操作代码
/**
* 级联操作 保存联系人 级联保存客户
*/
@Test
public void fun5() {
//获得session
Session session = HibernateUtils.openSession();
//开启事物
Transaction tx = session.beginTransaction();
//----------------------------
//操作数据
//创建客户
Customer customer = new Customer();
customer.setCust_name("google company");
//创建联系人
LinkMan lm = new LinkMan();
lm.setLkm_name("劈柴哥");
//为客户添加联系人
customer.getLinkMens().add(lm);
//为联系人指定客户
lm.setCustomer(customer);
//保存客户----> 只保存联系人 通过级联操作保存客户
session.saveOrUpdate(lm);
//----------------------------
//提交事物
tx.commit();
//关闭资源
session.close();
}
在平时开发中，建议使用save-update 不建议使用delete 级联删除会删除相关的所有数据
- 关系维护
我们查看操作时Hibernate产生的SQL语句时发现了如下的语句
Hibernate执行的语句.png
我们发现。在保存时，客户和联系人两房都会维护外键的关系，关系会维护两次，这样冗余了。多余的维护关系语句。显然是客户这一端在维护关系。所以我们需要优化这种情况 这就引入了Hibernate在实体类配置的时候提供的配置 inverse
inverse是为了提高效率
<!--
inverse属性：配置关系是否维护
配置当前的Customer是否维护与LinkMan的关系
inverse true 的意思就是将关系维护的工作完全交给对方 作为配置方不进行维护关系
* 不维护关系无法在删除的时候将外键置为空
false(默认值) 意思是将关系维护的工作由配置方来维护
原则：无论关系方如何放弃关系，总有一方必须要维护关系
一对多关系当中，也只能是一的一方放弃维护，多的一方不能放弃
-->
<set name="linkMens" inverse="true">
<key column="lkm_cust_id"></key>
class指定是与哪个类型一对多
<one-to-many class="LinkMan"/>
</set>
tips:在开发中的删除数据，结合inverse 和cascade 实现不同的数据删除策略。以这个demo为例，一个客户可以由多个联系人。在这种情况下 相当于客户和联系人维持着某种关系。我们在有需求删除客户的时候对联系人的删除有两种。
第一种：删除Customer的时候，将LinkMan的外键置为空，LinkMan数据保留
这种情况下，如果Customer不维护数据的话是无法操作LinkMan的外键的，所以在这种情况下我们需要让Customer inverse配置为false 让customer维护关系，在这种情况下删除Customer的时候会删除LinkMan的关系。
第二种：删除Customer的时候，级联操作将LinkMan的数据删除。
在这种情况下，将Customer inverse设置为true 并且将cascade指定为delete 这样在删除Customer的同时就会删除LinkMan子表中的数据。
多对多关联关系映射操作
建表原则：创建一个中间表，中间表中至少两个字段作为外键分别指向多对多双方的主键
多对多
表中关系表达
表中表达
实体中的表达
实体中的表达
orm元数据表达
- User表配置
<set name="roles" table="sys_user_role">
<!--
key标签
column:当前对象在中间表中的外键名称
-->
<key column="user_id"></key>
<!--
many-to-many标签：
class：关联另一方的类的全类名
column 关联的另一方在中间表的外键名称
-->
<many-to-many class="Role" column="role_id"></many-to-many>
</set>
- role表配置
<!--Role多对多配置-->
<set name="users" table="sys_user_role">
<key column="role_id"/>
<many-to-many class="User"
column="user_id"/>
</set>
多对多操作
我们使用案例：保存员工以及角色
在多对多关系中一定要有一方放弃关系的维护，否则会出现主键重复错误
放弃关系维护在配置文件中使用 inverse=“true” 表示放弃操作
- 配置文件
<!-- inverse 属性 使得一方放弃维护外键关系-->
<set name="users" table="sys_user_role" inverse="true">
<key column="role_id"/>
<many-to-many class="User"
column="user_id"/>
</set>
- 实例代码
//从工厂获得session
Session session = HibernateUtil.openSession();
//开启事物
Transaction tx = session.beginTransaction();
//操作数据
//-------------------------------
//创建两个User
User user1 = new User();
User user2 = new User();
user1.setUser_name("blackman");
user2.setUser_name("whiteman");
//创建两个role
Role role1 = new Role();
Role role2 = new Role();
Role role3 = new Role();
role1.setRole_name("vp");
role2.setRole_name("cto");
role3.setRole_name("security");
//用户表达关系
user1.getRoles().add(role1);
user1.getRoles().add(role2);
user2.getRoles().add(role1);
user2.getRoles().add(role3);
//角色表达关系
role1.getUsers().add(user1);
role1.getUsers().add(user2);
role2.getUsers().add(user1);
role3.getUsers().add(user2);
//保存到数据库
session.save(user1);
session.save(user2);
session.save(role1);
session.save(role2);
session.save(role3);
//-------------------------------
//提交事务
tx.commit();
//关闭资源
session.close();
@Test
/**
* 添加角色到某个用户中
*/
public void addRoleToUser() {
Session session = HibernateUtil.openSession();
Transaction tx = session.beginTransaction();
//操作
//------------
//获得要添加的用户
User user = session.get(User.class, 1l);
//创建公关角色
Role role = new Role();
role.setRole_name("公关");
//将角色添加到用户
user.getRoles().add(role);
//将角色转换为持久化
session.save(role);
//------------
tx.commit();
session.close();
}
/**
* 从指定角色删除
*/
@Test
public void delRoleFromUser(){
//获取session
Session session = HibernateUtil.openSession();
//开启事物
Transaction tx = session.beginTransaction();
//操作数据
//-------------
//获得要删除的数据
User user = session.get(User.class, 3l);
//获得要删除的角色数据
Role role = session.get(Role.class, 7l);
user.getRoles().remove(role);
//-------------
//提交事务
tx.commit();
//关闭资源
session.close();
}
进阶操作
- 级联操作
cascade: 级联操作
在User.hbm.xml中配置cascade后
<set name="roles" table="sys_user_role" cascade="save-update">
可以进行级联保存 上面的操作代码不再需要
session.save(role)
一对一
- 建表原则：
- 1 唯一外键对应：假设一对一种的任意一方为多，在多的一方创建外键指向一的一方的主键，然后将外键设置为唯一。
-
2 主键对应：一方的主键作为另一方的主键
一对一
