Hibernate学习之关联关系映射

红太狼 2022-08-07 16:51 303阅读 0赞

介绍

从单向关系映射开始，然后考虑双向关系映射，逐步讲解典型的案例。

在单向关联的例子中，将用 Student类和 Classes类。

在双向关联的例子中，将用 Person类和 Event类。

单向关联

多对一

单向 many-to-one 关联是最常见的单向关联关系。

Student.java

  1. package com.dfdc.hibernate.domain;
  3. import java.io.Serializable;
  5. public class Student implements Serializable{
  7.     private static final long serialVersionUID = 1L;
  9.     private Long sid;
  10.     private String sname;
  11.     //维护多对一
  12.     private Classes clazz;
  14.     public Classes getClazz() {
  15.         return clazz;
  16.     }
  17.     public void setClazz(Classes clazz) {
  18.         this.clazz = clazz;
  19.     }
  21.     public Long getSid() {
  22.         return sid;
  23.     }
  24.     public void setSid(Long sid) {
  25.         this.sid = sid;
  26.     }
  27.     public String getSname() {
  28.         return sname;
  29.     }
  30.     public void setSname(String sname) {
  31.         this.sname = sname;
  32.     }
  34. }

Classes.java

  1. import java.io.Serializable;
  2. import java.util.Set;
  4. public class Classes implements Serializable{
  6.     private static final long serialVersionUID = 1L;
  8.     private Long cid;
  9.     private String cname;       
  11.     public Long getCid() {
  12.         return cid;
  13.     }
  15.     public void setCid(Long cid) {
  16.         this.cid = cid;
  17.     }
  19.     public String getCname() {
  20.         return cname;
  21.     }
  23.     public void setCname(String cname) {
  24.         this.cname = cname;
  25.     }   
  27. }

Student.hbm.xml内容

  1. <?xml version="1.0"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
  3. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
  5. <hibernate-mapping>
  6.     <class name="com.dfdc.hibernate.domain.Student" table="STUDENT">
  7.         <id name="sid" type="java.lang.Long">
  8.             <column name="SID" />
  9.             <generator class="native" />
  10.         </id>
  11.         <property name="sname" type="java.lang.String">
  12.             <column name="SNAME" />
  13.         </property>
  15.         <!-- 多对一，无关联表 -->        
  16.         <many-to-one name="clazz" column="CID" not-null="true"/>
  17.     </class>
  18. </hibernate-mapping>

以下为了代码简洁将省略DTD部分。

Classes.hbm.xml内容

  1. <hibernate-mapping>
  2. <class name="com.dfdc.hibernate.domain.Classes" table="CLASSES">
  3.     <id name="cid" type="java.lang.Long">
  4.         <column name="CID" />
  5.         <generator class="native" />
  6.     </id>
  7.     <property name="cname" type="java.lang.String">
  8.         <column name="CNAME" />
  9.     </property>               
  10. </class>
  11. </hibernate-mapping>

一对一

基于外键关联

基于外键关联的单向一对一关联和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯一性约束。

在上面Student.hbm.xml内容的节点增加unique=”true”

基于主键关联

基于主键关联的单向一对一关联通常使用一个特定的 id 生成器。

注释掉student类的clazz属性，并在classes类中增加Student类型的stu属性，即Classes类持有Student的引用。

Student.hbm.xml内容

  1. <id name="sid" type="java.lang.Long">
  2.     <column name="SID" />
  3.     <generator class="native" />
  4. </id>
  5. <property name="sname" type="java.lang.String">
  6.     <column name="SNAME" />
  7. </property>

**Classes.hbm.xml内容**class节点内容改成如下：

  1. <!--  基于主键的单向一对一 -->
  2. <id name="cid" type="java.lang.Long">
  3.     <column name="SID" />
  4.     <generator class="foreign">
  5.         <!-- property只关联对象 --> 
  6.         <param name="property">stu</param>
  7.     </generator>
  8. </id>
  9. <property name="cname" type="java.lang.String">
  10.     <column name="CNAME" />
  11. </property>
  12.    <!-- constrained,通过一个外键引用对主键进行约束。-->
  13. <one-to-one name="stu" constrained="true"/>

一对多

基于外键关联

基于外键关联的单向一对多关联是一种很少见的情况，我们不推荐使用它。

我们认为对于这种关联关系最好使用连接表（关联表）。

基于连接表的单向关联

一对多（one-to-many）

基于连接表的单向一对多关联应该优先被采用。

注意，通过指定unique=”true”，我们可以把多样性从多对多改变为一对多。

student映射文件内容：

  1. <id name="sid" type="java.lang.Long">
  2. <column name="SID" />
  3. <generator class="native" />
  4. </id>
  5. <property name="sname" type="java.lang.String">
  6. <column name="SNAME" />
  7. </property>

classes映射文件内容：

  1. <id name="cid" type="java.lang.Long">
  2. <column name="CID" />
  3. <generator class="native"/> 
  4. </id>
  5. <property name="cname" type="java.lang.String">
  6. <column name="CNAME" />
  7. </property>
  8. <!-- 基于连接表的多对多
  9.     指定unique="true"转换为两个一对多 -->
  10. <set name="students" table="CLASSES_STUDENT">
  11.     <key column="CID"></key>
  12.     <many-to-many column="SID" unique="true" class="com.dfdc.hibernate.domain.Student"></many-to-many>
  13. </set>

注释掉student类的clazz属性，并在classes类中设置Set集合，属性为students。

多对一（many-to-one）

基于连接表的单向多对一关联在关联关系可选的情况下应用也很普遍。

student映射文件内容：

  1. <id name="sid" type="java.lang.Long">
  2.     <column name="SID" />
  3.     <generator class="native" />
  4. </id>
  5. <property name="sname" type="java.lang.String">
  6.     <column name="SNAME" />
  7. </property>
  9. <!-- 基于连接表的单向多对一
  10.     table：被连接表的名称。
  11.     optional（可选 — 默认是 false）：如果为true，Hibernate 
  12.         只会在此连接定义的属性非空时插入一行数据，并且总是使用一个外连接来得到这些属性。        
  13.  -->
  14. <join table="CLASSES_STUDENT" optional="true" >
  15.     <key column="SID" unique="true"/>
  16.     <many-to-one name="clazz" column="CID" not-null="true" unique="true"/>
  17. </join>

classes映射文件内容：

  1. <id name="cid" type="java.lang.Long">
  2.     <column name="CID" />
  3.     <generator class="native"/> 
  4. </id>
  5. <property name="cname" type="java.lang.String">
  6.     <column name="CNAME" />
  7. </property>

以上的student类和classes类不变。

一对一（One-to-one）

基于连接表的单向一对一关联也是可行的，但非常少见，就不举例了。

多对多（many-to-many）

最后，这里是一个单向多对多关联的例子。

student映射文件内容：

  1. <id name="sid" type="java.lang.Long">
  2.     <column name="SID" />
  3.     <generator class="native" />
  4. </id>
  5. <property name="sname" type="java.lang.String">
  6.     <column name="SNAME" />
  7. </property>
  8.  <!-- 基于连接表的单向多对多 -->
  9. <set name="clazzSet" table="CLASSES_STUDENT">
  10.     <key column="SID"/>
  11.     <many-to-many column="CID" class="com.dfdc.hibernate.domain.Classes"/>
  12. </set>

classes映射文件内容：

  1. <id name="cid" type="java.lang.Long">
  2.     <column name="CID" />
  3.     <generator class="native"/> 
  4. </id> 
  5. <property name="cname" type="java.lang.String">
  6.     <column name="CNAME" />
  7. </property>

把上面的student类的clazz属性类型改成Set即可。

双向关联

从双向关系映射开始，逐步讲解典型的案例。

在双向关联的例子中，将用 Event 和 Person。

Event.java

  1. import java.util.Date;
  2. import java.util.HashSet;
  3. import java.util.Set;
  5. public class Event {
  7.     private Long id;
  9.     private Date date;
  11.     private Set<Person> personSet = new HashSet<Person>();
  13.     public Set<Person> getPersonSet() {
  14.         return personSet;
  15.     }
  17.     public void setPersonSet(Set<Person> personSet) {
  18.         this.personSet = personSet;
  19.     }
  21.     public Event() {}
  23.         public Long getId() {
  24.         return id;
  25.     }
  27.     //只有hibernate能操作标识符
  28.     private void setId(Long id) {
  29.         this.id = id;
  30.     }
  32.     public Date getDate() {
  33.         return date;
  34.     }
  36.     public void setDate(Date date) {
  37.         this.date = date;
  38.     }
  40. }

Person.java

  1. import java.util.HashSet;
  2. import java.util.Set;
  4. public class Person {
  5.     private Long id;
  6.     private int age;
  8.     public Person() {}                         
  10.     public Long getId() {
  11.         return id;
  12.     }
  14.     private void setId(Long id) {
  15.         this.id = id;
  16.     }
  18.     public int getAge() {
  19.         return age;
  20.     }
  22.     public void setAge(int age) {
  23.         this.age = age;
  24.     } 
  26. }

一对多（one to many)/多对一（many to one）

双向多对一关联，是最常见的关联关系。

person映射文件内容：

  1. <id name="id">
  2.     <column name="PERSON_ID"/>
  3.     <generator class="native"></generator>
  4. </id>
  6. <property name="age"/>
  7. <!-- 双向多对一/一对多 -->
  9. <many-to-one name="events" column="EVENT_ID" class="com.dfdc.hibernate.domain.Event" not-null="true"/>

event映射文件内容：

  1. <id name="id">
  2.     <column name="EVENT_ID" />
  3.     <generator class="increment" />
  4. </id> 
  5. <property name="date" type="timestamp">
  6.     <column name="DATE" />
  7. </property>
  8. <!-- 双向一对多/多对一 -->
  9. <set name="persons" inverse="true">
  10.     <key column="EVENT_ID"/>
  11.     <one-to-many class="com.dfdc.hibernate.domain.Person"/>
  12. </set>

在上面的person类添加Event类型的events属性。

一对一（One-to-one）

基于外键关联

基于外键关联的双向一对一关联也很常见。

person映射文件内容：

  1. <id name="id">
  2.     <column name="PERSON_ID"/>
  3.     <generator class="native"></generator>
  4. </id>
  6. <property name="age"/>
  7. <!-- 基于外键关联双向一对一
  8.     unique，作为 property-ref 引用的目标。这使关联同时具有一对一的效果。
  9.  -->
  10. <many-to-one name="events" column="EVENT_ID" unique="true" not-null="true"/>

event映射文件内容：

  1. <id name="id">
  2.     <column name="EVENT_ID" />
  3.     <generator class="native" />
  4. </id> 
  5. <property name="date" type="timestamp">
  6.     <column name="DATE" />
  7. </property>
  8.  <!-- 基于外键关联双向一对一
  9.     property-ref，被关联到此外键的类中的对应属性的名字。如果没有指定，被关联类的主键将被使用。
  10.  -->
  11.  <one-to-one name="persons" property-ref="events"/>

注释掉Event类的set类型的属性，并添加Person类型的属性persons。

在Person类添加Event类型的属性events。

基于主键关联

person映射文件内容：

  1. <!-- 1.基于主键关联双向一对一 -->
  2.     <id name="id">
  3.         <column name="EVENT_ID"/>
  4.         <!--
  5.         foreign,获取相关联的对象的标识符。它通常和 <one-to-one> 联合起来使用。
  6.         -->
  7.         <generator class="foreign">
  8.             <!--property，相关联的对象 -->
  9.             <param name="property">events</param>
  10.         </generator>
  11.     </id>
  13.     <property name="age"/>
  14.     <!--constrained="true",开启当前类与关联类之间的外键约束
  15.             将影响级联操作顺序。
  16.      -->
  17.     <one-to-one name="events" class="com.dfdc.hibernate.domain.Event" constrained="true"/>

event映射文件内容：

  1. <id name="id">
  2.     <column name="EVENT_ID" />
  3.     <generator class="native" />
  4. </id> 
  5. <property name="date" type="timestamp">
  6.     <column name="DATE" />
  7. </property>
  8. <!-- 1.基于主键关联双向一对一 -->
  9. <one-to-one name="persons" class="com.dfdc.hibernate.domain.Person"/>

在上面的person类添加Event类型的events属性。

在上面的event类添加Person类型的persons属性，并注释Set类型的persons属性。

主键关联不需要额外的表字段,两个对象通过主键一对一关联，必须确认它们被赋予同样的标识值。

基于连接表的双向关联

一对多（one to many)/多对一（many to one）

下面是一个基于连接表的双向一对多关联的例子。

person映射文件内容：

  1. <id name="id">
  2.         <column name="PENSON_ID"/>
  3.         <generator class="native"></generator>
  4.     </id>
  6.     <property name="age"/>
  7.     <!-- 4. 基于连接表关联双向多对一/一对多 -->
  8.     <set name="eventSet" table="PERSONEVENT">
  9.         <key column="PERSON_ID"/>
  10.         <many-to-many column="EVENT_ID" unique="true" class="com.dfdc.hibernate.domain.Event"/>
  11.     </set>

event映射文件内容：

  1. <id name="id">
  2.     <column name="EVENT_ID" />
  3.     <generator class="native" />
  4. </id> 
  5. <property name="date" type="timestamp">
  6.     <column name="DATE" />
  7. </property>
  8. <!-- 4. 基于连接表关联双向多对一/一对多 -->
  9. <join table="PERSONEVENT" inverse="true" optional="true">
  10.     <key column="EVETN_ID"/>
  11.     <many-to-one name="persons" column="PERSON_ID" not-null="true"/>
  12. </join>

在上面的Person类（代表一）中定义Set类型的eventSet属性。

在event类（代表多）中注释掉Set类型的persons属性，并添加Person类型的persons属性，即持有Person类的引用。

一对一（one to one）

基于连接表的双向一对一关联也是可行的，但极为罕见。这里就不阐述了。

多对多（many-to-many）

下面是一个双向多对多关联的例子

person映射文件内容：

  1. <id name="id">
  2.     <column name="PENSON_ID"/>
  3.     <generator class="native"></generator>
  4. </id>
  6. <property name="age"/>
  7. <set name="eventSet" table="person_event">
  8.     <key column="PERSON_ID"></key>
  9.     <many-to-many class="com.dfdc.hibernate.domain.Event" column="EVENT_ID"></many-to-many>
  10. </set>

event映射文件内容：

  1. <id name="id">
  2.     <column name="EVENT_ID" />
  3.     <generator class="native" />
  4. </id> 
  5. <property name="date" type="timestamp">
  6.     <column name="DATE" />
  7. </property>
  8. <set name="personSet" table="person_event" inverse="true">
  9.     <key column="EVENT_ID"/>
  10.     <many-to-many column="PERSON_ID" class="com.dfdc.hibernate.domain.Person"/>
  11. </set>

在上面的Person类中定义Set类型的eventSet属性。

以上。。。

发表评论

表情：
评论列表 （有 0 条评论，303人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Hibernate 03-配置关联关系映射

    一、了解关联关系 类与类之间最普遍的关系就是关联关系，并且关联是有方向的。以部门（Dept）和员工（Emp）类为例，一个部门下有多个员工，而一个员工只能属于一个部门

    朱雀朱雀/ 0 赞/ 332 阅读