Hibernate表关系映射之一对多映射

一、基本概述

在表中的一对多，是使用外键关联，通过一张表的一个键另一个表的外键来建立一多关系;而在类中表示为一个类中有一个集合属性包含对方类的很多对象，而在另一个类中，只包含前述类的一个对象，从而实现一对多关系的建立！

而在Hibernate中采用的是Set类型集合，使用<one-to-many>和<many-to-one>来实现。

对于一对多的映射关系可以分为两种情况：单向映射和双向映射。

单向映射：只能从一方访问到另一方，无法反向访问。

双向映射：双方都可以通过映射访问到对方。

这里以双向映射为例，单向映射只需在一端的配置文件和代码中删除相应的代码块即可。

二、实例演示(双向映射)

1、模型抽象

这里以 Customer 和 Order 为例： 一个客户能发出多个订单, 而一个订单只能属于一个客户. 从 Order 到 Customer 的关联是多对一关联; 而从 Customer 到 Order 是一对多关联。



Customer.java

package com.chen.one2many;

import java.util.HashSet;
import java.util.Set;

public class Customer {
	private Integer customerID;
	private String customerName;
	//持有一个order的集合对象，表示一个客户customer可以有多个订单order
	Set<Order> orders=new HashSet<>();

	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;
	}
	public Set<Order> getOrders() {
		return orders;
	}
	public void setOrders(Set<Order> orders) {
		this.orders = orders;
	}

}

Order.java

package com.chen.one2many;

public class Order {
	private Integer orderID;
	private String orderName;

	//持有一个Customer的引用，一个订单order只能属于一个用户customer
	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;
	}

}

2、配置相关xml文件

Customer.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">
<!-- Generated 2017-3-10 10:28:28 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
    <class name="com.chen.one2many.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>
        <!--利用set标签完成映射
             name:该集合对应的属性名 orders
             table：关联的另一端对应的表名    ORDERS
             cascade 级联关系，当保存或更新时会级联保存与这个Customers对象相关联的所有Orders对象
             inverse=true是将控制权抛出(给Order) -->
        <set name="orders" table="ORDERS" cascade="save-update" inverse="true">
            <key column="CUSTOMER_ID"></key><!-- 表字段 -->
            <one-to-many class="com.chen.one2many.Order"/><!-- 关联的类 -->
        </set>
    </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">
<!-- Generated 2017-3-10 10:28:28 by Hibernate Tools 3.4.0.CR1 -->
<hibernate-mapping>
	<class name="com.chen.one2many.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: 映射的外键名,也就是另一个表的主键 -->
		<many-to-one name="customer" class="com.chen.one2many.Customer"
			column="CUSTOMER_ID"></many-to-one>
	</class>
</hibernate-mapping>

Hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
		"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
		"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>

    	<!-- Hibernate 连接数据库的基本信息 -->
    	<property name="connection.username">root</property>
    	<property name="connection.password">root</property>
    	<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
    	<property name="connection.url">jdbc:mysql://192.168.1.148:3306/hibernate5</property>

		<!-- Hibernate 的基本配置 -->
		<!-- Hibernate 使用的数据库方言，为了使mysql自动生成数据表
		对于mysql5.x使用如下设置 -->
		<property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

		<!-- 运行时是否打印 SQL -->
    	<property name="show_sql">true</property>

    	<!-- 运行时是否格式化 SQL -->
    	<property name="format_sql">true</property>

    	<!-- 生成数据表的策略 -->
    	<property name="hbm2ddl.auto">update</property>

    	<!-- 设置 Hibernate 的事务隔离级别 -->
    	<property name="connection.isolation">2</property>

    	<!-- 删除对象后, 使其 OID 置为 null -->
    	<property name="use_identifier_rollback">true</property>

    	<!-- 配置 C3P0 数据源 -->
    	<property name="hibernate.c3p0.max_size">10</property>
    	<property name="hibernate.c3p0.min_size">5</property>
    	<property name="c3p0.acquire_increment">2</property>

    	<property name="c3p0.idle_test_period">2000</property>
    	<property name="c3p0.timeout">2000</property>

    	<property name="c3p0.max_statements">10</property>

    	<!-- 设定 JDBC 的 Statement 读取数据的时候每次从数据库中取出的记录条数 -->
    	<property name="hibernate.jdbc.fetch_size">100</property>

    	<!-- 设定对数据库进行批量删除，批量更新和批量插入的时候的批次大小 -->
    	<property name="jdbc.batch_size">30</property>

    	<!-- 需要关联的 hibernate 映射文件 .hbm.xml -->
        <mapping resource="com/chen/one2many/Customer.hbm.xml"/>
		<mapping resource="com/chen/one2many/Order.hbm.xml"/>

    </session-factory>
</hibernate-configuration>
 

3、编写测试方法

HibernateTest.java

package com.chen.one2many;

import java.util.Iterator;
import java.util.Set;

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;

public class HibernateTest {
	private static SessionFactory sessionFactory;
	private static Session session;
	private static Transaction transaction;

	//定义事务初始化函数
	public static void init(){
		Configuration configuration = new Configuration().configure();
		ServiceRegistry serviceRegistry =
				new ServiceRegistryBuilder().applySettings(configuration.getProperties())
				                            .buildServiceRegistry();
		sessionFactory = configuration.buildSessionFactory(serviceRegistry);

		session = sessionFactory.openSession();
		transaction = session.beginTransaction();
	}

	//定义事务结束时的处理函数
	public static void doit(){
		transaction.commit();
		session.close();
		sessionFactory.close();
	}

	//编写自己的处理过程
	public static void test(){
		//初始化基本信息：一个客户chen有两个订单book和food
		Customer customer=new Customer();
		customer.setCustomerName("chen");
		Order order1=new Order();
		order1.setOrderName("book");
		Order order2=new Order();
		order2.setOrderName("food");

		//设置对应关系（双向映射）

		//关联customer
		order1.setCustomer(customer);
		order2.setCustomer(customer);
		//关联order
		customer.getOrders().add(order1);
		customer.getOrders().add(order2);

		//因为配置文件中cascade="save-update"，所以保存customer时会级联保存与之相关的order
		session.save(customer);	

		//从order表中获取customer
		Order orderResult=(Order) session.get(Order.class, 1);
		String ordername=orderResult.getOrderName();
		String customername=orderResult.getCustomer().getCustomerName();
		System.out.println(ordername+" is owned by "+customername);

		//从customer表中获取order
		Customer customerResult=(Customer) session.get(Customer.class, 1);
		Set<Order> set=customerResult.getOrders();
		System.out.println(set.size());
		for (Iterator iterator2 = set.iterator(); iterator2.hasNext();) {
			Order order = (Order) iterator2.next();
			System.out.println(order.getOrderName());
		}
	}
	public static void main(String[] args) {
		HibernateTest.init();
		HibernateTest.test();
		HibernateTest.doit();
		System.out.println("完成---------");
	}

}

4、运行结果

数据表

customers

orders

运行窗口显示

三、单向一对多映射与双向映射原理相同，只是把其中一端的配置文件和代码进行删减即可。具体而言：

1、单向order--->customer。即order中持有customer的一个引用。

order端的代码和配置文件不用改。把customer代码中的order集合代码删除，配置文件中的set标签内容删除。

2、单向customer---->order。不推荐。操作复杂

一般推荐使用order（多的一端）持有customer（一的一端）的引用，这样可以减小维护代价。

四、inverse 属性详解

在hibernate中通过对 inverse 属性的来决定是由双向关联的哪一方来维护表和表之间的关系。inverse = false 的为主动方，inverse = true 的为被动方即交出控制权, 由主动方负责维护关联关系。在没有设置 inverse=true 的情况下，父子两边都维护关联关系 。

在 1-N关系中，将 N 方设为主控方将有助于性能改善。在 1-N 关系中，若将 1 方设为主控方会额外多出 update 语句，且插入数据时无法同时插入外键列，因而无法为外键列添加非空约束。