Hibernate - 单向多对一关联关系映射

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

在领域模型中, 类与类之间最普遍的关系就是关联关系。

在 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） 对其进行重载。