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

一.一对多操作

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

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

配置:

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

多方:

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

配置:

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

2.测试代码
  

  1   package demo;
  2
  3     import org.hibernate.Session;
  4      import org.hibernate.Transaction;
  5      import org.junit.Test;
  6
  7     import entity.Customer;
  8      import entity.Linkman;
  9      import utils.HibernateUtils;
 10
 11     //一对多操作
 12     public class demo01 {
 13          @Test
 14          public void test() {
 15              Session cs = HibernateUtils.getCurrentSession();
 16              Transaction tx = cs.beginTransaction();
 17              // 创建一个客户
 18             Customer cust = new Customer();
 19              cust.setCustName("A公司");
 20              // 创建与客户关联的联系人
 21             Linkman man = new Linkman();
 22              man.setLkmName("Jack");
 23              // 保存关系--配置一的一方的set标签的inverse属性的值为true,放弃外键维护权
 24             cust.getLinkmans().add(man);
 25              man.setCustomer(cust);
 26              // 保存
 27             cs.save(cust);
 28              cs.save(man);
 29              // 提交
 30             tx.commit();
 31          }
 32      }
 33 

二.多对多操作

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

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

多方2-Role:
                

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

2.测试代码:
   

  1  package demo;
  2
  3     import org.hibernate.Session;
  4      import org.hibernate.Transaction;
  5      import org.junit.Test;
  6
  7     import entity.Role;
  8      import entity.User;
  9      import utils.HibernateUtils;
 10
 11     //测试多对多操作
 12     public class demo02 {
 13          @Test
 14          public void testAdd() {
 15              Session cs = HibernateUtils.getCurrentSession();
 16              Transaction tx = cs.beginTransaction();
 17              // 创建一个user
 18              User u = new User();
 19              u.setUserName("Rose");
 20              // 创建一个role
 21              Role r = new Role();
 22              r.setRoleName("painter");
 23              // 维护中间表,配置文件中被动一方放弃维护权
 24             u.getRoles().add(r);
 25              r.getUsers().add(u);
 26              // 保存
 27             cs.save(u);
 28              cs.save(r);
 29              tx.commit();
 30          }
 31
 32
 33           @Test
 34          // 多对多级联操作,多一个配置,少一个保存
 35         public void testCascade() {
 36              Session cs = HibernateUtils.getCurrentSession();
 37              Transaction tx = cs.beginTransaction();
 38              // 创建一个user
 39              User user = new User();
 40              user.setUserName("Jack");
 41              // 创建一个role
 42              Role role = new Role();
 43              role.setRoleName("model");
 44              // 维护中间表,被动一方配置为放弃维护权
 45             user.getRoles().add(role);
 46              role.getUsers().add(user);
 47              // 保存user,user配置级联操作,即user可以操作role
 48              cs.save(user);
 49              // 下一行语句不报错,只是维护了cst_role表格,因为role没有配置级联操作
 50             // cs.save(role);
 51              // 提交事务
 52             tx.commit();
 53          }
 54
 55             @Test
 56          // 给1号用户添加2号角色操作
 57         public void addRole() {
 58              Session cs = HibernateUtils.getCurrentSession();
 59              Transaction tx = cs.beginTransaction();
 60              // 获取1号用户
 61             User user01 = cs.get(User.class, 1L);
 62              // 获取2号角色
 63             Role role02 = cs.get(Role.class, 2L);
 64              // 分配角色
 65             user01.getRoles().add(role02);
 66              // 保存
 67             cs.save(user01);
 68              // 提交
 69             tx.commit();
 70          }
 71
 72             @Test
 73          // 删除1号用户的1号角色
 74         public void delRole() {
 75              Session cs = HibernateUtils.getCurrentSession();
 76              Transaction tx = cs.beginTransaction();
 77              // 获取1号用户
 78             User user01 = cs.get(User.class, 1L);
 79              // 获取1号角色
 80             Role role01 = cs.get(Role.class, 1L);
 81              // 删除1号用户的1号角色
 82             user01.getRoles().remove(role01);
 83              // 保存
 84             cs.save(user01);
 85              // 提交事务
 86             tx.commit();
 87          }
 88
 89             @Test
 90          // 修改1号用户为3号角色
 91         public void changeRole() {
 92              Session cs = HibernateUtils.getCurrentSession();
 93              Transaction tx = cs.beginTransaction();
 94              // 获取1号用户
 95             User user01 = cs.get(User.class, 1L);
 96              // 获取2号角色
 97             Role role02 = cs.get(Role.class, 2L);
 98              // 获取3号角色
 99             Role role03 = cs.get(Role.class, 3L);
100              // 删除1号用户的2号角色
101             user01.getRoles().remove(role02);
102              // 添加3号角色
103             user01.getRoles().add(role03);
104              // 保存
105             cs.save(user01);
106              // 提交事务
107             tx.commit();
108          }
109      }
110 

三.导航查询

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