hibernate映射-单向多对一映射

（如有错误或不足之处，敬请指正，不甚感激 ^_^）

hibernate中单向多对一的映射关系情况：

单向 n-1 关联只需要从n的一端可以访问1的一端。

举例： Customer-Order

一个顾客（Customer）可以同时有多个订单（Order）。在单向多对一的情况中，Customer类中，并没有关于Order的集合属性，Order中有一个Customer属性。（这里就是单向多对一与双向多对一的区别，在双向多对一中，Customer中有一个Set<Order>属性）

一、代码演示：

{类文件↓}

Customer:

 1 public class Customer {
 2     
 3     private Integer customerId;
 4     private String customerName;
 5     
 6     public Integer getCustomerId() {
 7         return customerId;
 8     }
 9     public void setCustomerId(Integer customerId) {
10         this.customerId = customerId;
11     }
12     public String getCustomerName() {
13         return customerName;
14     }
15     public void setCustomerName(String customerName) {
16         this.customerName = customerName;
17     }
18     
19 }

Customer.class

Order:

 1 public class Order {
 2     
 3     private Integer orderId;
 4     private String orderName;
 5     
 6     private Customer customer;
 7 
 8     public Integer getOrderId() {
 9         return orderId;
10     }
11 
12     public void setOrderId(Integer orderId) {
13         this.orderId = orderId;
14     }
15 
16     public String getOrderName() {
17         return orderName;
18     }
19 
20     public void setOrderName(String orderName) {
21         this.orderName = orderName;
22     }
23 
24     public Customer getCustomer() {
25         return customer;
26     }
27 
28     public void setCustomer(Customer customer) {
29         this.customer = customer;
30     }
31     
32 }

Order.class

在映射文件中：

Customer是1的一端，Order是多的一端。可想而知，Order表中是有一个外键来指向Customer的。

{映射文件↓}

Customer.hbm.xml:

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2015-11-29 10:18:07 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping>
 6     <class name="com.zit.hibernate.n21.Customer" table="CUSTOMERS">
 7         <id name="customerId" type="java.lang.Integer">
 8             <column name="CUSTOMER_ID" />
 9             <generator class="native" />
10         </id>
11         <property name="customerName" type="java.lang.String">
12             <column name="CUSTOMER_NAME" />
13         </property>
14     </class>
15 </hibernate-mapping>

Customer.hbm.xml

Order.hbm.xml:

 1 <?xml version="1.0"?>
 2 <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4 <!-- Generated 2015-11-29 10:18:07 by Hibernate Tools 3.4.0.CR1 -->
 5 <hibernate-mapping package="com.zit.hibernate.n21">
 6     <class name="Order" table="ORDERS">
 7         <id name="orderId" type="java.lang.Integer">
 8             <column name="ORDER_ID" />
 9             <generator class="native" />
10         </id>
11         <property name="orderName" type="java.lang.String">
12             <column name="ORDER_NAME" />
13         </property>
14         <many-to-one name="customer" class="Customer">
15             <column name="CUSTOMER_ID" />
16         </many-to-one>
17     </class>
18 </hibernate-mapping>

Order.hbm.xml

二、使用注意：

1.插入时：要先插入1的一端，再插入多的一端。若先插入多的一端，则会多执行UPDATE语句，降低了程序执行效率与性能。（先插入多的一端的值，则它的外键值可能是某个中间值或其他，再插入1的一端的值后，才能将其进行更新操作，所以会多出UPDATE语句）

session.save(object);

2.查询时：

①查询多的一端的对象时，默认情况下只查询了多的一端的对象，没有查询出对应的1的一端的对象。

session.get(object.class, num);

②在需要使用关联的1的一端的对象时，才会发送对应的SQL语句去查询该对象。

③注意懒加载异常（由多的一端导航到1的一端时，可能会发生）

　　 LazyIniializationException

　 ④得到Order对象时，获得的是Customer的代理对象。　

3.更新时：

4.删除时：

①在1的一端进行删除时，要进行设置级联删除，否则当多的一端有记录在引用该1的一端的记录时，不能删除（若多的一端没有记录在引用该1的一端，则还是可以删除的）。　

1 <many-to-one name="customer" class="Customer" cascade="delete">
2             <column name="CUSTOMER_ID" />
3         </many-to-one>

Order.hbm.xml设置级联删除