Hibernate-映射关系- 1<->n(双向)

紧接上一篇博文,

双向 1-n 与双向 n-1 是完全相同的两种情形

双向 1-n 需要在1的一端可以访问n的一端,反之依然.

域模型:从Order到Customer的多对一双向关联需要在Order类中定义一个Customer属性,而在Customer类中需定义存放Order对象的集合属性

关系数据模型:ORDERS表中的CUSTOMER_ID参照CUSTOMER表的主键

几个注意点：

 当 Session从数据库中加载Java集合时,创建的是Hibernate内置集合类的实例,因此 在持久化类中定义集合属性时必须把属性声明为 Java 接口类型

–Hibernate 的内置集合类具有集合代理功能, 支持延迟检索策略

–事实上,Hibernate 的内置集合类封装了 JDK 中的集合类,这使得Hibernate能够对缓存中的集合对象进行脏检查,按照集合对象的状态来同步更新数据库。

 在定义集合属性时, 通常把它初始化为集合实现类的一个实例.这样可以提高程序的健壮性,避免应用程序访问取值为null的集合的方法抛出NullPointerException

详细介绍实现方式：

 Hibernate 使用 <set>元素来映射set类型的属性

 <set> 元素来映射持久化类的 set 类型的属性  

name: 设定待映射的持久化类的属性的,

<key>元素设定与所关联的持久化类对应的表的外键–column:指定关联表的外键名   

<one-to-many>元素设定集合属性中所关联的持久化类–class:指定关联的持久化类的类名

在介绍set中两个属性：

<set> 元素的inverse属性
在hibernate中通过对 inverse 属性的来决定是由双向关联的哪一方来维护表和表之间的关系. inverse = false 的为主动方，inverse = true 的为被动方, 由主动方负责维护关 联关系
在没有设置 inverse=true 的情况下，父子两边都维护父子关系 
在 1-n 关系中，将 n 方设为主控方将有助于性能改善(如果要国家元首记住全国人民的名字，不是太可能，但要让全国人民知道国家元首，就容易的多)
在 1-N 关系中，若将 1 方设为主控方会额外多出 update 语句。
插入数据时无法同时插入外键列，因而无法为外键列添加非空约束
cascade 属性：
在对象 – 关系映射文件中, 用于映射持久化类之间关联关系的元素, <set>, <many-to-one> 和 <one-to-one> 都有一个 cascade 属性, 它用于指定如何操纵与当前对象关联的 其他对象. 

具体代码实现：

Order.java

/*
 * 文件名：Order.java
 * 版权：Copyright by www.huawei.com
 * 描述：
 * 修改人：Cuigaochong
 * 修改时间：2015-10-23
 * 跟踪单号：
 * 修改单号：
 * 修改内容：
 */

package com.cgc.hibernate.n21both;

/**
 * <一句话功能简述> <功能详细描述>
 * 
 * @author 姓名 工号
 * @version [版本号, 2015-10-23]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
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;
    }
    
    public void setCustomer(Customer customer)
    {
        this.customer = customer;
    }
    
}

Order.java

/*
 * 文件名：Customer.java
 * 版权：Copyright by www.huawei.com
 * 描述：
 * 修改人：Cuigaochong
 * 修改时间：2015-10-23
 * 跟踪单号：
 * 修改单号：
 * 修改内容：
 */

package com.cgc.hibernate.n21both;

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

/**
 * <一句话功能简述> <功能详细描述>
 * 
 * @author 姓名 工号
 * @version [版本号, 2015-10-23]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public class Customer
{
    
    private Integer customerId;
    
    private String customerName;
    
    private Set<Order> orders = new HashSet<Order>();
    
    /*
     * 0:声明集合类型时，需使用接口类型，因为hibernate在获取集合类型时 返回的是Hibernate的集合类型，而不是javase的标准的集合实现1： 需要把集合进行初始化 可以防止发生空指针异常
     */

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

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.cgc.hibernate.n21both">

    <class name="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>
		
		 <!-- 映射多对一的关联关系 -->
		 <!-- 
		 	name:多这一端 关联的一那一端的属性名字；
		 	class:一那一端的属性对应的类型；
		 	column:一那一端在多的一端对应的数据表中的外键的名字；
		  -->
        <many-to-one name="customer" class="Customer" column="CUSTOMER_ID">
        </many-to-one>
		
    </class>
</hibernate-mapping>

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">

<hibernate-mapping package="com.cgc.hibernate.n21both">
    
    <class name="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:映射set类型的属性，table:set中的元素对应的记录放在哪一个数据表中，该值要和多对一的多的那个表的名字一致  -->
        <!-- inverse指定由哪一方来维护关联关系   通常设置为true以指定由多的一端来维护关联关系 -->
        
        <!-- cascade="delete" ,设定级联删除 ,cascade="delete-orphan"解除customer和order的关系，order剩下的孤儿对象   要被删除 -->
        <!--cascade="save-update"设定级联保存    cascade 级联属性   开发时不建议设置该属性  -->
        <!--order-by="ORDER_NAME desc 排序，在查询时根据属性 排序 order-by中使用的是表的字段名  ，以上为 根据  ORDER_NAME，降序-->
        <set name="orders" table="ORDERS" inverse="true" order-by="ORDER_NAME desc">
        	<!-- 执行多的表中的外键列的名字 -->
        	<key column="CUSTOMER_ID"></key>
        	<!-- 指定映射类型 -->
        	<one-to-many class="Order"/>
        </set>
        
    </class>
    
</hibernate-mapping>

调测类：

/*
 * 文件名：HibernateTest.java
 * 版权：Copyright by www.huawei.com
 * 描述：
 * 修改人：Cuigaochong
 * 修改时间：2015-10-22
 * 跟踪单号：
 * 修改单号：
 * 修改内容：
 */

package com.cgc.hibernate.n21both;

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;

/**
 * <一句话功能简述> <功能详细描述>
 * 
 * @author 姓名 工号
 * @version [版本号, 2015-10-22]
 * @see [相关类/方法]
 * @since [产品/模块版本]
 */
public class HibernateTest
{
    private SessionFactory sessionFactory;
    
    private Session session;
    
    private Transaction transaction;
    
    @Before
    public void init()
    {
        Configuration configuration = new Configuration().configure();
        // 创建一个ServiceRegisttry对象：hibernate 4.x,新添加的对象，hibernate的任何配置和服务器都需要
        // 在该配置中注册后才能生效
        ServiceRegistry serviceRegistry =
            new ServiceRegistryBuilder().applySettings(configuration.getProperties()).buildServiceRegistry();
        sessionFactory = configuration.buildSessionFactory(serviceRegistry);
        session = sessionFactory.openSession();
        // 开启事物
        transaction = session.beginTransaction();
    }
    
    @After
    public void detory()
    {
        transaction.commit();
        session.close();
        sessionFactory.close();
    }
    
    @Test
    public void testSave()
    {
        Customer customer = new Customer();
        customer.setCustomerName("Cui02GC");
        
        Order order00 = new Order();
        order00.setOrderName("order03GC");
        
        Order order01 = new Order();
        order01.setOrderName("order04GC");
        // 设定关联关系
        order00.setCustomer(customer);
        order01.setCustomer(customer);
        
        customer.getOrders().add(order00);
        customer.getOrders().add(order01);
        
        // 执行save 先插入Customer,在插入order,执行了三条inserts 2条update
        // 因为一的一端和n的一端，都维护关联关系，所以会多出update
        // 可以在一的一端的set节点，指定inverse="true"，来使一的一端放弃关联关系，建议先插入一的一端，这样就不会多出update语句
        // session.save(customer);
        // session.save(order00);
        // session.save(order01);
        
        // 先插入order,在插入customer 执行3条insert 4条update
        session.save(order00);
        session.save(order01);
        session.save(customer);
    }
    
    @Test
    public void testOng2ManyGet()
    {
        // 对于n的一端 的集合使用延时加载
        Customer c = (Customer)session.get(Customer.class, 101);
        System.out.println(c.getCustomerName());
        // 返回的多的一端的集合是Hibernate内置的集合类型，该集合有延迟加载和存放代理的功能
        System.out.println(c.getOrders().getClass());
        // session.close();
        // 可能会抛出懒加载异常
        
        System.out.println(c.getOrders().size());
        // 在需要使用元素中集合进行初始化，
        
    }
    
    @Test
    public void testMany2OneGet()
    {
        // 若查询多的一端的对象，则默认情况下，只查询多的一端的对象 而没有查询关联的一的一端的对象
        Order order = (Order)session.get(Order.class, 41);
        System.out.println(order);
        
        session.close();
        
        Customer customer = order.getCustomer();
        // 在需要使用关联对象的时候才会发送对应的sql
        System.out.println(customer);
        
        // 在查询customer对象时，由多的一端导航到1的一端时，可能会发生懒加载异常LazyInitializationException
        
        // 获取Order对象时，默认情况下，其关联的Customer对象是一个代理对象
        
    }
    
    @Test
    public void testUpdate00()
    {
        Customer customer = (Customer)session.get(Customer.class, 61);
        customer.getOrders().iterator().next().setOrderName("AK");
    }
    
    @Test
    public void testUpdate()
    {
        Order order = (Order)session.get(Order.class, 41);
        order.getCustomer().setCustomerName("QWE");
    }
    
    @Test
    public void testDelete()
    {
        // 在不设定级联关系的情况下，且1这一端的对象有n的对象在引用，不能直接删除1这一端的对象
        Customer c = (Customer)session.get(Customer.class, 61);
        session.delete(c);
    }
    
    @Test
    public void testCascade()
    {
        Customer customer = (Customer)session.get(Customer.class, 83);
        customer.getOrders().clear();
    }
    
}