Hibernate表关系映射之一对多映射-蒲公英云

一、基本概述
在表中的一对多，是使用外键关联，通过一张表的一个键另一个表的外键来建立一多关系;而在类中表示为一个类中有一个集合属性包含对方类的很多对象，而在另一个类中，只包含前述类的一个对象，从而实现一对多关系的建立！
而在Hibernate中采用的是Set类型集合，使用和来实现。
对于一对多的映射关系可以分为两种情况：单向映射和双向映射。
单向映射：只能从一方访问到另一方，无法反向访问。
双向映射：双方都可以通过映射访问到对方。
这里以双向映射为例，单向映射只需在一端的配置文件和代码中删除相应的代码块即可。
二、实例演示(双向映射)
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

20170310134519592

orders

20170310134532295

运行窗口显示

20170310134544469

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

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 语句，且插入数据时无法同时插入外键列，因而无法为外键列添加非空约束。