`

Hibernate的关联关系映射

HibernateBeanXMLMySQLSQL 
阅读更多

一、一对一关联（有共享主键关联和惟一外键关联两种）

1、共享主键关联
 
比如课题是由教师去任教，没有教师就没有课题，这样课题就可以完全由教师来决定。
 
Java示例代码如下：

 

publicclass Course {
    private Long id; 
    private String name; 
    private Teacher teacher;
    // 省略setter和getter 方法
}
 
publicclass Teacher {
    private Long id; 
    private String name; 
    private Course course;
    // 省略setter和getter 方法
}


 配置文件

 

 

Teacher.hbm.xml
<!-- cascade="all" 表明对Teacher对象CRUD的操作会级联到Course对象 -->
<one-to-one name="course" class="powerwind.bean.Course"
    cascade="all" />
Course.hbm.xml
<!-- id值参照 teacher属性而生成-->
<id name="id" type="java.lang.Long" column="id">
    <generator class="foreign">
       <param name="property">teacher</param>
    </generator>
</id>
<!-- teacher属性参照 -->
<one-to-one name="teacher" class="powerwind.bean.Teacher"
           constrained="true" />

 

2、惟一外键关联

外键关联需要一个定义外键字段，比如在教师表定义一个课题的外键course_id。
 
配置文件

 

Teacher.hbm.xml
<many-to-one name="course" class="powerwind.bean.Course"
       column="course_id" cascade="save-update" unique="true"/>
如果同时在Coure.hbm.xml加上如下配置则为双向关联。
<one-to-one name="teacher" class="powerwind.bean.Teacher"
       property-ref="course" />

 

3、第三种

以上两种一对一关联在Hibernate中是比较常用的。但我用另外一种方法实现时，发现也可行。测试了一下，目前没有发现错误。

思想是和唯一外键关联相似，但两个表中都需要一个外键，在配置<one-to-one>的地方用了<many-to-one>，即两边对用了<many-to-one> 。

 

Course.hbm.xml
<many-to-one name="teacher" class="powerwind.bean.Teacher"
           column="teacher_id" unique="true" />
Teacher.hbm.xml
<many-to-one name="course" class="powerwind.bean.Course"
           column="course_id" unique="true" />


 细看起来，应该是一对多关联的配置，只是两边都设置“一”，欺骗了hibernate。在hibernate文档中有这样一句：基于外键关联的单向一对一关联和单向多对一关联几乎是一样的。唯一的不同就是单向一对一关联中的外键字段具有唯一性约束。

 

二、一对多、多对一关联

一对多（多对一）的关联是现在中用得比较多的。现实中，一个教师是可以任教多个课程的，这就是典型的一对多关系。（由于关联是有方向的，一对多和多对一的单向关联是不同的，而双向的时候就一样）单向关联：

假设我们只需要从课题知道该课题的任教教师是谁？而不需要从教师那里知道该都任教哪些课程。只在Course.hbm.xml中这样设置就可以。

 

<many-to-one name="teacher" class="powerwind.bean.Teacher"
           column="teacher_id" />

 

如果只需要从教师那里得知他的所有课程，可把原本多对多的关联变成一对多（需要连接表Teacher_ Course）。

 

Teacher.hbm.xml
<set name="courses" table="teacher_course" cascade="save-update">
      <key column="teacher_id"/>
      <many-to-many column="course_id"
            unique="true" class="powerwind.bean.Course"/>
</set>

 

unique="true"是它不同于多对多的地方。
 
双向关联：
双向关联就是在单向的基础上，再配置多一项（向）。
 
最常用最标准的配置是这种：

 

Course.hbm.xml
<many-to-one name="teacher" class="powerwind.bean.Teacher"
           column="teacher_id" />
Teacher.hbm.xml
<set name="courses" inverse="true">
       <key column="course_id" not-null="true" />
       <one-to-many class="powerwind.bean.Course" />
</set>

 

其中inverse="true" 的设置是比较常用的，设置后，当Teacher和Course对象状态均发生变化时，仅参照Course对象状态的变化来更新数据厍。

#p#

三、多对多关联

举个单向多对多关联的例子。比如远程教学，教师不知道他的学生有谁谁谁，只知道有很多学生在远程听课；而学生可以知道他的老师有哪些。这样，不就是单向多对多关联吗？实际上，单向的多对多关联是不完整的双向多对多关联。
 
如果单向，则只要在Student.hbm.xml配置。

 

<set name="teachers" inverse="true" table="student_teacher">
    <key column="student_id" />
    <many-to-many column="teacher_id" class="powerwind.bean.Teacher" />
</set>

 

如果双向，在上面的基础上，还要在Teacher.hbm.xml配置。

 

<set name="students" table="student_teacher">
    <key column="teacher_id" />
    <many-to-many column=" student_id" class="powerwind.bean.Student" />
</set>

 

有时候，连接表还会有其它信息的。比如学生与课程的关系表(stuent_course)，里面可以加入学生的考试成绩。这样的话，我们可以把这个连接表定义成这样：

 

student_coures( id,student_id, course_id, score );

 

这样，双向多对多关联就变成两个一对多的关联。这种情况下，多对多的双方并没有直接拥有对方的集合引用。这里把student_coures表对应的实体叫Score（一时想不出，叫成绩单算了）。

 

Student.hbm.xml
<set name="scores" inverse="true">
       <key column="student_id" />
       <one-to-many class="powerwind.bean.Score" />
</set>
Teacher.hbm.xml
<set name="scores" inverse="true">
       <key column="teacher_id" />
       <one-to-many class="powerwind.bean.Score" />
</set>
 
Score.hbm.xml
<many-to-one name="teacher" column="teacher_id" 
       class="powerwind.bean.Teacher" />
<many-to-one name="student" column="student_id" 
class="powerwind.bean.Student" />

 

 

 

举例：

Hibernate 多对多双向关联
 
一、模型介绍
 
多个人（Person ）对应多个地址（Address ）。
一个人可对应多个地址，一个地址也可以对应多个人。
 
二、实体（省略getter 、setter 方法）
 
public class Personnn_sx {
    private int personid;
    private String name;
    private int age;
    private Set addresses=new HashSet();
 
public class Addressnn_sx {
    private int addressid;
    private String addressdetail;
    private Set persons = new HashSet();
 
三、表模型
 
mysql> desc person_nn_sx;
+----------+--------------+------+-----+---------+----------------+
| Field    | Type         | Null | Key | Default | Extra          |
+----------+--------------+------+-----+---------+----------------+
| personid | int(11)      | NO   | PRI | NULL    | auto_increment |
| name     | varchar(255) | YES  |     | NULL    |                |
| age      | int(11)      | YES  |     | NULL    |                |
+----------+--------------+------+-----+---------+----------------+
 
mysql> desc address_nn_sx;
+---------------+--------------+------+-----+---------+----------------+
| Field         | Type         | Null | Key | Default | Extra          |
+---------------+--------------+------+-----+---------+----------------+
| addressid     | int(11)      | NO   | PRI | NULL    | auto_increment |
| addressdetail | varchar(255) | YES  |     | NULL    |                |
+---------------+--------------+------+-----+---------+----------------+
 
mysql> desc join_nn_sx;
+-----------+---------+------+-----+---------+-------+
| Field     | Type    | Null | Key | Default | Extra |
+-----------+---------+------+-----+---------+-------+
| addressid | int(11) | NO   | PRI |         |       |
| personid  | int(11) | NO   | PRI |         |       |
+-----------+---------+------+-----+---------+-------+
 
四、生成的SQL 脚本
 
/* Formatted on 2007/08/22 17:59 (QP5 v5.50) */
CREATE TABLE `address_nn_sx` (
  `addressid` int(11) NOT NULL auto_increment,
  `addressdetail` varchar(255) default NULL,
  PRIMARY KEY  (`addressid`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;
 
/* Formatted on 2007/08/22 17:59 (QP5 v5.50) */
CREATE TABLE `person_nn_sx` (
  `personid` int(11) NOT NULL auto_increment,
  `name` varchar(255) default NULL,
  `age` int(11) default NULL,
  PRIMARY KEY  (`personid`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;
 
/* Formatted on 2007/08/22 17:59 (QP5 v5.50) */
CREATE TABLE `join_nn_sx` (
  `addressid` int(11) NOT NULL,
  `personid` int(11) NOT NULL,
  PRIMARY KEY  (`personid`,`addressid`),
  KEY `FK6EBBC5EF6C600921` (`personid`),
  KEY `FK6EBBC5EF2A92FF3D` (`addressid`),
  CONSTRAINT `FK6EBBC5EF2A92FF3D` FOREIGN KEY (`addressid`) REFERENCES `address_nn_sx` (`addressid`),
  CONSTRAINT `FK6EBBC5EF6C600921` FOREIGN KEY (`personid`) REFERENCES `person_nn_sx` (`personid`)
) ENGINE=InnoDB DEFAULT CHARSET=gbk;
 
五、映射方法
 
<hibernate-mapping>
    <class name="com.lavasoft.sx._n_n.Personnn_sx" table="PERSON_nn_sx">
        <id name="personid">
            <generator class="identity"/>
        </id>
        <property name="name"/>
        <property name="age"/>
        <!-- 映射集合属性，关联到持久化类-->
         <!--table="join_1ntab_sx" 指定了连接表的名字-->
        <set name="addresses"
             table="join_nn_sx"
             cascade="all">
            <!--column="personid" 指定连接表中关联当前实体类的列名-->
            <key column="personid" not-null="true"/>
            <!--column="addressid" 是连接表中关联本实体的外键-->
            <many-to-many column="addressid"
                          class="com.lavasoft.sx._n_n.Addressnn_sx"/>
        </set>
    </class>
</hibernate-mapping>
 
<hibernate-mapping>
    <class name="com.lavasoft.sx._n_n.Addressnn_sx"
           table="ADDRESS_nn_sx">
        <id name="addressid">
            <generator class="identity"/>
        </id>
        <property name="addressdetail"/>
         <!--table="join_nn_sx" 是双向多对多的连接表-->
        <set name="persons"
             inverse="true"
             table="join_nn_sx">
            <!--column="addressid" 是连接表中关联本实体的外键-->
            <key column="addressid"/>
            <many-to-many column="personid"
                          class="com.lavasoft.sx._n_n.Personnn_sx"/>
        </set>
    </class>
</hibernate-mapping>
 
六、测试方法
 
public class Test_nn_sx {
    public static void main(String[] args){
        Addressnn_sx add1=new Addressnn_sx();
        Addressnn_sx add2=new Addressnn_sx();
        Personnn_sx p1=new Personnn_sx();
        Personnn_sx p2=new Personnn_sx();
 
        add1.setAddressdetail(" 郑州市经三路");
        add2.setAddressdetail(" 合肥市宿州路");
        p1.setName("wang");
        p1.setAge(30);
        p2.setName("zhang");
        p2.setAge(22);
 
        p1.getAddresses().add(add1);
        p1.getAddresses().add(add2);
        p2.getAddresses().add(add2);
        add1.getPersons().add(p1);
        add2.getPersons().add(p1);
        add2.getPersons().add(p2);
 
 
        Session session= HibernateUtil.getCurrentSession();
        Transaction tx=session.beginTransaction();
        session.save(p1);
        session.save(p2);
//        session.saveOrUpdate(add1);
//        session.saveOrUpdate(add2);
        tx.commit();
        HibernateUtil.closeSession();
    }
}
 
七、测试结果
 
1) : 正常保存.
        session.save(p1);
        session.save(p2);
//        session.saveOrUpdate(add1);
//        session.saveOrUpdate(add2);
 
  Hibernate: insert into PERSON_nn_sx (name, age) values (?, ? )
  Hibernate: insert into ADDRESS_nn_sx (addressdetail) values (?)
  Hibernate: insert into ADDRESS_nn_sx (addressdetail) values (?)
  Hibernate: insert into PERSON_nn_sx (name, age) values (?, ? )
  Hibernate: insert into join_nn_sx (personid, addressid) values (?, ? )
  Hibernate: insert into join_nn_sx (personid, addressid) values (?, ? )
  Hibernate: insert into join_nn_sx (personid, addressid) values (?, ? )
分享到：
| oracle中使用on delete cascade和on delet ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    hibernate关联关系映射

    "hibernate关联关系映射"是Hibernate的核心概念之一，它定义了如何在Java对象和数据库表之间建立关系。以下是对这个主题的详细讲解： 一、一对一关系映射（One-to-One） 一对一关系是指一个实体对应另一个实体的...

    Hibernate 关联关系映射分类

    在深入探讨Hibernate关联关系映射分类之前，我们首先简要回顾一下Hibernate框架的基本概念。Hibernate是一种持久层框架，主要用于Java应用程序中的对象关系映射（ORM），它能够将面向对象的数据模型转换为数据库中的...

    Hibernate关联关系映射目录

    ### Hibernate关联关系映射 #### 一、单向关联 单向关联指的是对象之间的关联关系只在一个方向上存在，也就是说这种关联关系仅在一个类中表示出来，在另一个类中不体现这种关联。 ##### 1. 一对一外键单向关联 ...

    Hibernate关联关系映射.CHM

    Hibernate关联关系映射.CHM Hibernate文档相关

    Hibernate关联关系映射实例速查

    Hibernate关联关系映射实例速查，帮助初学者学习。

    Hibernate的关联关系映射图解

    Hibernate4中映射关系图解。

    hibernate关联关系映射PPT

    hibernate中的关联关系映射ppt!觉得有用的可以下！

    hibernate关联映射详解

    hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,包含4个说明文档，分别详细解说了hibernate关联映射的...

    hibernate的关联关系映射

    【hibernate的关联关系映射】在Java持久化框架Hibernate中，关联关系映射是核心功能之一，它允许对象间的复杂关系与数据库中的表结构相匹配。在选课系统这个例子中，主要涉及到的对象包括课题(Course)、教师(Teacher...

    Hibernate_关联关系映射配置详解

    Hibernate_关联关系映射配置详解，希望能帮助广大java爱好者

    hibernate实体关联关系映射

    ### Hibernate实体关联关系映射详解 #### 一、引言 Hibernate作为一种强大的对象关系映射（Object Relational Mapping，简称ORM）框架，在Java开发领域扮演着极其重要的角色。它不仅简化了持久化层的开发工作，...

    hibernate关联映射实例

    本文将深入探讨“hibernate关联映射实例”中的关键知识点，包括一对多、多对多和继承映射，这些都是Hibernate中至关重要的概念。 1. **一对多关联映射**： 在现实世界中，一个实体可能会与多个其他实体相关联，...

    Hibernate_关联关系映射配置

    本教程将详细讲解Hibernate中的关联关系映射配置，帮助你理解和掌握如何在Hibernate中设置不同类型的关联。 一、一对一（One-to-One）关联 在现实世界中，两个实体之间可能存在一对一的关系，例如一个人只有一个...

    Hibernate_实体关联关系映射--学习总结

    Hibernate的实体关联映射是其核心功能之一，它通过灵活的配置来适应不同场景下的数据持久化需求。通过对一对一、一对多、多对多等映射关系的熟练掌握和灵活运用，可以有效地处理复杂的实体关系，提高开发效率和应用...

    hibernate关联映射的作用和常用属性解释

    ### Hibernate关联映射的作用与常用属性详解 #### 关联映射概述 在对象关系映射（Object Relational Mapping，简称ORM）技术中，Hibernate作为Java领域内非常成熟且功能强大的框架之一，它允许开发者将Java类映射...

    Hibernate注解 关联关系映射注解.docx

    在Java的持久化框架Hibernate中，注解是用于简化对象关系映射（ORM）的一种方式。本篇文章将详细探讨在Hibernate中如何使用注解来处理各种关联关系，特别是`mappedBy`属性的用法。 首先，`@OneToMany`注解用于表示...

Magicbox
Global site tag (gtag.js) - Google Analytics