表于表的关系
一对多
建表原则：在多的一方创建外键指向一的一方的主键
多对多
建表原则：创建一个中件表，中间表至少要两个字段作为外键分别指向多对多双方的主键
一对一
建表原则：
原则一：唯一外键对应：假设一对一中的任意一方为多，在多的一方创建外键指向的一方的主键，然后将外键设置为唯一
原则二：主键对象：一方的主键作为是另一方的主键
在hibernate中采用Java对象关系来描述数据表之间的关系，具体如下图：
一对多关系
customer类
private Set<CstLinkmanEntity> linkmanEntities=new HashSet<>();
public Set<CstLinkmanEntity> getLinkmanEntities() {
return linkmanEntities;
}
public void setLinkmanEntities(Set<CstLinkmanEntity> linkmanEntities) {
this.linkmanEntities = linkmanEntities;
}
<!--name属性：多的一方的集合属性名称 -->
<set name="linkmanEntities">
<!-- column属性：多的一方的外键名称-->
<key column="lkm_cust_id"></key>
<!--多的一方的类全路径-->
<one-to-many class="com.hibernate.domain.CstLinkmanEntity"></one-to-many>
</set>
linkman类
private CstCustomerEntity cstCustomerEntity;
public CstCustomerEntity getCstCustomerEntity() {
return cstCustomerEntity;
}
public void setCstCustomerEntity(CstCustomerEntity cstCustomerEntity) {
this.cstCustomerEntity = cstCustomerEntity;
}
<!--
name:一 一方的对象的名称
class：一 的类全路径
column：表中的外键的名称
-->
<many-to-one name="cstCustomerEntity" class="com.hibernate.domain.CstCustomerEntity" column="lkm_cust_id"></many-to-one>
测试类
@Test
public void demo01(){
//一对多关系
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
Session s = sessionFactory.openSession();
Transaction tx=s.beginTransaction();
//创建要给客户
CstCustomerEntity c1=new CstCustomerEntity();
c1.setCustName("蒋总");
//创建两个联系人
CstLinkmanEntity l1=new CstLinkmanEntity();
l1.setLkmId(1L);
l1.setLkmName("李秘书");
CstLinkmanEntity l2=new CstLinkmanEntity();
l2.setLkmId(2l);
l2.setLkmName("王助理");
//建立关系
c1.getLinkmanEntities().add(l1);
c1.getLinkmanEntities().add(l2);
l1.setCstCustomerEntity(c1);
l2.setCstCustomerEntity(c1);
s.save(c1);
s.save(l1);
// s.evict(l1);
s.save(l2);
tx.commit();
s.close();
}
一对多的级联操作
级联操作是指当主控放执行保存、更新、或者删除时，其关联对象也执行相同的操作，在映射文件中通过对cascade属性的设置来控制是否对关联对象采用级联操作。
一对多/多对一
O 对象 一的一方使用集合. 多的一方直接引用一的一方.
R 关系型数据库 多的一方使用外键引用一的一方主键.
M 映射文件 一: <set name="">
<key column="" />
<one-to-many class="" />
</set>
多: <many-to-one name="" column="" class="" /> **保存客户级联联系人**
主控方：客户
<set name="linkmanEntities" cascade="save-update">
<key column="lkm_cust_id"></key>
<one-to-many class="com.hibernate.domain.CstLinkmanEntity"></one-to-many>
</set>
测试代码：
@Test
public void demo02(){
Session session=HibernateUtils.getCurrentSession();
Transaction tx=session.beginTransaction();
//创建要给客户
CstCustomerEntity c1=new CstCustomerEntity();
c1.setCustName("刘总");
//创建两个联系人
CstLinkmanEntity l1=new CstLinkmanEntity();
//.setLkmId(1L);
l1.setLkmName("敖秘书");
CstLinkmanEntity l2=new CstLinkmanEntity();
//l2.setLkmId(2l);
l2.setLkmName("陈保安");
//建立关系
c1.getLinkmanEntities().add(l1);
c1.getLinkmanEntities().add(l2);
l1.setCstCustomerEntity(c1);
l2.setCstCustomerEntity(c1);
session.save(c1);
tx.commit();
}
保存联系人级联客户
主控方：联系人
<many-to-one name="cstCustomerEntity" class="com.hibernate.domain.CstCustomerEntity" cascade="save-update" column="lkm_cust_id"></many-to-one>
级联删除
和添加一样要确定好主控方，cascade=”delete”
双向关联产生多余的sql语句
双向维护关系会产生多余的sql，需要一方放弃外键维护权，一般交给多的一方维护。
<set name="linkmanEntities" cascade="save-update" inverse="true">
<key column="lkm_cust_id"></key>
<one-to-many class="com.hibernate.domain.CstLinkmanEntity"></one-to-many>
</set>
区分cascade和inverse
casecade强调的时操作一个对象的时候，是否操作其关联对象
inverse强调的是外键的维护权
cascade: 级联操作 减少我们书写的操作代码. none(默认值) 不级联 save-update: 级联保存 delete: 级联删除 all: 级联保存+级联删除 结论: 可以使用save-update.不推荐使用delete. 也可以不用cascade. inverse: 反转关系维护 属于性能优化.关系的两端如果都书写了关系.那么两方都会发送维护关系的语句. 这样,语句就发生重复.我们可以使用inverse使一的一方放弃维护关系. true 放弃 false(默认值) 维护 结论: 在一对多中,一的一方可以放弃维护关系.
多对多关系映射
O 对象 两方都使用集合.
R 关系型数据库 使用中间表.至少两列.作为外键引用两张表的主键.
M 映射文件 多: <set name="" table="中间表名" >
<key column="别人引用我" />
<man-to-many class="" column="我引用别人的" />
</set>
操作:操作管理级别属性.
cascade: 级联操作
减少我们书写的操作代码.
none(默认值) 不级联
save-update: 级联保存
delete: 级联删除
all: 级联保存+级联删除
结论: 可以使用save-update.不推荐使用delete. 也可以不用cascade.
inverse: 反转关系维护
属于性能优化.必须选择一方放弃维护主键关系.哪方放弃要看业务方向. ### 代码 实体类
public class SysUser {
private long userId;
private String userCode;
private String userName;
private String userPassword;
private String userState;
private Set<SysRole> roles=new HashSet<>();
public Set<SysRole> getRoles() {
return roles;
}
……
public class SysRole {
private long roleId;
private String roleName;
private String roleMemo;
private Set<SysUser> users=new HashSet<>();
public Set<SysUser> getUsers() {
return users;
}
……
实体类映射文件
<hibernate-mapping>
<class name="com.hibernate.domain.SysUser" table="sys_user" schema="yy-visualization">
<id name="userId" column="user_id">
<generator class="native"></generator>
</id>
<property name="userCode" column="user_code"/>
<property name="userName" column="user_name"/>
<property name="userPassword" column="user_password"/>
<property name="userState" column="user_state"/>
<!--
name：关联的另一方的集合属性名称
table：中间表的名称
-->
<set name="roles" table="sys_user_role">
<!--column：当前对象在中件表中的外键名称-->
<key column="user_id"></key>
<!--
class：关联另一方的类全路径
column：关联另一方在中件表的外键名称
-->
<many-to-many class="com.hibernate.domain.SysRole"
column="role_id"></many-to-many>
</set>
</class>
</hibernate-mapping>
<hibernate-mapping>
<class name="com.hibernate.domain.SysRole" table="sys_role" schema="yy-visualization">
<id name="roleId" column="role_id">
<generator class="identity"></generator>
</id>
<property name="roleName" column="role_name"/>
<property name="roleMemo" column="role_memo"/>
<set name="users" table="sys_user_role">
<key column="role_id"></key>
<many-to-many column="user_id"
class="com.hibernate.domain.SysUser"></many-to-many>
</set>
</class>
</hibernate-mapping>
测试类
@Test
public void demo03(){
Configuration configuration = new Configuration().configure();
SessionFactory sessionFactory = configuration.buildSessionFactory();
Session session = sessionFactory.openSession();
Transaction tx=session.beginTransaction();
SysUser u1=new SysUser();
u1.setUserCode("1231323213");
u1.setUserPassword("123");
u1.setUserState("1");
u1.setUserName("敖哈哈");
SysUser u2=new SysUser();
u2.setUserCode("435454");
u2.setUserName("袁嘻嘻");
u2.setUserPassword("123");
u2.setUserState("1");
SysRole r1=new SysRole();
r1.setRoleName("男朋友");
SysRole r2=new SysRole();
r2.setRoleName("女朋友");
SysRole r3=new SysRole();
r3.setRoleName("室友");
u1.getRoles().add(r1);
u1.getRoles().add(r3);
u2.getRoles().add(r2);
u2.getRoles().add(r3);
r1.getUsers().add(u1);
r2.getUsers().add(u2);
r3.getUsers().add(u1);
r3.getUsers().add(u2);
session.save(u1);
session.save(u2);
session.save(r1);
session.save(r2);
session.save(r3);
tx.commit();
session.close();
}