原文：http://www.cnblogs.com/huxi/archive/2009/12/15/1624988.html
以简单的两个类为例：
User(int id, String name)
Group(int id, String name)
没有关联关系时的关系模型：
t_user(id int pk, name varchar)
t_group(id int pk, name varchar)
一、多对一和一对多关联映射（多个用户有相同的组）
这几种关联映射后的关系模型是相同的：
t_user(id int pk, name varchar, gid int fk->t_group(id))
t_group(id int pk, name varchar)
1、多对一单向关联
实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id"><generator class="native"/></id>
<property name="name"/>
<!-- 使用<many-to-one>映射多对一关系。导出ddl时将自动生成一个外键 -->
<many-to-one name="group" column="gid"/>
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id"><generator class="native"/></id>
<property name="name"/>
</class>
</hibernate-mapping>
2、一对多单向关联（几乎不用）
实体模型：
bean.User(int id, String name)
bean.Group(int id, String name, Set users)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id"><generator class="native"/></id>
<property name="name"/>
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id"><generator class="native"/></id>
<property name="name"/>
<!-- 使用<set>映射集合 -->
<set name="users">
<!-- 使用<key>指定引用至自身的外键表（t_user）中的外键 -->
<key column="gid"/>
<!-- 使用<one-to-many>映射一对多关系 -->
<one-to-many class="bean.User"/>
</set>
</class>
</hibernate-mapping>
为Group加入集合也可以使用List（<list>），注意不能指定类型是具体的HashSet或ArrayList，只能是接口Set或List。
集合标签可以使用order-by属性指定排序：
<set name="users" order-by="id desc">
3、双向关联
实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name, Set users)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id"><generator class="native"/></id>
<property name="name"/>
<!-- 使用<many-to-one>映射多对一关系。导出ddl时将自动生成一个外键 -->
<many-to-one name="group" column="gid"/>
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id"><generator class="native"/></id>
<property name="name"/>
<!-- 使用<set>映射集合 -->
<set name="users">
<!-- 使用<key>指定引用至自身的外键表（t_user）中的外键 -->
<key column="gid"/>
<!-- 使用<one-to-many>映射一对多关系 -->
<one-to-many class="bean.User"/>
</set>
</class>
</hibernate-mapping>
双向关联中，为<set>加入”inverse=true”可以反转维护关系：Hibernate将放弃从一的一端维护。意思就是user和group的关系必须使用user维护，操作group时Hibernate将不维护这个关系。<set name="users" inverse="true">操作group的示例：
session.beginTransaction();
User user = new User();
user.setName("张三");
Group group = new Group();
group.setName("admin");
group.setUsers(new HashSet());
group.getUsers().add(user);
session.save(user);
session.save(group);
session.getTransaction().commit();
没有配置inverse=”true”时，Hibernate输出了添加user和group，并更新user的语句：Hibernate: insert into t_user (name, gid) values (?, ?) Hibernate: insert into t_group (name) values (?) Hibernate: update t_user set gid=? where id=?
Hibernate: insert into t_user (name, gid) values (?, ?) Hibernate: insert into t_group (name) values (?)
session.beginTransaction();
Group group = new Group();
group.setName("admin");
User user = new User();
user.setName("张三");
user.setGroup(group);
session.save(group);
session.save(user);
session.getTransaction().commit();
因为外键列在t_user表中，从group端维护需要操作多表，所以从user端维护关系更加合理，效率也更高。上面的代码输出两条SQL语句，插入数据的同时也维护了关系：Hibernate: insert into t_group (name) values (?) Hibernate: insert into t_user (name, gid) values (?, ?)
依照映射方法不同，可分为主键关联映射和唯一外键关联映射。主键关联是维护两张表的主键一致，如有必要还可以在主键上再加上外键约束；唯一外键关联则类似于多对一关联，为表加入一个外键列，不过一对一关联会同时将这个外键加上唯一约束。
1、主键关联映射
主键关联生成的关系模型：
t_user(id int pk fk->t_group(id), name varchar)
t_group(id int pk, name varchar)
1.1、主键单向关联
实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id">
<!-- 指定主键生成策略为外键 -->
<generator class="foreign">
<!-- 指定要参照的属性 -->
<param name="property">group</param>
</generator>
</id>
<property name="name"/>
<!-- 使用<one-to-one>映射一对一关系。 -->
<one-to-one name="group">
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id"><generator class="native"/></id>
<property name="name"/>
</class>
</hibernate-mapping>
主键关联由Hibernate维护，不依赖数据库。如果需要在数据库端也生成外键约束，可以使用constrained：
<one-to-one name="group" constrained="true"/>
1.2、主键双向关联
实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name, User user)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id">
<!-- 指定主键生成策略为外键 -->
<generator class="foreign">
<!-- 指定要参照的属性 -->
<param name="property">group</param>
</generator>
</id>
<property name="name"/>
<!-- 使用<one-to-one>映射一对一关系。 -->
<one-to-one name="group">
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id"><generator class="native"/></id>
<property name="name"/>
<!-- 使用<one-to-one>映射一对一关系 -->
<one-to-one name="user"/>
</class>
</hibernate-mapping>
2、唯一外键关联映射
唯一外键关联生成的关系模型：
t_user(id int pk, name varchar, gid int fk->t_group(id))
t_group(id int pk, name varchar)
2.1、唯一外键单向关联
实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<!-- 为<many-to-one>加上unique就变成了一对一 -->
<many-to-one name="group" unique="true" column="gid"/>
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id"><generator class="native"/></id>
<property name="name"/>
</class>
</hibernate-mapping>
2.2、唯一外键双向关联
实体模型：
bean.User(int id, String name, Group group)
bean.Group(int id, String name, User user)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<!-- 为<many-to-one>加上unique就变成了一对一 -->
<many-to-one name="group" unique="true" column="gid"/>
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id"><generator class="native"/></id>
<property name="name"/>
<!-- 使用<one-to-one>映射一对一 -->
<one-to-one name="user"/>
</class>
</hibernate-mapping>
三、多对多关联映射（每个用户拥有多个组，每个组也有多个用户）
多对多关联映射关系使用中间表表示。导出关系模型时Hibernate将自动生成复合主键以及外键约束。
关系模型：
t_user(id int pk, name varchar)
t_group(id int pk, name varchar)
t_user_group(userid int fk->t_user(id), groupid int fk->t_group(id), pk(userid, groupid))
1、多对多单向关联
实体模型：
bean.User(int id, String name, Set groups)
bean.Group(int id, String name)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<!-- 使用<set>映射集合，在多对多关系中，Hibernate将生成第三张表 -->
<set name="groups" table="t_user_group">
<!-- 使用<key>指定引用至自身的外键表（t_user_group）中的外键 -->
<key column="userid"/>
<!-- 使用<many-to-many>映射多对多关系，column指定另一端在表t_user_group中的列 -->
<many-to-many class="bean.Group" column="groupid"/>
</set>
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id"><generator class="native"/></id>
<property name="name"/>
</class>
</hibernate-mapping>
1、多对多单向关联
实体模型：
bean.User(int id, String name, Set groups)
bean.Group(int id, String name, Set users)
<!-- bean/User.hbm.xml -->
<hibernate-mapping>
<class name="bean.User" table="t_user">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<!-- 使用<set>映射集合，在多对多关系中，Hibernate将生成第三张表 -->
<set name="groups" table="t_user_group">
<!-- 使用<key>指定引用至自身的外键表（t_user_group）中的外键 -->
<key column="userid"/>
<!-- 使用<many-to-many>映射多对多关系，column指定另一端在表t_user_group中的列 -->
<many-to-many class="bean.Group" column="groupid"/>
</set>
</class>
</hibernate-mapping>
<!-- bean/Group.hbm.xml -->
<hibernate-mapping>
<class name="bean.Group" table="t_group">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<!-- 使用<set>映射集合，在多对多关系中，Hibernate将生成第三张表 -->
<set name="users" table="t_user_group">
<!-- 使用<key>指定引用至自身的外键表（t_user_group）中的外键 -->
<key column="group"/>
<!-- 使用<many-to-many>映射多对多关系，column指定另一端在表t_user_group中的列 -->
<many-to-many class="bean.User" column="userid"/>
</set>
</class>
</hibernate-mapping>
多对多的双向关联同样可以在不想要维护关系的一端的<set>里设置inverse=”true”；但是必须有一端可以维护，也就是说只可以设置一个。
相关推荐
hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,hibernate,包含4个说明文档，分别详细解说了hibernate关联映射的...
本文将深入探讨“hibernate关联映射实例”中的关键知识点，包括一对多、多对多和继承映射，这些都是Hibernate中至关重要的概念。 1. **一对多关联映射**： 在现实世界中，一个实体可能会与多个其他实体相关联，...
### Hibernate关联映射的作用与常用属性详解 #### 关联映射概述 在对象关系映射（Object Relational Mapping，简称ORM）技术中，Hibernate作为Java领域内非常成熟且功能强大的框架之一，它允许开发者将Java类映射...
本教程“Hibernate关联映射.rar”聚焦于Hibernate中的关联映射，特别是多对一和一对多的关系映射，非常适合初学者了解和实践。 首先，我们要理解什么是关联映射。在数据库中，表与表之间存在各种关系，如一对一、一...
总的来说，这个压缩包提供了丰富的Hibernate关联映射的学习资源，涵盖了从基础到进阶的各种关联类型。通过学习这些示例，你将能够熟练掌握如何在Java项目中使用Hibernate进行数据持久化，并灵活地处理各种数据库关系...
这可能是测试Hibernate关联映射的一个示例项目或者类。通常，这样的测试会包含各种关联映射的实例，如实体类的定义，配置文件或注解，以及测试用例，用于验证关联映射是否按预期工作。 **详细知识讲解：** 1. **一...
本文将深入探讨“Hibernate关联映射中的Many-to-One关系”。 Many-to-One关联是现实世界中常见的关系类型，比如一个学生可以对应多个课程，而一个课程可能被多个学生选修。在数据库中，这通常表现为一对多（One-to-...
hibernate关联映射是Hibernate框架中的一个重要概念，它用于在Java对象模型和数据库表之间建立关系，使得数据操作更加方便。以下将详细介绍各种类型的关联映射： 1. **单向N-1关联（无连接表）** 在这种关联中，一...
在Java的持久化框架Hibernate中，关联映射是至关重要的概念，它允许我们将数据库中的表关系映射到对象之间的关系。SSH（Struts、Spring、Hibernate）是经典的Java Web开发框架，其中Hibernate负责数据访问层，提供了...
本话题主要探讨的是Hibernate中的一种关联映射方式——一对一（One-to-One）单向外键关联。这种关联模式通常用于两个实体之间存在唯一对应的关系，例如一个用户对应一个唯一的账户。 在Hibernate中，一对一关联可以...
本篇文章将深入探讨Hibernate中的关联映射，特别是One-to-One（一对一）关联，这是一种表示两个实体之间一对一关系的映射方式。我们将通过源码分析和实际例子来理解其工作原理。 ### 一、One-to-One关联概述 在...
在Java的持久化框架Hibernate中，关联映射是核心特性之一，它允许我们将数据库中的表关系映射到对象之间的关系。本篇将深入探讨一种特殊的关联映射方式——一对一（One to One）映射，特别是在双向关联的情况下的...
在Java的持久化框架Hibernate中，一对一（One-to-One）关联映射是一种常见的关系数据库模型映射方式。这种关联通常发生在两个实体之间，且每个实体都只有一个对应的实例。本篇文章将详细探讨双向一对一主键关联映射...