Hibernate入门（三）

表于表的关系

一对多

建表原则：在多的一方创建外键指向一的一方的主键

多对多

建表原则：创建一个中件表，中间表至少要两个字段作为外键分别指向多对多双方的主键

一对一

建表原则：

原则一：唯一外键对应：假设一对一中的任意一方为多，在多的一方创建外键指向的一方的主键，然后将外键设置为唯一

原则二：主键对象：一方的主键作为是另一方的主键

在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();
    }