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 类型的属性。

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属性

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

delete-orphan

删除所有和当前对象解除关联关系的对象

all-delete-orphan

包含all和delete-orphan的行为。

测试级联删除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=?

测试结果如下：

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属性

元素有一个 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

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

【1】修改Customer与Order

【2】代码实例

【3】Set节点的属性配置

热门文章

最新文章

相关电子书