单向n-1的关联关系
单向 n-1 关联:只能从 n 的一端可以访问 1 的一端。
域模型:从 Order 到 Customer 的多对一单向关联需要在Order 类中定义一个 Customer 属性,而在 Customer 类中无有关Order的设置。
关系数据模型: ORDERS 表中的 CUSTOMER_ID 参照 CUSTOMER 表的主键。(外键)
Hibernate 使用 元素来映射多对一关联关系。
例如,在Customer和Order的例子中,首先创建两个类文件:
public class Customer {
private Integer customerId;
private String customerName;
//getters and setters
}
public class Order {
private Integer orderId;
private String orderName;
private Customer customer;
//getters and setters
}
生成hibernate映射文件:
Customer.hbm.xml
这里要注意的是;用hibernate 生成的 hbm.xml文件,主键的生成策略会默认为assigned,这个是由程序员自己指定的,如果在程序是不指定,则会报错。
Order.hbm.xml
多这一端需要注意的有:
1、 使用 many-to-one 来映射多对一的关联关系
2、 name: 多这一端关联的一那一端的属性的名字(多端的属性名)
3、class: 一那一端的属性对应的类名(全限定类名,不带".JAVA"哈哈)
4、column: 一那一端在多的一端对应的数据表中的外键的名字(多端的外键名)。
单向n-1的save操作:
@Test
public void testMany2OneSave(){
Customer customer = new Customer();
customer.setCustomerName("AA");
Order order1 = new Order();
order1.setOrderName("ORDER-1");
Order order2 = new Order();
order2.setOrderName("ORDER-2");
//设定关联关系
order1.setCustomer(customer);
order2.setCustomer(customer);
//执行 save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT
//先插入 1 端, 再插入 n 端, 只有 INSERT 语句.
session.save(customer);
session.save(order1);
session.save(order2);
//先插入 Order, 再插入 Customer. 3 条 INSERT, 2 条 UPDATE
//先插入 n 的一端, 再插入 1 的一端, 会多出 UPDATE 语句!
//因为在插入多的一端时, 无法确定 1 的一端的外键值. 所以只能等 1 的一端插入后, 再额外发送 UPDATE 语句.
//推荐先插入 1 的一端, 后插入 n 的一端
//session.save(order1);
//session.save(order2);
//session.save(customer);
}
}
先插入“1端”能提高效率。
单向n-1的get操作:
@Test
public void testMany2OneGet(){
//1. 若查询n端的一个对象, 则默认情况下, 只查询了n端的对象. 而没有查询关联的 1 的那一端的对象!
Order order = (Order) session.get(Order.class, 1);
System.out.println(order.getOrderName());
System.out.println(order.getCustomer().getClass().getName());
//session.close();
//2. 只有在需要使用到关联的对象时, 才发送对应的 SQL 语句.
Customer customer = order.getCustomer();
System.out.println(customer.getCustomerName());
//3. 在查询 Customer 对象时, 由多的一端导航到 1 的一端时,
//若此时 session 已被关闭, 则默认情况下
//会发生 LazyInitializationException 异常
//4. 获取 Order 对象时, 默认情况下, 其关联的 Customer 对象是一个代理对象!
}
单向n-1的update操作:
@Test
public void testUpdate(){
Order order = (Order) session.get(Order.class, 1);
order.getCustomer().setCustomerName("AAA");
}
单向n-1的delete操作:
@Test
public void testDelete(){
//在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
Customer customer = (Customer) session.get(Customer.class, 1);
session.delete(customer);
}
但是在开发时并不建议设定级联属性,而建议使用手工的方式来处理。
双向1-n的关联关系
Hibernate 使用 元素来映射set类型的属性。
public class Customer {
private Integer customerId;
private String customerName;
/*
* 1. 声明集合类型时, 需使用接口类型, 因为 hibernate 在获取
* 集合类型时, 返回的是 Hibernate 内置的集合类型, 而不是 JavaSE 一个标准的集合实现.
* 2. 需要把集合进行初始化, 可以防止发生空指针异常
*/
private Set orders = new HashSet<>();
//getters and setters
}
public class Order {
private Integer orderId;
private String orderName;
private Customer customer;
//getters and setters
}
Order类与单向时一样,Customer 多了个set
hbm文件(Order映射文件与与单向时相同)
Customer的hbm文件多了
双向1-n的save操作:
@Test
public void testOne2ManySave(){
Customer customer = new Customer();
customer.setCustomerName("AA");
Order order1 = new Order();
order1.setOrderName("ORDER-1");
Order order2 = new Order();
order2.setOrderName("ORDER-2");
//设定关联关系
order1.setCustomer(customer);
order2.setCustomer(customer);
customer.getOrders().add(order1);
customer.getOrders().add(order2);
//执行 save 操作: 先插入 Customer, 再插入 Order, 3 条 INSERT, 2 条 UPDATE
//因为 1 的一端和 n 的一端都维护关联关系. 所以会多出 UPDATE
//可以在 1 的一端的 set 节点指定 inverse=true, 来使 1 的一端放弃维护关联关系!
//建议设定 set 的 inverse=true, 建议先插入 1 的一端, 后插入多的一端
//好处是不会多出 UPDATE 语句
session.save(customer);
session.save(order1);
session.save(order2);
//先插入 Order, 再插入 Cusomer, 3 条 INSERT, 4 条 UPDATE
//session.save(order1);
//session.save(order2);
//session.save(customer);
}
}
那么,如果我们不希望两端都维护关联关系,该怎么办呢?
解决办法是,在hibernate的配置文件中可以通过设置inverse属性来决定是由双向关联的哪一方来维护表和表之间的关系。inverse = false的为主动方,inverse = true 的为被动方。由主动方负责维护关 联关系。在没有设置inverse属性的情况下,默认父子两边都维护父子关系。
在Customer.hbm.xml映射文件中设置set节点为:
双向1-n的get操作:
@Test
public void testOne2ManyGet(){
//1. 对 n 的一端的集合使用延迟加载
Customer customer = (Customer) session.get(Customer.class, 7);
System.out.println(customer.getCustomerName());
//2. 返回的多的一端的集合时 Hibernate 内置的集合类型.
//该类型具有延迟加载和存放代理对象的功能.
System.out.println(customer.getOrders().getClass());
//session.close();
//3. 可能会抛出 LazyInitializationException 异常
System.out.println(customer.getOrders().size());
//4. 再需要使用集合中元素的时候进行初始化.
}
与单向n-1的get操作类似,在双向1-n的get操作中,如果先加载了customer对象,在使用它的orders集合之前,是不会加载orders集合的,这使用了懒加载机制,那么同样,也有可能抛出懒加载异常。
双向1-n的update操作:
@Test
public void testUpdat2(){
Customer customer = (Customer) session.get(Customer.class, 1);
customer.getOrders().iterator().next().setOrderName("GGG");
}
双向1-n的delete操作:
@Test
public void testDelete(){
//在不设定级联关系的情况下, 且 1 这一端的对象有 n 的对象在引用, 不能直接删除 1 这一端的对象
Customer customer = (Customer) session.get(Customer.class, 1);
session.delete(customer);
}
关于双向1-n的两个类的映射文件中,属性的对应关系,如下图所示:
声明本文引用自:https://blog.csdn.net/xiangwanpeng/article/details/53457124