AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

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

2023-12-13 39
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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） 对其进行重载。

文章标签：
Java
数据库连接
SQL
uml
XML
关键词：
Hibernate关系映射
Hibernate单向
Hibernate单向多对一
流烟默
目录
相关文章
流烟默
|
6月前
|
SQL Java 关系型数据库
Hibernate - 对象关系映射文件(*.hbm.xml)详解
Hibernate - 对象关系映射文件(*.hbm.xml)详解
流烟默
255 1
流烟默
|
6月前
|
SQL 存储 Java
Hibernate - 继承关联关系映射
Hibernate - 继承关联关系映射
流烟默
71 0
流烟默
|
6月前
|
机器学习/深度学习 SQL Java
Hibernate - 多对多关联关系映射
Hibernate - 多对多关联关系映射
流烟默
60 0
流烟默
|
6月前
|
SQL Java 数据库连接
Hibernate -双向一对一关联关系映射
Hibernate -双向一对一关联关系映射
流烟默
54 0
王卫
|
SQL XML Java
Hibernate框架【四】——基本映射——多对一和一对多映射
Hibernate框架【四】——基本映射——多对一和一对多映射
王卫
171 0
小许同学
|
XML Java 数据库连接
《Hibernate上课笔记》----class4----Hibernate继承关系映射实现详解
《Hibernate上课笔记》----class4----Hibernate继承关系映射实现详解
小许同学
93 0
《Hibernate上课笔记》----class4----Hibernate继承关系映射实现详解
热烈的马
|
SQL 存储 数据可视化
Java Web之Hibernate的高级应用(数据库实体关联之间的映射规则、实体继承关系映射、Hibernate查询语言)
Java Web之Hibernate的高级应用(数据库实体关联之间的映射规则、实体继承关系映射、Hibernate查询语言)
热烈的马
187 0
Java Web之Hibernate的高级应用(数据库实体关联之间的映射规则、实体继承关系映射、Hibernate查询语言)
danny_idea
|
XML Java 关系型数据库
hibernate里面的一对多关系映射
hibernate里面的一对多关系映射
danny_idea
111 0
游客nhhwponctadnk
|
Java 数据库连接 网络安全
【SSH快速进阶】——Hibernate 多对一映射 和 一对多映射
上两篇文章说了一对一映射，这里说一下多对一　和　一对多的映射情况。
游客nhhwponctadnk
195 0
【SSH快速进阶】——Hibernate 多对一映射 和 一对多映射
两个蝴蝶飞
|
存储 Java 数据库连接
Hibernate的一对多映射的单向关联和双向关联(九)
Hibernate的一对多映射的单向关联和双向关联(九)
两个蝴蝶飞
132 0
Hibernate的一对多映射的单向关联和双向关联(九)