Hibernate 框架映射关联关系

单向多对一关联关系

Hibernate 使用 <\many-to-one> 元素来映射多对一关联关系

例子（用户可以有多个订单，一个订单对应一个用户）

Customer.java

package com.hibernate.entities.n21;

public class Customer {

private int customerId;
private String customerName;

public int getCustomerId() {
return customerId;
}
public void setCustomerId(int customerId) {
this.customerId = customerId;
}
public String getCustomerName() {
return customerName;
}
public void setCustomerName(String customerName) {
this.customerName = customerName;
}
}

Order.java

package com.hibernate.entities.n21;

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;
}

@Override
public String toString() {
return "Order [orderId=" + orderId + ", orderName=" + orderName
+ ", customer=" + customer + "]";
}

public void setCustomer(Customer customer) {
this.customer = customer;
}
}

Custormer.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.entities.n21">
<class name="Customer" table="CUSTOMER">
<id name="customerId" type="int">
<column name="CUSTOMER_ID" />
<generator class="native" />
</id>
<property name="customerName" type="java.lang.String">
<column name="CUSTOMER_NAME" />
</property>
</class>
</hibernate-mapping>

Order.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.entities.n21">
<class name="Order" table="ORDERS">
<id name="orderId" type="java.lang.Integer">
<column name="ORDERID" />
<generator class="native" />
</id>
<property name="orderName" type="java.lang.String">
<column name="ORDER_NAME" />
</property>

<!-- 映射多对一的映射关系，使用many-to-one 来映射多对一的映射关系
name：多这一端关联的映射名字
class：设定待映射的持久化类的属性的类型
column：设定和持久化类的属性对应的表的外键
-->
<many-to-one name="customer" class="Customer" column="CUSTOMER_ID">
</many-to-one>
</class>
</hibernate-mapping>

PropertiesTest.java

package com.hibernate.entities.n21;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

import com.sun.org.apache.xpath.internal.operations.Or;

public class PropertiesTest {
SessionFactory sessionFactory;
Session session;
Transaction transaction;

@Before
public void init() {
Configuration configuration = new Configuration().configure();
@SuppressWarnings("deprecation")
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
.applySettings(configuration.getProperties()).buildServiceRegistry();
sessionFactory = configuration.buildSessionFactory(serviceRegistry);
session = sessionFactory.openSession();
transaction = session.beginTransaction();
}

@After
public void destory() {
transaction.commit();
session.close();
sessionFactory.close();
}

/**
* 在不设定级联关系的情况下，不能直接删除一对多且有多的情况下一这一端的数据
*/
@Test
public void testMany2OneDelete() {
Order order = (Order) session.get(Order.class, 1);
session.delete(order.getCustomer());
}

@Test
public void testMany2OneUpdate() {
Order order = (Order) session.get(Order.class, 1);
order.getCustomer().setCustomerName("barry");
}

/**
* 1. 若查询多的一端的对象，默认情况下只查询了多的一端的对象，而没有查询一的一端的对象（延迟加载）
* 2. 若需要使用一的一端的对象，才会发送对应的 SQL 语句
* 3. 在查询Customer一端的时，由多的一端导航到一的一端
*      如果session关闭，在默认情况下会抛出 LazyInitializationException 异常
* 4. 获取 Order 对象时，默认情况下其关联的对象是一个代理对象
*/
@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.close();
Customer customer = order.getCustomer();

System.out.println(customer.getCustomerName());
}

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

Order order1 = new Order();
order1.setOrderName("外套-1");
Order order2 = new Order();
order2.setOrderName("外套-2");

//设置关联关系
order1.setCustomer(customer);
order2.setCustomer(customer);

//执行save
//先插入Customer，再插入Order，3条INSERT
session.save(customer);
session.save(order1);
session.save(order2);

//先插入 Order，在插入 Customer，3条INSERT，两条UPDATE；先插入多的一端会多两条UPDATE语句，推荐先插入1的一端
/*session.save(order1);
session.save(order2);

session.save(customer);*/
}
}

双向一对多关联关系

这里仍然使用用户和订单例子，只需修改上面Customer文件

Customer.java需要添加orders属性

/**
* 1. 声明集合时需要使用接口类型，因为Hibernate在获取接口时返回的是Hibernate内置的集合类型，而不是JavaSe中标准的集合类型
* 2. 需要把集合初始化，防止出现空指针异常
*/
private Set<Order> orders = new HashSet<>();
public Set<Order> getOrders() {
return orders;
}
public void setOrders(Set<Order> orders) {
this.orders = orders;
}

Customer.hbm.xml中添加

<!-- 映射 1 对 多的关联关系 -->
<!-- set: 映射 set 类型的属性, table: set 中的元素对应的记录放在哪一个数据表中. 该值需要和多对一的多的那个表的名字一致 -->
<!-- inverse: 指定由哪一方来维护关联关系. 通常设置为 true, 以指定由多的一端来维护关联关系 -->
<!-- cascade 设定级联操作. 开发时不建议设定该属性. 建议使用手工的方式来处理 -->
<!-- order-by 在查询时对集合中的元素进行排序, order-by 中使用的是表的字段名, 而不是持久化类的属性名  -->
<set name="orders" table="ORDERS" inverse="true" cascade="delete-orphan" order-by="ORDER_NAME DESC">
<!-- 执行多的表中的外键列的名字 -->
<key column="CUSTOMER_ID"></key>
<!-- 指定映射类型 -->
<one-to-many class="Order"/>
</set>

PropertiesTest.java

package com.hibernate.entities.n21.both;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.service.ServiceRegistry;
import org.hibernate.service.ServiceRegistryBuilder;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class PropertiesTest {
SessionFactory sessionFactory;
Session session;
Transaction transaction;

@Before
public void init() {
Configuration configuration = new Configuration().configure();
@SuppressWarnings("deprecation")
ServiceRegistry serviceRegistry = new ServiceRegistryBuilder()
.applySettings(configuration.getProperties()).buildServiceRegistry();
sessionFactory = configuration.buildSessionFactory(serviceRegistry);
session = sessionFactory.openSession();
transaction = session.beginTransaction();
}

@After
public void destory() {
transaction.commit();
session.close();
sessionFactory.close();
}

@Test
public void testCascade() {
Customer customer = (Customer) session.get(Customer.class, 2);
customer.getOrders().clear();
}

/**
* 在不设定级联关系的情况下，不能直接删除一对多且有多的情况下一这一端的数据
*/
@Test
public void testDelete() {
Order order = (Order) session.get(Order.class, 1);
session.delete(order.getCustomer());
}

@Test
public void testOne2ManyUpdate() {
Customer customer = (Customer) session.get(Customer.class, 1);
customer.getOrders().iterator().next().setOrderName("连衣裙");
}

@Test
public void testMany2OneUpdate() {
Order order = (Order) session.get(Order.class, 1);
order.getCustomer().setCustomerName("barry");
}

/**
* 1. 对 n 的一端使用延迟加载
*/
@Test
public void testOne2ManyGet() {
Customer customer = (Customer) session.get(Customer.class, 3);
System.out.println(customer.getCustomerName());
// 返回多的一端的集合是Hibernate内置的集合类型，该类型具有延迟加载和存放代理对象的作用
System.out.println(customer.getOrders().getClass());
// 可能会抛出 LazyInitializationException 异常
//session.close();

//4. 需要使用集合中元素的时候进行初始化.
System.out.println(customer.getOrders());
}

/**
* 1. 若查询多的一端的对象，默认情况下只查询了多的一端的对象，而没有查询一的一端的对象（延迟加载）
* 2. 若需要使用一的一端的对象，才会发送对应的 SQL 语句
* 3. 在查询Customer一端的时，由多的一端导航到一的一端
*      如果session关闭，在默认情况下会抛出 LazyInitializationException 异常
* 4. 获取 Order 对象时，默认情况下其关联的对象是一个代理对象
*/
@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.close();
Customer customer = order.getCustomer();

System.out.println(customer.getCustomerName());
}

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

Order order1 = new Order();
order1.setOrderName("外套-1");
Order order2 = new Order();
order2.setOrderName("外套-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，在插入 Customer，3条INSERT，4条UPDATE；
/*session.save(order1);
session.save(order2);

session.save(customer);*/
}
}

在对象 – 关系映射文件中, 用于映射持久化类之间关联关系的元素, <\set>, <\many-to-one> 和 <\one-to-one> 都有一个 cascade 属性, 它用于指定如何操纵与当前对象关联的其他对象. 不建议使用

一对一关联关系

以部门、部门经理为例

基于外键映射的 1-1

对于基于外键的1-1关联，其外键可以存放在任意一边，在需要存放外键一端，增加many-to-one元素。为many-to-one元素增加unique=“true” 属性来表示为1-1关联

<many-to-one name="manager" column="MANAGER_ID" unique="true" class="Manager"></many-to-one>

另一端需要使用one-to-one元素，该元素使用 property-ref 属性指定使用被关联实体主键以外的字段作为关联字段

<one-to-one name="department" property-ref="manager" class="Department"></one-to-one>

基于主键映射的 1-1

基于主键的映射策略:指一端的主键生成器使用 foreign 策略,表明根据”对方”的主键来生成自己的主键，自己并不能独立生成主键. 子元素指定使用当前持久化类的哪个属性作为 “对方”

采用foreign主键生成器策略的一端增加 one-to-one 元素映射关联属性，其one-to-one属性还应增加 constrained=“true” 属性；另一端增加one-to-one元素映射关联属性。

constrained(约束):指定为当前持久化类对应的数据库表的主键添加一个外键约束，引用被关联的对象(“对方”)所对应的数据库表主键

Department.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.entities.one2one.primary">
<class name="Department" table="DEPARTMENT">
<id name="depId" type="int">
<column name="DEP_ID" />
<!-- 使用外键的方式来生成当前的主键 -->
<generator class="foreign">
<!-- property 属性指定使用当前持久化类的哪一个属性的主键作为外键 -->
<param name="property">manager</param>
</generator>
</id>
<property name="depName" type="java.lang.String">
<column name="DEP_NAME" />
</property>
<!--
采用 foreign 主键生成器策略的一端增加 one-to-one 元素映射关联属性,
其 one-to-one 节点还应增加 constrained=true 属性, 以使当前的主键上添加外键约束
-->
<one-to-one name="manager" class="Manager" constrained="true"></one-to-one>
</class>
</hibernate-mapping>

Manager.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.hibernate.entities.one2one.primary">
<class name="Manager" table="MANAGER">
<id name="managerId" type="int">
<column name="MANAGER_ID" />
<generator class="native" />
</id>
<property name="managerName" type="java.lang.String">
<column name="MANAGER_NAME" />
</property>

<one-to-one name="department" class="Department"></one-to-one>
</class>
</hibernate-mapping>

映射多对多关联关系

双向 n-n 关联需要两端都使用集合属性

双向n-n关联必须使用连接表

集合属性应增加 key 子元素用以映射外键列, 集合元素里还应增加many-to-many子元素关联实体类

在双向 n-n 关联的两边都需指定连接表的表名及外键列的列名. 两个集合元素 set 的 table 元素的值必须指定，而且必须相同。set元素的两个子元素：key 和 many-to-many 都必须指定 column 属性，其中，key 和 many-to-many 分别指定本持久化类和关联类在连接表中的外键列名，因此两边的 key 与 many-to-many 的column属性交叉相同。也就是说，一边的set元素的key的 cloumn值为a,many-to-many 的 column 为b；则另一边的 set 元素的 key 的 column 值 b,many-to-many的 column 值为 a.

对于双向 n-n 关联, 必须把其中一端的 inverse 设置为 true, 否则两端都维护关联关系可能会造成主键冲突.

<!-- 指定中间表 -->
<set name="items" table="CATEGORIES_ITEMS" inverse="false" lazy="true">
<key>
<column name="C_ID" />
</key>
<!-- 使用 many-to-many 指定多对多的关联关系，column 指定 set 集合中持久化类在中间表的外间列的名称 -->
<many-to-many class="Item" column="I_ID"></many-to-many>
</set>

<set name="categories" table="CATEGORIES_ITEMS" inverse="true" lazy="true">
<key column="I_ID"></key>
<many-to-many class="Category" column="C_ID"></many-to-many>
</set>