Hibernate - 单向多对一关联关系映射-阿里云开发者社区

在领域模型中, 类与类之间最普遍的关系就是关联关系。

在 UML 中, 关联是有方向的。

以 Customer 和 Order 为例：一个用户能发出多个订单, 而一个订单只能属于一个客户。从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联。

【1】单向n-1

单向 n-1 关联只需从 n 的一端可以访问 1 的一端。

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

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

Customer类如下：

public class Customer {
  private Integer customerId;
  private String customerName;
  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 + "]";
  }
}

Customer.hbm.xml如下：

很普通的一个对象映射关系文件，Customer不需要保持Order属性。

<hibernate-mapping>
    <class name="com.jane.model.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" />
        </property>
    </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如下：

映射单向多对一的关联关系，多的一端需要使用 many-to-one 来映射多对一的关联关系。

<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" />
        </property>
    <!-- 
      映射多对一的关联关系。 使用 many-to-one 来映射多对一的关联关系 
      name: 多的一端关联的一的一端的属性的名字(Order类中Customer属性)
      class: 一那一端的属性对应的类名
      column: 一那一端在多的一端对应的数据表中的外键的名字(order表中保存的customeId)
    -->
    <many-to-one name="customer" class="Customer" column="CUSTOMER_ID"></many-to-one>
    </class>
</hibernate-mapping>

【2】代码测试示例

① 单向多对一持久化

多对一持久化操作的时候，建议先保存一的一端，再保存多的一端，此时只有n+1条insert语句。

  @Test
  public void testMany2OneSave(){
    Customer customer = new Customer();
    customer.setCustomerName("BB");
    Order order1 = new Order();
    order1.setOrderName("ORDER-3");
    Order order2 = new Order();
    order2.setOrderName("ORDER-4");
    //设定关联关系
    order1.setCustomer(customer);
    order2.setCustomer(customer);
    //执行  save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT
    //先插入 1 的一端, 再插入 n 的一端, 只有 INSERT 语句.
    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
        (?, ?)

如果先保存多的一端，后保存一的一端，此时在n+1条语句基础上，还会多出N条update语句。

因为在插入多的一端时, 无法确定 1 的一端的外键值. 所以只能等 1 的一端插入后, 再额外发送 UPDATE 语句。

故而推荐先插入 1 的一端, 后插入 n 的一端。

  @Test
  public void testMany2OneSave(){
    Customer customer = new Customer();
    customer.setCustomerName("BB");
    Order order1 = new Order();
    order1.setOrderName("ORDER-3");
    Order order2 = new Order();
    order2.setOrderName("ORDER-4");
    //设定关联关系
    order1.setCustomer(customer);
    order2.setCustomer(customer);
    //先插入 Order, 再插入 Customer. 3 条 INSERT, 2 条 UPDATE
    //先插入 n 的一端, 再插入 1 的一端, 会多出 UPDATE 语句!
    session.save(order1);
    session.save(order2);
    session.save(customer);
  }

如果先保存多的一端，后保存一的一端，此时在n+1条语句基础上，还会多出N条update语句。

因为在插入多的一端时, 无法确定 1 的一端的外键值. 所以只能等 1 的一端插入后, 再额外发送 UPDATE 语句。

故而推荐先插入 1 的一端, 后插入 n 的一端。

  @Test
  public void testMany2OneSave(){
    Customer customer = new Customer();
    customer.setCustomerName("BB");
    Order order1 = new Order();
    order1.setOrderName("ORDER-3");
    Order order2 = new Order();
    order2.setOrderName("ORDER-4");
    //设定关联关系
    order1.setCustomer(customer);
    order2.setCustomer(customer);
    //先插入 Order, 再插入 Customer. 3 条 INSERT, 2 条 UPDATE
    //先插入 n 的一端, 再插入 1 的一端, 会多出 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=?

② 单向多对一获取

若查询多的一端的一个对象, 则默认情况下, 只查询了多的一端的对象。而没有查询关联的1 的那一端的对象。在需要使用到关联的对象时, 才发送对应的 SQL 语句。

Hibernate默认是懒加载的。可以设置是否懒加载。

获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!

测试代码如下：

  @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());
    //2. 在需要使用到关联的对象时, 才发送对应的 SQL 语句. 
    Customer customer = order.getCustomer();
    System.out.println(customer.getCustomerName());   
  }

测试结果如下：

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=?
ORDER-3
//获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!
com.jane.model.Customer_$$_jvst6c_3
Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
BB

在查询 Customer 对象时, 由多的一端导航到 1 的一端时, 若此时 session 已被关闭, 则默认情况下会发生 LazyInitializationException 异常。

  @Test
  public void testMany2OneGet(){
    Order order = (Order) session.get(Order.class, 1);
    System.out.println(order.getOrderName()); 
    System.out.println(order.getCustomer().getClass().getName());
    //关闭session
    session.close();
    //懒加载异常
    Customer customer = order.getCustomer();
    System.out.println(customer.getCustomerName()); 
  }

如下图所示：

如果单独查询一的一端，则只是普通bean查询：

  @Test
  public void testMany2OneGet2(){
    Customer customer = session.get(Customer.class, 1);
    System.out.println(customer);
  }

测试结果如下：

Hibernate: 
    select
        customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
        customer0_.CUSTOMER_NAME as CUSTOMER2_0_0_ 
    from
        CUSTOMERS customer0_ 
    where
        customer0_.CUSTOMER_ID=?
Customer [customerId=1, customerName=BB]

③ 单向多对一更新

单独更新一的一端或者多的一端，均为正常更新。不需要考虑额外事情。

代码如下：

  @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=?

两条select查询出order，再根据order查询出Customer，最后更新Customer。

④ 单向多对一删除

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

如有Order引用Customer，则不能直接删除Customer。除非设置级联关系。

测试代码如下：

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

此时是有关键约束的，结果如下：

博文是基于XML进行讲解，那么注解版的如何使用呢？

【3】多对一关联中配置属性

如上所示，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" >
    </many-to-one>
    </class>
</hibernate-mapping>

此时默认是懒加载的，查询Order时，不会查询Customer。

除了基本配置外，<many-to-one />节点还有许多属性可供我们配置：

如，我们可以设置禁用懒加载：

<many-to-one name="customer" class="Customer" 
  column="CUSTOMER_ID" lazy="false">
</many-to-one>

此时查询Order时就会同时查询Customer。

但是查询方式还有两种，通过fetch属性控制(select/join，默认为select)：

fetch参数指定了关联对象抓取的方式是select查询还是join查询。

select方式时先查询返回要查询的主体对象（列表），再根据关联外键id，每一个对象发一个select查询，获取关联的对象，形成n+1次查询；

join方式，主体对象和关联对象用一句外键关联的sql同时查询出来，不会形成多次查询。

join方式实例如下：

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_,
        customer1_.CUSTOMER_ID as CUSTOMER1_0_1_,
        customer1_.CUSTOMER_NAME as CUSTOMER2_0_1_ 
    from
        ORDERS order0_ 
    left outer join
        CUSTOMERS customer1_ 
            on order0_.CUSTOMER_ID=customer1_.CUSTOMER_ID 
    where
        order0_.ORDER_ID=?

通常情况下，我们并不使用映射文档进行抓取策略的定制。更多的是，保持其默认值，然后在特定的事务中，使用HQL的左连接抓取（left join fetch）对其进行重载。

Hibernate - 单向多对一关联关系映射

【1】单向n-1

【2】代码测试示例

【3】多对一关联中配置属性

热门文章

最新文章

相关电子书

热门

活动广场

任务中心

开发者评测

高校计划

乘风者计划

训练营

阿里云MVP

话题

直播

下载

镜像站

技术资料

插件

Hibernate - 单向多对一关联关系映射

【1】单向n-1

【2】代码测试示例

【3】多对一关联中配置属性

热门文章

最新文章

相关电子书