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

简介: 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) 对其进行重载。

目录
相关文章
|
9月前
|
SQL XML Java
Hibernate框架【四】——基本映射——多对一和一对多映射
Hibernate框架【四】——基本映射——多对一和一对多映射
102 0
|
Java 数据库连接 网络安全
【SSH快速进阶】——Hibernate 多对一映射 和 一对多映射
上两篇文章说了一对一映射,这里说一下多对一 和 一对多的映射情况。
【SSH快速进阶】——Hibernate 多对一映射 和 一对多映射
|
Java 数据库连接
【Jpa hibernate】一对多@OneToMany,多对一@ManyToOne的使用
项目中使用实体之间存在一对多@OneToMany,多对一@ManyToOne的映射关系,怎么设置呢? GitHub地址:https://github.com/AngelSXD/myagenorderdiscount可以查看完整项目 下面给一个例子: 类似于一个部门对应多个员工 这里给出 一个流水账单对应多条订单折扣信息   流水账单类: package com.
8825 0
|
Java 数据库连接 关系型数据库
|
Java 关系型数据库 数据库连接