Hibernate之1-N关联映射，hibernate1-n映射

Hibernate之1-N关联映射，hibernate1-n映射

             解：通过成员变量的方式即可.

2. 单向 n-1 关联关系

     1）. 域对象中，在 Order 中声明一个 Customer 类型的成员变量，并提供 setter、getter

     public class Order {

          private Integer orderId;
          private String orderName;
     
          private Customer customer;

          //...
     }

2）. 数据表：



3）. 如何进行映射：通过 many-to-one 来映射

     ①. 注意：需要映射在 ORDERS 数据表中的外键列！

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

4）. API 操作时
     ①. save 时，若先保存 Order， 在保存 Customer，则会多出 UPDATE 语句；若先保存 Customer，再保存 Order，则只有 INSERT. 建议先保存 1 的一端的对象

     ②. get 时，
          ◆默认情况下，关联对象采取 懒加载 策略。即在获取 Order 时，若不使用关联的 Customer 的属性，

获取一个对象，没有初始化其关联的属性，若在 Session 已经关闭的情况下，访问关联的属性，就会抛出懒 加载异常。

     ③. update 时，
          ◆若对象本身是一个持久化对象，则在 flush Session 时，会级联更新其关联的对象的属性。
          ◆若对象是游离对象，则不会更新关联对象的属性。但可以通过设置 cascade 属性来使其能够进行更新

     ④. delete 时，
          ◆删除对象，只需要 ID 属性
          ◆防止发生外键约束异常

3. 单向 1-n 关联关系

     1）. 域对象：增加集合属性

     public class Customer {

          private Integer customerId;
          private String customerName;

          //访问 n 的一端的集合属性
          private Set<Order> orders = new HashSet<>();
     
          //....
     }

     注意：
     ①. 当 Session 从数据库中加载 Java 集合时, 创建的是 Hibernate 内置集合类的实例,
          因此在持久化类中定义集合属性时必须把属性声明为 Java 接口类型
     ②. 在定义集合属性时, 通常把它初始化为集合实现类的一个实例. 
          避免应用程序访问取值为 null 的集合的方法抛出 NullPointerException


     2）.关系数据模型

     
     3）. 如何进行映射，在Customer.hbm.xml中通过 set 元素

     <set name="orders" table="ORDERS" 
          order-by="ORDER_NAME ASC">
          <key column="CUSTOMER_ID"></key>
          <one-to-many class="Order"/>
     </set>

     4）. API 具体操作：

          ①. save 时：因为由 1 的一端来维护关联关系，所以一定会多出 UPDATE 语句！

最好不是有 1 的一端来维护关联关系
          ②. update 时：
               ◆若把集合对象 clear，默认情况下是把多的一端的外键置空
          ③. delete 时：可以删除 1 的一端，但是把多的一端的外键置空

     5）. set 的 order-by 属性：可以指定在查询集合时，按集合元素对应的数据表的列进行排序！

     <set name="orders" table="ORDERS" 
          order-by="ORDER_NAME ASC">
          <key column="CUSTOMER_ID"></key>
          <one-to-many class="Order"/>
     </set>





----------------------------------------------------双向关联映射-----------------------------------------------------
4. 双向 1-n 关联关系

     1）. 如何进行映射（下面是Customer表，注意两者之间的对应关系）



     2）. set 元素的 inverse 属性可以指定由哪一方来维护关联关系，

User {
Set<Order> orders;
}

Order {
User user;
}

一般来说我们让Order来控制关系。即user的配置<set name="orders" inverse="true">
inverse="true"的意思是，请对方控制关系。也即（User不控制关系，Order控制关系）

即我们修改order.setUser(user)，则数据库会更新。
我们修改user.getOrders().add(order)，则数据库不会更新。

至于怎么体现双向，那就是我们从数据库取user的时候，我们可以直接user.getOrders()
里面将有我们已经添加的order。
 

Hibernate的关联关系映射大概有这么几种:

1、单向N-1

2、单向1-1

3、单向1-N

4、单向N-N

5、双向1-N

6、双向N-N

7、双向1-1

下面就对这七种关联关系映射进行一个简单的总结:

一、单向的多对一

看两个POJO

public class Person{

private int pid;

private String name;

private Address address;

...//生成相应的getter、setter方法

}

----------------------------------------

public class Address{

private int id;

private String detail;

...//生成相应的getter、setter方法

}

这里我们需要维护的关系是多个Person可以对应同一个地址,使用单向的N-1映射我们只需要在多的一端加入一个外键指向一的一端即可

**看配置文件

<class name="Person">

<id name="id">

<generator class="native"/>

</id>

...//部分字段配置省略

<many-to-one name="address" column="addressId"/>//关键配置

</class>

这样配置以后hibernate就会帮我们在多的一端（Person）添加一个外键addressId指向一的一端

二、单向的1-1(外键关联)

可以采用<many-to-one>标签，指定多的一端的unique=true，这样就限制了多的一端的多重性唯一

通过这种手段映射一对一唯一外键关联

配置文件只需要修改为:

<many-to-one name="address" column="addressId" unique="true"/>

三、单向的1-N

**看代码,我们知道一个班级有多名学生，这就是一个典型的1-N关系

public class Classes {
private int id;
private String name;
private Set students;

...//生成相应的getter、setter方法

}

---------------------------------------------------------------------------

public class Student {
private int id;
private String name;

..//生成相应是getter、setter方法

}

**映射原理:一对多关联映射，在多的一端添加一个外键指向一的一端,它维护的关系是一指向多

**配置文件:

<class name="Classes" table="t_classes">
<id......余下全文>>