Hibernate 学习之路（六）：双向一对多映射

hibernate如何处理双向的一对多映射呢？

• 双向 1-n 与 双向 n-1 是完全相同的两种情形
• 双向 1-n 需要在 1 的一端可以访问 n 的一端, 反之依然.

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

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

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

  1. Hibernate 的内置集合类具有集合代理功能, 支持延迟检索策略
  2. 事实上, Hibernate 的内置集合类封装了 JDK 中的集合类, 这使得 Hibernate 能够对缓存中的集合对象进行脏检查, 按照集合对象的状态来同步更新数据库。
• 在定义集合属性时, 通常把它初始化为集合实现类的一个实例. 这样可以提高程序的健壮性, 避免应用程序访问取值为 null 的集合的方法抛出 NullPointerException

set中的三个属性（在一的映射文件中配置）

1. cascade：级联

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

2. inverse：控制反转

   • 在hibernate中通过对 inverse 属性的来决定是由双向关联的哪一方来维护表和表之间的关系. inverse = false 的为主动方，inverse = true 的为被动方, 由主动方负责维护关联关系
     在没有设置 inverse=true 的情况下，父子两边都维护父子
     关系
     在 1-n 关系中，将 n 方设为主控方将有助于性能改善(如果要国家元首记住全国人民的名字，不是太可能，但要让全国人民知道国家元首，就容易的多)

3. order-by：排序

   • 元素有一个 order-by 属性, 如果设置了该属性, 当 Hibernate 通过 select 语句到数据库中检索集合对象时, 利用 order by 子句进行排序
   • order-by 属性中还可以加入 SQL 函数

代码演示

Customer.java

public class Customer {

    private Integer id;
    private String name;

    //1. 声明集合类型的时候，需要使用接口类型（Set），因为hibernate在获取
    //n的一方数据时，返回的是hibernate内置的集合类型，而不是javase的一个
    //标准实现
    //2. 需要把集合进行初始化，否则保存数据的时候会报空指针异常
    private Set<Order> orders = new HashSet<>();

    ...
}

Order.java

public class Order {

    private Integer id;
    private String name;
    private Customer customer;

    ...
}

Customer.hbm.xml

<hibernate-mapping package="com.zc.cris.n21.both">

    <class name="Customer" table="CUSTOMERS">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>

        <!-- 映射一对多的一中的对应多的那个set 集合属性，table 表示set 中的元素对应的那张表格名字
                inverse:一般都是在一的一方设置为true，即失去维护关系
                cascade:设置级联操作，如果为delete，那么删除一的时候也会删除多
                        如果取值为delete-orphan,即孤儿删除，删除多不删除一
                        如果取值为save-update，保存一的时候自动保存多
                        开发时不建议设置 cascade 值，一般都是手工逻辑判断
                        order-by 在查询时，对集合中的元素排序，取值为表的字段名，而不是持久化类的属性名
         -->
        <set name="orders" inverse="true" table="ORDERS" cascade="save-update" order-by="ID desc">
            <!-- 执行多的那张表中的外键列的列名 -->
                <key column="CUSTOMER_ID"></key>
                <!-- 指定映射的 class 类型 -->
                <one-to-many class="Order"/>
        </set>
    </class>
</hibernate-mapping>

Order.hbm.xml

<hibernate-mapping package="com.zc.cris.n21.both">
    <class name="Order" table="ORDERS">
        <id name="id" type="java.lang.Integer">
            <column name="ID" />
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>

        <many-to-one name="customer" column="CUSTOMER_ID" class="Customer" />
    </class>
</hibernate-mapping>

TestHibernate2.java

@Test
    void testCascadeDelete() {
        Customer customer = this.session.get(Customer.class, 1);
        //孤儿删除，只会删除多，不会删除一
        customer.getOrders().clear();
    }

    @Test
    void testMany21DeleteBoth() {
        Customer customer = this.session.get(Customer.class, 2);

//      <!-- 特别注意hibernate 所使用的数据库方言需要进行如下设置 -->
//      <property name="dialect">org.hibernate.dialect.MySQL5InnoDBDialect</property>

//      <!-- hibernate 所使用的数据库方言如下，将不会创建外键，因为不能识别部分命令 -->
//      <property name="dialect">org.hibernate.dialect.MySQL5Dialect</property>

        //在不设置级联关系的时候，如果一还有多的引用，那么一就无法被删除
        this.session.delete(customer);

    }

    @Test
    void testMany21UpdateBoth() {
        Customer customer = this.session.get(Customer.class, 1);
        customer.getOrders().iterator().next().setName("jjj");
    }

    @Test
    void testMany21GetBoth() {

        //1. 查询一的时候对n的一端使用延迟加载
        Customer customer = this.session.get(Customer.class, 3);
        System.out.println(customer.getName());

        //查询一的时候，如果session已经关了就可能产生懒加载异常（后面如果还要查询多的具体数据就会发生）
        //this.session.close();

        //2.返回多的一端的时候，是使用Hibernate的内置集合类型
        //org.hibernate.collection.internal.PersistentSet
        //这是一个javase的Set接口的实现类，具有延迟加载和存放代理对象的功能
        //在需要使用集合中的元素的时候才会进行真正的初始化
        System.err.println(customer.getOrders().getClass().getName());
        System.out.println(customer.getOrders().size());
    }

    @Test
    void testMany21SaveBoth() {
        Customer customer = new Customer();
        customer.setName("james");

        Order order1 = new Order();
        order1.setName("order1");
        Order order2 = new Order();
        order2.setName("order2");

        //设定双向关联关系
        order1.setCustomer(customer);
        order2.setCustomer(customer);
        customer.getOrders().add(order1);
        customer.getOrders().add(order2);

        //双向关系默认情况下双发都会维护关联关系，更新数据的时候会更新双方的情况
        //一般都是设置多的一方来维护关联关系（类似于老师和学生相互记名字的情况），这个时候就要在一的
        //映射文件里的set节点配置控制反转 inverse="true"，即一的一方失去控制关系，由多的一方维护双方关系
        //好处就是不会有额外的update语句执行
        //需要先保存一，再保存多（效率更高，否则会多出update语句，因为先插入多会无法确定外键值）
        this.session.save(customer);
//      this.session.save(order1);
//      this.session.save(order2);
    }

点我获取源码