Hibernate笔记3--多表操作-导航查询

一.一对多操作
1.构造实体类及编写配置文件:
     一方:
 

       // 一个Customer对应多个linkman
         private Set<Linkman> linkmans = new HashSet<>(0);

     配置:

        <!-- inverse="true"代表放弃外键维护权 -->
         <set name="linkmans" inverse="true">
                 <!-- 配置从表的外键名 -->
             <key column="sys_cust_id"></key>
                <!-- 配置关联方式 -->
             <one-to-many class="entity.Linkman"/>
         </set>

     多方:

        // 多个linkman对应一个customer
         private Customer customer;

     配置:

        <!-- 配置关联关系 -->
         <many-to-one name="customer" class="entity.Customer" column="sys_cust_id"></many-to-one>

2.测试代码
  

  package demo;

    import org.hibernate.Session;
     import org.hibernate.Transaction;
     import org.junit.Test;

    import entity.Customer;
     import entity.Linkman;
     import utils.HibernateUtils;

    //一对多操作
    public class demo01 {
         @Test
         public void test() {
             Session cs = HibernateUtils.getCurrentSession();
             Transaction tx = cs.beginTransaction();
             // 创建一个客户
            Customer cust = new Customer();
             cust.setCustName("A公司");
             // 创建与客户关联的联系人
            Linkman man = new Linkman();
             man.setLkmName("Jack");
             // 保存关系--配置一的一方的set标签的inverse属性的值为true,放弃外键维护权
            cust.getLinkmans().add(man);
             man.setCustomer(cust);
             // 保存
            cs.save(cust);
             cs.save(man);
             // 提交
            tx.commit();
         }
     }

二.多对多操作
1.构造实体类及编写配置文件:
     多方1-User:
          

      <!-- 配置关联关系 多对多,table代表中间表,cascade表示允许级联操作:all/save-update/delete-->
             <set name="roles" table="sys_user_role" cascade="all">
                 <!--外键:当前对象在中间表的外键名  -->
                 <key column="sys_user_id"></key>
                 <!--对方的全限定名,及在中间表的外键名  -->
                 <many-to-many class="entity.Role" column="sys_role_id"></many-to-many>
             </set>

     多方2-Role:
                

<!-- 配置关联关系 多对多-->
             <set name="users" table="sys_user_role" inverse="true">
                 <!--外键:当前对象在中间表的外键名  -->
                 <key column="sys_role_id"></key>
                 <!--对方的全限定名,及在中间表的外键名  -->
                 <many-to-many class="entity.User" column="sys_user_id"></many-to-many>
             </set>

2.测试代码:
   

 package demo;

    import org.hibernate.Session;
     import org.hibernate.Transaction;
     import org.junit.Test;

    import entity.Role;
     import entity.User;
     import utils.HibernateUtils;

    //测试多对多操作
    public class demo02 {
         @Test
         public void testAdd() {
             Session cs = HibernateUtils.getCurrentSession();
             Transaction tx = cs.beginTransaction();
             // 创建一个user
             User u = new User();
             u.setUserName("Rose");
             // 创建一个role
             Role r = new Role();
             r.setRoleName("painter");
             // 维护中间表,配置文件中被动一方放弃维护权
            u.getRoles().add(r);
             r.getUsers().add(u);
             // 保存
            cs.save(u);
             cs.save(r);
             tx.commit();
         }


          @Test
         // 多对多级联操作,多一个配置,少一个保存
        public void testCascade() {
             Session cs = HibernateUtils.getCurrentSession();
             Transaction tx = cs.beginTransaction();
             // 创建一个user
             User user = new User();
             user.setUserName("Jack");
             // 创建一个role
             Role role = new Role();
             role.setRoleName("model");
             // 维护中间表,被动一方配置为放弃维护权
            user.getRoles().add(role);
             role.getUsers().add(user);
             // 保存user,user配置级联操作,即user可以操作role
             cs.save(user);
             // 下一行语句不报错,只是维护了cst_role表格,因为role没有配置级联操作
            // cs.save(role);
             // 提交事务
            tx.commit();
         }

            @Test
         // 给1号用户添加2号角色操作
        public void addRole() {
             Session cs = HibernateUtils.getCurrentSession();
             Transaction tx = cs.beginTransaction();
             // 获取1号用户
            User user01 = cs.get(User.class, 1L);
             // 获取2号角色
            Role role02 = cs.get(Role.class, 2L);
             // 分配角色
            user01.getRoles().add(role02);
             // 保存
            cs.save(user01);
             // 提交
            tx.commit();
         }

            @Test
         // 删除1号用户的1号角色
        public void delRole() {
             Session cs = HibernateUtils.getCurrentSession();
             Transaction tx = cs.beginTransaction();
             // 获取1号用户
            User user01 = cs.get(User.class, 1L);
             // 获取1号角色
            Role role01 = cs.get(Role.class, 1L);
             // 删除1号用户的1号角色
            user01.getRoles().remove(role01);
             // 保存
            cs.save(user01);
             // 提交事务
            tx.commit();
         }

            @Test
         // 修改1号用户为3号角色
        public void changeRole() {
             Session cs = HibernateUtils.getCurrentSession();
             Transaction tx = cs.beginTransaction();
             // 获取1号用户
            User user01 = cs.get(User.class, 1L);
             // 获取2号角色
            Role role02 = cs.get(Role.class, 2L);
             // 获取3号角色
            Role role03 = cs.get(Role.class, 3L);
             // 删除1号用户的2号角色
            user01.getRoles().remove(role02);
             // 添加3号角色
            user01.getRoles().add(role03);
             // 保存
            cs.save(user01);
             // 提交事务
            tx.commit();
         }
     }

三.导航查询
概念:比如客户与联系人是一对多的关系,通过查询客户也能查询其对应的联系人,则称为导航查询.导航查询默认为延迟加载;如果使延迟加载失效,则在客户的映射关系文件的set标签内配置lazy属性
   <!-- lazy : 配置查询关联对象的延迟加载
                             true:使用延迟,默认
                             false:不使用延迟
                             extra:极其懒惰-->