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

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/J080624/article/details/82999912

双向 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>
        
<!--         <set name="orders" lazy="true"  > -->
<!--         	<key column="customer_id"></key> -->
<!--         	<one-to-many class="Order" /> -->
<!--         </set> -->
        <!-- 映射 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 属性, 它用于指定如何操纵与当前对象关联的其他对象。

属性值	描述
none	当Session操作当前对象时，忽略其他关联的对象。它是cascade属性的默认值。
save-update	当通过session的save(),update()即saveOrUpdate()方法来保存或更新当前对象时，级联保存所有关联的新建的临时对象，并且级联更新所有关联的游离对象。
persist	当通过session的persist()方法来保存当前对象时，会级联保存所有关联的新建的临时对象。
merge	当通过session的merge()方法来保存当前对象时，会级联融合所有关联的游离对象。
delete	当通过session的delete()方法删除当前对象时，会级联删除所有关联的对象。
lock	当通过Session的lock()方法把当前游离对象加入到session缓存中时，会把所有关联的游离对象也加入到Session缓存中。
replicate	当通过Session的replicate()方法复制当前对象时，会级联复制所有关联的对象。
evict	当通过Session的evict()方法从Session缓存中清除当前对象时，会级联清除所有关联的对象。
refresh	当通过Session的refresh()方法刷新当前对象时，会级联刷新所有关联的对象。所谓刷新是指读取数据库中相应数据，然后根据数据库中的最新数据去同步更新Session缓存中的相应对象。
all	包含save-update, persist , merge , delete , lock , replicate , evict即refresh的行为。
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=?

查询出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

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