Hibernae - 双向多对一关联关系映射

双向 1-n 与 双向 n-1 是完全相同的两种情形。双向 1-n 需要在 1 的一端可以访问 n 的一端, 反之依然。

域模型:从 Order 到 Customer 的多对一双向关联需要在Order 类中定义一个 Customer 属性, 而在 Customer 类中需定义存放 Order 对象的集合属性。

关系数据模型:ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键。

当 Session 从数据库中加载 Java 集合时, 创建的是 Hibernate 内置集合类的实例, 因此在持久化类中定义集合属性时必须把属性声明为 Java 接口类型。

• Hibernate 的内置集合类具有集合代理功能, 支持延迟检索策略。
• 事实上, Hibernate 的内置集合类封装了 JDK 中的集合类, 这使得 Hibernate 能够对缓存中的集合对象进行脏检查, 按照集合对象的状态来同步更新数据库。

在定义集合属性时, 通常把它初始化为集合实现类的一个实例。这样可以提高程序的健壮性, 避免应用程序访问取值为 null 的集合的方法抛出 NullPointerException。

如下所示：

private Set<Order> orders=new HashSet<Order>();
  
public Set<Order> getOrders() {
  return orders;
}
  
public void setOrders(Set<Order> orders) {
  this.orders = orders;
}

【1】修改Customer与Order

Customer修改如下：

public class Customer {

  private Integer customerId;
  private String customerName;
  
  private Set<Order> orders=new HashSet<Order>();
  
  public Set<Order> getOrders() {
    return orders;
  }
  
  public void setOrders(Set<Order> orders) {
    this.orders = orders;
  }

  public Integer getCustomerId() {
    return customerId;
  }

  public void setCustomerId(Integer customerId) {
    this.customerId = customerId;
  }

  public String getCustomerName() {
    return customerName;
  }

  public void setCustomerName(String customerName) {
    this.customerName = customerName;
  }

  @Override
  public String toString() {
    return "Customer [customerId=" + customerId + ", customerName=" + customerName + ", orders=" + orders + "]";
  }

}

Customer.hbm.xml修改如下：

<hibernate-mapping package="com.jane.model">
    
    <class name="Customer" table="CUSTOMERS">
    
        <id name="customerId" type="java.lang.Integer">
            <column name="CUSTOMER_ID" />
            <generator class="native" />
        </id>
    
        <property name="customerName" type="java.lang.String">
            <column name="CUSTOMER_NAME" default="null" />
        </property>
        
        <!-- 映射 1 对多的那个集合属性 -->
        <!-- set: 映射 set 类型的属性, -->
        <!-- table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 --> 
        <!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->
        <!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理 -->
        <!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->
        <set name="orders" table="ORDERS" inverse="true" order-by="ORDER_NAME DESC">
            <!-- 指定多的表中的外键列的名字 -->
            <key column="CUSTOMER_ID"></key>
            <!-- 指定映射类型 -->
            <one-to-many class="Order"/>
        </set>
    </class>
</hibernate-mapping>

Order修改如下：

public class Order {
  
  private Integer orderId;
  private String orderName;
  
  private Customer customer;

  public Integer getOrderId() {
    return orderId;
  }

  public void setOrderId(Integer orderId) {
    this.orderId = orderId;
  }

  public String getOrderName() {
    return orderName;
  }

  public void setOrderName(String orderName) {
    this.orderName = orderName;
  }

  public Customer getCustomer() {
    return customer;
  }

  public void setCustomer(Customer customer) {
    this.customer = customer;
  }

  @Override
  public String toString() {
    return "Order [orderId=" + orderId + ", orderName=" + orderName + ", customer=" + customer + "]";
  }
  
}

Order.hbm.xml如下：

<hibernate-mapping package="com.jane.model">

    <class name="Order" table="ORDERS">

        <id name="orderId" type="java.lang.Integer">
            <column name="ORDER_ID" />
            <generator class="native" />
        </id>
        
        <property name="orderName" type="java.lang.String">
            <column name="ORDER_NAME" default="null" />
        </property>
        
<!-- 
    映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系 
    name: 多的一端关联的一的一端的属性的名字(Order类中Customer属性)
    class: 一那一端的属性对应的类名
    column: 一那一端在多的一端对应的数据表中的外键的名字(order表中保存的customeId)
-->
    <many-to-one name="customer" class="Customer" 
        column="CUSTOMER_ID" lazy="false" fetch="join">
    </many-to-one>

    </class>
</hibernate-mapping>

可以发现，双向多对一基本上就是单向多对一和单向一对多的综合体。

【2】代码实例

① 双向多对一持久化操作

• 先保存一的一端(Customer)，再保存多的一端(Order)

代码如下：

@Test
  public void testMany2OneSave(){
    Customer customer = new Customer();
    customer.setCustomerName("AA");
    
    Order order1 = new Order();
    order1.setOrderName("ORDER-1");
    Order order2 = new Order();
    order2.setOrderName("ORDER-2");
    
    //设定关联关系
    order1.setCustomer(customer);
    order2.setCustomer(customer);
    
    customer.getOrders().add(order1);
    customer.getOrders().add(order2);
    
    session.save(customer);
    
    session.save(order1);
    session.save(order2);
  
  }

结果如下：

Hibernate: 
    insert 
    into
        CUSTOMERS
        (CUSTOMER_NAME) 
    values
        (?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NAME, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NAME, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    update
        ORDERS 
    set
        CUSTOMER_ID=? 
    where
        ORDER_ID=?
Hibernate: 
    update
        ORDERS 
    set
        CUSTOMER_ID=? 
    where
        ORDER_ID=?

单向多对一时，先插入一的一端是只有三条insert语句的，这里多了两条update语句。

分析如下：

执行 save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT, 2 条 UPDATE。因为 1 的一端和 n 的一端都维护关联关系，所以会多出 UPDATE。

可以在 1 的一端的 set 节点指定​​inverse=true​​, 来使 1 的一端放弃维护关联关系 !

<set name="orders" table="ORDERS" inverse="true" order-by="ORDER_NAME DESC">
      <!-- 执行多的表中的外键列的名字 -->
      <key column="CUSTOMER_ID"></key>
      <!-- 指定映射类型 -->
      <one-to-many class="Order"/>
</set>

建议设定 set 的​​inverse=true​​, 然后先插入 1 的一端, 后插入多的一端。这样不会多出 UPDATE 语句。

此时测试结果如下所示：

Hibernate: 
    insert 
    into
        CUSTOMERS
        (CUSTOMER_NAME) 
    values
        (?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NAME, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NAME, CUSTOMER_ID) 
    values
        (?, ?)

只有三条insert语句，类似单向多对一时先插入一的一端的效果！

• 先保存多的一端(Order)，再保存一的一端(Customer)

代码如下：

@Test
  public void testMany2OneSave(){
    Customer customer = new Customer();
    customer.setCustomerName("AA");
    
    Order order1 = new Order();
    order1.setOrderName("ORDER-1");
    
    Order order2 = new Order();
    order2.setOrderName("ORDER-2");
    
    //设定关联关系
    order1.setCustomer(customer);
    order2.setCustomer(customer);
    
    customer.getOrders().add(order1);
    customer.getOrders().add(order2);
    
    //先插入 Order, 再插入 Cusomer, 3 条 INSERT, 4 条 UPDATE
    session.save(order1);
    session.save(order2);
    session.save(customer);
  }

测试结果如下：

Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NAME, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NAME, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        CUSTOMERS
        (CUSTOMER_NAME) 
    values
        (?)
Hibernate: 
    update
        ORDERS 
    set
        ORDER_NAME=?,
        CUSTOMER_ID=? 
    where
        ORDER_ID=?
Hibernate: 
    update
        ORDERS 
    set
        ORDER_NAME=?,
        CUSTOMER_ID=? 
    where
        ORDER_ID=?
Hibernate: 
    update
        ORDERS 
    set
        CUSTOMER_ID=? 
    where
        ORDER_ID=?
Hibernate: 
    update
        ORDERS 
    set
        CUSTOMER_ID=? 
    where
        ORDER_ID=?

三条insert语句，4条update语句！

如果一的一端的set节点设置了​​inverse=true​​，即一的一端放弃了维护关系。这是效果等同于单向多对一时先插入多的一端的效果，有三条insert语句，两条update语句！

② 双向多对一获取操作

可以先获取一的一端，然后根据一的一端获取属性多的一端，反之亦然。

不过需要注意的有两点：

• 关联对象的懒加载；
• 懒加载异常；
• 关联对象的代理对象。

测试一如下：

@Test
  public void testMany2OneGet(){
    //1. 若查询多的一端的一个对象, 则默认情况下, 
    //只查询了多的一端的对象. 而没有查询关联的1 的那一端的对象!
    Order order = (Order) session.get(Order.class, 1);
    System.out.println(order.getOrderName()); 
    
    //获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!
    System.out.println(order.getCustomer().getClass().getName());
    
    session.close();
    
    //2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句. 
    Customer customer = order.getCustomer();
    System.out.println(customer.getCustomerName()); 
    
    //3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时, 
    //若此时 session 已被关闭, 则默认情况下
    //会发生 LazyInitializationException 异常

  }

测试二如下：

@Test
  public void testOne2ManyGet(){
    //1. 对 n 的一端的集合使用延迟加载
    Customer customer = (Customer) session.get(Customer.class, 1);
    System.out.println(customer.getCustomerName()); 
    
    //2. 返回的多的一端的集合时 Hibernate 内置的集合类型. 
    //该类型具有延迟加载和存放代理对象的功能. 
    //class org.hibernate.collection.internal.PersistentSet
    System.out.println(customer.getOrders().getClass()); 
    
    //3. 可能会抛出 LazyInitializationException 异常 
    //session.close();
    
    //4. 在需要使用集合中元素的时候进行初始化. 
    System.out.println(customer.getOrders().size()); 
  }

测试二结果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
AA
class org.hibernate.collection.internal.PersistentSet
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_1_,
        orders0_.ORDER_NAME as ORDER_NA2_2_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_2_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
2

③ 双向多对一update操作

同样可以从一的一端和多的一端进行update，如果需要对关联对象进行更新则会将关联对象查询出来。

测试一如下：

@Test
  public void testUpdate(){
    Order order = (Order) session.get(Order.class, 1);
    order.getCustomer().setCustomerName("AAA");
  }

测试一结果如下：

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_2_0_,
        order0_.ORDER_NAME as ORDER_NA2_2_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_2_0_ 
    from
        ORDERS order0_ 
    where
        order0_.ORDER_ID=?
Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Hibernate: 
    update
        CUSTOMERS 
    set
        CUSTOMER_NAME=? 
    where
        CUSTOMER_ID=?

如果只是更新OrderName，则不需要将Customer查询出来，如下所示：

@Test
  public void testUpdate(){
    Order order = (Order) session.get(Order.class, 1);
    order.setOrderName("Order-01");
//    order.getCustomer().setCustomerName("AAA");
  }

测试结果如下：

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_2_0_,
        order0_.ORDER_NAME as ORDER_NA2_2_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_2_0_ 
    from
        ORDERS order0_ 
    where
        order0_.ORDER_ID=?
Hibernate: 
    update
        ORDERS 
    set
        ORDER_NAME=?,
        CUSTOMER_ID=? 
    where
        ORDER_ID=?

测试二如下：

@Test
  public void testUpdat2(){
    Customer customer = (Customer) session.get(Customer.class, 1);
    customer.getOrders().iterator().next().setOrderName("GGG"); 
  }

测试结果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_1_,
        orders0_.ORDER_NAME as ORDER_NA2_2_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_2_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
Hibernate: 
    update
        ORDERS 
    set
        ORDER_NAME=?,
        CUSTOMER_ID=? 
    where
        ORDER_ID=?

如果只是更新CustomName，同样不需要将关联的Order查询出来，如下所示：

@Test
  public void testUpdat2(){
    Customer customer = (Customer) session.get(Customer.class, 1);
    customer.setCustomerName("Customer-01");
//

测试结果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Hibernate: 
    update
        CUSTOMERS 
    set
        CUSTOMER_NAME=? 
    where
        CUSTOMER_ID=?

④ 双向多对一删除操作

在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象。删除多的一端则可以直接删除。

代码如下：

@Test
  public void testDelete(){
    //在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
    Customer customer = (Customer) session.get(Customer.class, 1);
    session.delete(customer); 
  }

测试结果如下：

直接删除Order：

@Test
  public void testDelete(){
    Order order = session.get(Order.class, 1);
    session.delete(order);
  }

测试结果如下：

Hibernate: 
    select
        order0_.ORDER_ID as ORDER_ID1_2_0_,
        order0_.ORDER_NAME as ORDER_NA2_2_0_,
        order0_.CUSTOMER_ID as CUSTOMER3_2_0_ 
    from
        ORDERS order0_ 
    where
        order0_.ORDER_ID=?
Hibernate: 
    delete 
    from
        ORDERS 
    where
        ORDER_ID=?

【3】Set节点的属性配置

​​<set>​​元素来映射持久化类的 set 类型的属性。

• name: 设定待映射的持久化类的属性。
• table: set 中的元素对应的记录放在哪一个数据表中。该值需要和多对一的多的那个表的名字一致 。
• inverse: 指定由哪一方来维护关联关系。 通常设置为 true, 以指定由多的一端来维护关联关系 。
• cascade: 设定级联操作。开发时不建议设定该属性，建议使用手工的方式来处理 。
• order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名。

① inverse属性

在hibernate中通过对​​inverse​​属性的设置来决定是由双向关联的哪一方来维护表和表之间的关系。

inverse = false 的为主动方，inverse = true 的为被动方, 由主动方负责维护关联关系。在没有设置 inverse=true 的情况下，父子两边都维护父子关系 。

在 1-n 关系中，将 n 方设为主控方将有助于性能改善。在 1-N 关系中，若将 1 方设为主控方会额外多出 update 语句(插入数据时无法同时插入外键列，因而无法为外键列添加非空约束)。

② cascade属性

在对象 – 关系映射文件中, 用于映射持久化类之间关联关系的元素, ​​<set>, <many-to-one> 和 <one-to-one>​​ 都有一个 cascade 属性, 它用于指定如何操纵与当前对象关联的其他对象。

• 测试级联删除​​cascade=delete​​

修改Customer.hbm.xml如下：

//...
 <set name="orders" table="ORDERS" inverse="true" 
 order-by="ORDER_NAME DESC" cascade="delete">
        <!-- 执行多的表中的外键列的名字 -->
        <key column="CUSTOMER_ID"></key>
        <!-- 指定映射类型 -->
        <one-to-many class="Order"/>
</set>
 //...

测试代码如下：

@Test
  public void testDelete(){
    //在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
    Customer customer = (Customer) session.get(Customer.class, 1);
    session.delete(customer); 
  }

测试结果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_1_,
        orders0_.ORDER_NAME as ORDER_NA2_2_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_2_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
Hibernate: 
    delete 
    from
        ORDERS 
    where
        ORDER_ID=?
Hibernate: 
    delete 
    from
        ORDERS 
    where
        ORDER_ID=?
Hibernate: 
    delete 
    from
        CUSTOMERS 
    where
        CUSTOMER_ID=?

先查询Customer(1的一端)，再查询出关联的Order(多的一端)。先删除查询出来的n个Order(这里是两个Order，两条delete语句)，再删除Customer !

• 测试级联删除“孤儿”​​cascade="delete-orphan"​​

测试代码如下：

@Test
  public void testCascade(){
    Customer customer = (Customer) session.get(Customer.class, 3);
    //从Set<Order>中移除掉所有的Order元素,此时集合为empty
    //此时Order为"孤儿"  在cascade="delete-orphan"时会被删除
    customer.getOrders().clear();
    
  }

测试结果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_1_,
        orders0_.ORDER_NAME as ORDER_NA2_2_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_2_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc
Hibernate: 
    delete 
    from
        ORDERS 
    where
        ORDER_ID=?
Hibernate: 
    delete 
    from
        ORDERS 
    where
        ORDER_ID=?

查询出Customer，再查询出关联的Order，最后删除关联的所有的Order ！

• 测试级联保存​​cascade="save-update"​​

测试代码如下：

@Test
  public void testMany2OneSave(){
    Customer customer = new Customer();
    customer.setCustomerName("AA");
    
    Order order1 = new Order();
    order1.setOrderName("ORDER-1");
    
    Order order2 = new Order();
    order2.setOrderName("ORDER-2");
    
    //设定关联关系
    order1.setCustomer(customer);
    order2.setCustomer(customer);
    
    customer.getOrders().add(order1);
    customer.getOrders().add(order2);
    
    //只显示保存Customer 在cascade="save-update"时，会保存关联的临时对象
    session.save(customer);
  }

测试结果如下：

Hibernate: 
    insert 
    into
        CUSTOMERS
        (CUSTOMER_NAME) 
    values
        (?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NAME, CUSTOMER_ID) 
    values
        (?, ?)
Hibernate: 
    insert 
    into
        ORDERS
        (ORDER_NAME, CUSTOMER_ID) 
    values
        (?, ?)

三条insert语句，表明将关联的Order级联保存 (此时由多的一方保持维护关系，否则还会有两条update语句)！

③ order-by属性

​​<set>​​​ 元素有一个 order-by 属性, 如果设置了该属性
(值为数据库中列名), 当 Hibernate 通过 select 语句到数据库中检索集合对象时, 利用 order by 子句进行排序。

order-by 属性中还可以加入 SQL 函数。

实例如下：

<set name="orders" table="ORDERS"
   inverse="true" 
   <!-- 数据表中的列名 -->
   order-by="ORDER_NAME DESC"
   cascade="save-update">
          <!-- 执行多的表中的外键列的名字 -->
          <key column="CUSTOMER_ID"></key>
          <!-- 指定映射类型 -->
          <one-to-many class="Order"/>
        </set>

测试结果如下所示：

Hibernate: 
    select
        orders0_.CUSTOMER_ID as CUSTOMER3_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_0_,
        orders0_.ORDER_ID as ORDER_ID1_2_1_,
        orders0_.ORDER_NAME as ORDER_NA2_2_1_,
        orders0_.CUSTOMER_ID as CUSTOMER3_2_1_ 
    from
        ORDERS orders0_ 
    where
        orders0_.CUSTOMER_ID=? 
    order by
        orders0_.ORDER_NAME desc

参考博文：注解版的双向多对一操作