Hibernate 双向 多 对 1 对象关系映射 下 ，测试 crud

~~~~~~~~~~~~~~~~~~~~~~~~分割线~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

1. 增：save() 方法

         ①.   先save 1 的一端 ，在保存多的一端

         ②.   先保存多的一端，在保存1 的一端  

@Test
public void testMany2OneSave() {
Customer customer = new Customer();
customer.setCustomerName("Minnie");

Order order1 = new Order();
//		order1.setOrderName("order-1");
order1.setOrderName("order-11");

Order order2 = new Order();
//		order2.setOrderName("order-2");
order2.setOrderName("order-12");
//设定关联关系
order1.setCustomer(customer);
order2.setCustomer(customer);

customer.getOrders().add(order1);
customer.getOrders().add(order2);

/**
* 执行save 操作：先插入Customer ，再插入Order ，3条INSERT 2条Update
*
* 因为1 的一端 和n 的一端都维护关联关系，所以或多次update SQL语句
*
* 可以在1 的一端的 set 节点 指定 inverse=true，使1 的一端放弃维护关联关系
*1.  建议设定 set 的inverse=true ，
*2.  建议先插入1 的一端，后插入多的 一端 ，这样的好处是不会多出update 语句
*
*/

//执行save 操作
session.save(customer);
session.save(order1);
session.save(order2);

//		session.save(order1);
//		session.save(order2);
//		session.save(customer);
}

①.   先save 1 的一端 ，在保存多的一端 ，会 3条INSERT
2条Update
运行结果

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
(?, ?)
Hibernate:
update
ORDERS
set
CUST_ID=?
where
ORDER_ID=?
Hibernate:
update
ORDERS
set
CUST_ID=?
where
ORDER_ID=?
②.   先保存多的一端，在保存1 的一端  [b]3条INSERT
4条Update[/b]

[b]运行结果[/b]

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=?
Hibernate:
update
ORDERS
set
CUST_ID=?
where
ORDER_ID=?
Hibernate:
update
ORDERS
set
CUST_ID=?
where
ORDER_ID=?

原因是：因为1 的一端 和n 的一端都维护关联关系，所以或多次update SQL语句

如何解决：
可以在1 的一端的 set 节点 指定 inverse=true，使1 的一端放弃维护关联关系

  建议：            

                  1.  建议设定 set 的inverse=true ，


           2.  建议先插入1 的一端，后插入多的 一端 ，这样的好处是不会多出update 语句

2. 删：delete() 方法

@Test
public void testMany2OneDelete() {
/**
* 在不设定级联关系的情况下，且1 这一端的对象 被n 的对象在引用，不能直接删除 1 这一端的对象
*/
Customer customer = (Customer) session.get(Customer.class, 1);
customer.getOrders().clear();;
}
3. 改：update() 方法
@Test
public void testMany2OneUpdate() {
Customer customer = (Customer) session.get(Customer.class, 1);
customer.getOrders().iterator().next().setOrderName("Belle");
}
4. 查：get() 方法
@Test
public void testMany2OneGet() {
//1. 对 n 的一端的集合使用延迟加载
Customer customer = (Customer) session.get(Customer.class, 1);
System.out.println(customer.getCustomerName());
System.out.println(customer.getClass());
//2. 返回的多的一端的集合是hibernate 内置的集合类型
// 该类型具有延迟加载和存放代理对象的功能
System.out.println(customer.getOrders().getClass());

//3.可能抛出LazyInitializationException 异常
//session.close()

//4. 再需要使用集合中的元素的时候，进行初始化
Set<Order> orders = (Set<Order>) customer.getOrders();
for(Order order:orders){
System.out.println(order);
}
}