在电子商务应用中，经常会有这样的需求：根据给定的客户，得到该客户的所有订单；根据给定的订单，得到该订单的所属客户。对于这种双向关联的情况，在Hibernate应用中，也有人叫多对一双向关联，只是叫法不同而已，都是通过映射一对多双向关联关系来实现的。

不管是多对一单向关联还是（一对多）多对一双向关联，在关系型数据库中的表现方式都是一样的，均通过外键参照来实现如图4-18所示。

只是在持久化类与ORM映射文件中单向关联与双向关联存在一些区别而已，如图4-19所示。

持久化类Customer.java：

1. package com.ORM;
2. import java.io.Serializable;
3. import java.util.*;
4. public class Customer implements Serializable{
5. private java.lang.Integer id;               //ID号
6. private java.lang.String cname;                 //客户姓名
7. private java.lang.String bank;              //银行账号
8. private java.lang.String phone;                 //联系电话
9. private Set orders = new HashSet();             //订单集合
10. public Customer(){}
11. //省略上述各属性的get/set方法对
12. }

持久化类Orders.java：

1. package com.ORM;
2. import java.io.Serializable;
3. public class Orders implements Serializable{
4. private java.lang.Integer id;               //ID号
5. private java.lang.String orderno;               //订单编号
6. private java.lang.Double money;                 //订单金额
7. private Customer customer;              //订单的所属客户
8. public Orders(){}
9. //省略上述各属性的get/set方法对
10. }

customer表与Customer类的ORM映射文件Customer.hbm.xml：

1. <hibernate-mapping package="com.ORM">
2. <class name="Customer" table="customer">
3. <id name="id" column="ID" type="integer">
4. <generator class="identity"/>
5. </id>
6. <property name="cname" column="CNAME" type="string" />
7. <property name="bank" column="BANK" type="string" />

orders表与Orders类的ORM映射文件Orders.hbm.xml：

（1）创建供测试用的TestBean.java。

1. ……
2. public void addCustomer(){
3. Customer customer = new Customer();
4. customer.setCname("张三");
5. customer.setBank("123456789123456789");
6. customer.setPhone("020-12345678");
7. dao.addCustomer(customer);
8. }
9. public Customer loadCustomer(Integer id){
10. return dao.loadCustomer(id);
11. }
12. public void addOrders(Customer customer){
13. Orders order = new Orders();
14. order.setOrderno(new Long(System.currentTimeMillis()).toString());
15. order.setMoney(new Double(rnd.nextDouble()*10000));
16. //将Customer与Orders实例进行双向关联
17. order.setCustomer(customer);
18. customer.getOrders().add(order);
19. dao.addOrders(order);
20. }
21. public Orders loadOrders(Integer id){
22. return dao.loadOrders(id);
23. }
24. ……

（2）创建测试JSP页面index.jsp。

1. <jsp:useBean id="test" class="com.bean.TestBean" />
2. ...........

index.jsp运行分析。

（1）执行了test.addCustomer()以后，Hibernate向数据库服务器提交的SQL语句为：

1. 【SQL】insert into customer (CNAME, BANK, PHONE) values
2. ("张三", "123456789123456789","020-12345678")

（2）执行了test.loadCustomer(id)以后，Hibernate向数据库服务器提交的SQL语句为：

1. 【SQL】select * from customer where ID=1
2. select * from orders where CUSTOMER_ID=1

由于Customer.hbm.xml中的lazy="false"，在装载Customer后，会立即装载与当前Customer对象一对多关联的所有Orders对象。

（3）执行了test.addOrders(customer);以后，Hibernate向数据库服务器提交的SQL语句为：

1. 【SQL】insert into orders(ORDERNO,MONEY,CUSTOMER_ID)
2. values("1163858590843",7158.76,1)

（4）执行了test.loadOrders(newInteger(1));以后，Hibernate向数据库服务器提交的SQL语句为：

1. 【SQL】select * from orders where ID=1
2. select * from customer where ID=1

由于Orders.hbm.xml中的lazy="false"，在装载Orders后，会立即装载与当前Orders对象多对一关联的Customer对象。

index.jsp运行效果如图4-20所示。