在领域模型中, 类与类之间最普遍的关系就是关联关系。
在 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);
}
如下所示：
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） 对其进行重载。
参考博文：Hibernate对象检索方式
