Hibernate 单向多 对 1 对象关系映射 下
1. 增:save() 方法
①. 先save 1 的一端 ,在保存多的一端
②. 先保存多的一端,在保存1 的一端
@Test
public void testMany2OneSave() {
Customer customer = new Customer();
customer.setCustomerName("Tom");
Order order1 = new Order();
// order1.setOrderName("order-1");
order1.setOrderName("order-3");
Order order2 = new Order();
// order2.setOrderName("order-2");
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);
/**
* 执行save 操作
*
* 方式二:先承认Order,再插入Customer,除了先有3条INSERT 之后还有2条update
*
* 先插入n 的一端,在插入 一的一段,会多次update语句
* 因为在插入多的一端时,无法确定1 的一端的外键值,所以只能等1 的一端插入完以后,
* 再更新1 的一端的外键值,这时需要在发送update 语句
*
* 因此推荐:先插入1 在插入 n
*/
session.save(order1);
session.save(order2);
session.save(customer);
}
①. 先save 1 的一端 ,在保存多的一端
运行结果
Hibernate:
insert
into
CUSTOMERS
(CUSTOMER_Name)
values
(?)
Hibernate:
insert
into
ORDERS
(ORDER_NAME, CUST_ID)
values
(?, ?)
Hibernate:
insert
into
ORDERS
(ORDER_NAME, CUST_ID)
values
(?, ?)
②. 先保存多的一端,在保存1 的一端 运行结果
Hibernate:
insert
into
ORDERS
(ORDER_NAME, CUST_ID)
values
(?, ?)
Hibernate:
insert
into
ORDERS
(ORDER_NAME, CUST_ID)
values
(?, ?)
Hibernate:
insert
into
CUSTOMERS
(CUSTOMER_Name)
values
(?)
Hibernate:
update
ORDERS
set
ORDER_NAME=?,
CUST_ID=?
where
ORDER_ID=?
Hibernate:
update
ORDERS
set
ORDER_NAME=?,
CUST_ID=?
where
ORDER_ID=?
从结果看,推荐第一种情况①. 先save 1 的一端 ,在保存多的一端,效率会高一点
2. 删:delete() 方法
@Test
public void testMany2OneDelete() {
/**
* 在不设定级联关系的情况下,且1 这一端的对象 被n 这一端 的对象在引用,不能直接删除 1 这一端的对象
*/
Customer customer = (Customer) session.get(Customer.class, 2);
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:
delete
from
CUSTOMERS
where
CUSTOMER_ID=?
发了SQL语句 ,但是会报
3. 改:update() 方法
@Test
public void testMany2OneUpdate() {
Order order = (Order) session.get(Order.class, 3);
order.getCustomer().setCustomerName("Anna");
}
运行结果
Hibernate:
select
order0_.ORDER_ID as ORDER_ID1_1_0_,
order0_.ORDER_NAME as ORDER_NA2_1_0_,
order0_.CUST_ID as CUST_ID3_1_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=?
4. 查:get() 方法
@Test
public void testMany2OneGet() {
/**
* 1. 若查询多的一端的一个对象,则默认情况下,只会查询了多的一端的对象,而不会查询关联的1 的那一端的对象
*/
Order order = (Order) session.get(Order.class, 3);
System.out.println(order.getClass());
/**
* 2. 只有在需要使用关联的对象时,才发送对应的sql 语句,去查询1 那一端的对象
*/
Customer customer = order.getCustomer();
System.out.println(customer.getClass());
System.out.println(customer.getCustomerName());
/**
* 3. 在查询Customer 对象时,由多的一端导航到1 的一端时,
* 若此时session已经关闭,则默认情况下,
* 则会发生LazyInitializationException 异常
*/
/**
* 4. 获取Order 对象时,默认情况下,其关联的Customer 对象是一个代理对象:Customer_$$_javassist_0
*/
}
Hibernate:
select
order0_.ORDER_ID as ORDER_ID1_1_0_,
order0_.ORDER_NAME as ORDER_NA2_1_0_,
order0_.CUST_ID as CUST_ID3_1_0_
from
ORDERS order0_
where
order0_.ORDER_ID=?
class com.baidu.n21.Order
class com.baidu.n21.Customer_$$_javassist_0
Hibernate:
select
customer0_.CUSTOMER_ID as CUSTOMER1_0_0_,
customer0_.CUSTOMER_Name as CUSTOMER2_0_0_
from
CUSTOMERS customer0_
where
customer0_.CUSTOMER_ID=?
Tom