下载文档原格式
Hibernate（6）——一对多和多对多关联关系映射（xml和注解）总结涉及的知识点总结如下：∙One to Many 映射关系o多对一单向外键关联(XML/Annotation)o一对多单向外键关联(XML/Annotation)o懒加载和积极加载o一对多双向外键关联(XML/Annotation)∙Many to Many 映射关系o多对多单向外键关联(XML/Annotation)o多对多双向外键关联(XML/Annotation)o set的inverse元素详解∙问题小结∙关联关系的优缺点多对一单向外键关联关系注意多对一关联是多方持有一方的引用。
看一个例子，去淘宝购物，那么一个淘宝用户可以对应多个购物订单，如图所示：多的一方是Orders，持有一方的引用，也就是Users，而在Users中无需作任何定义，从订单到用户的关系是单向多对一关联。
对应数据库就是：还有比如说学生和班级的关系，多个学生可以属于同一个班级，这就是从学生到班级也是典型的单向多对一关系，看代码实现：基于注解的多对一单向外键关联：单向多对一关联中，多方需要持有一方的引用，那么多方（学生类）需要额外配置，需要对持有的一方引用使用注解@ManyToOne (cascade={CascadeType.ALL}, fetch=FetchType.EAGER)，设置为级联操作和饥渴的抓取策略，@JoinColumn(name="cid")，而一方（教室类）无需做任何多方的定义。
注意；多方必须保留一个不带参数的构造器！importjavax.persistence.Entity;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;//班级类,在多对一关系中属于一的方，不持有其他多余的配置，反而是被多方持有@Entitypublic class ClassRoom {private intcid;//班级编号private String cname;//班级名称// 自动增长的主键@Id@GeneratedValuepublicintgetCid() {returncid;}public void setCid(intcid) {this.cid = cid;}public String getCname() {returncname;}public void setCname(String cname) {ame = cname;}}View Code一方——班级类无需做多余的定义，下面是多方——学生实体和配置：importjavax.persistence.CascadeType;importjavax.persistence.Entity;importjavax.persistence.FetchType;importjavax.persistence.GeneratedValue;importjavax.persistence.Id;importjavax.persistence.JoinColumn;importjavax.persistence.ManyToOne;//学生实体类，属于多对一的多方，持有班级（一方）的引用@Entitypublic class Students {private intsid; //编号private String sname; //姓名private ClassRoom classroom;//学生班级//注意：多方一定要显式的定义不带参数的构造方法public Students() {}public Students(String sname){this.sname = sname;}// 多方使用注解：@ManyToOne// fetch=FetchType.EAGER，急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载。
Hibernate（6）——一对多和多对多关联关系映射（xml和注解）总结涉及的知识点总结如下：∙One to Many 映射关系o多对一单向外键关联(XML/Annotation)o一对多单向外键关联(XML/Annotation)o懒加载和积极加载o一对多双向外键关联(XML/Annotation)∙Many to Many 映射关系o多对多单向外键关联(XML/Annotation)o多对多双向外键关联(XML/Annotation)o set的inverse元素详解∙问题小结∙关联关系的优缺点多对一单向外键关联关系注意多对一关联是多方持有一方的引用。
看一个例子，去淘宝购物，那么一个淘宝用户可以对应多个购物订单，如图所示：多的一方是Orders，持有一方的引用，也就是Users，而在Users中无需作任何定义，从订单到用户的关系是单向多对一关联。
对应数据库就是：还有比如说学生和班级的关系，多个学生可以属于同一个班级，这就是从学生到班级也是典型的单向多对一关系，看代码实现：基于注解的多对一单向外键关联：单向多对一关联中，多方需要持有一方的引用，那么多方（学生类）需要额外配置，需要对持有的一方引用使用注解@ManyToOne (cascade={CascadeType.ALL}, fetch=FetchType.EAGER)，设置为级联操作和饥渴的抓取策略，@JoinColumn(name="cid")，而一方（教室类）无需做任何多方的定义。
注意；多方必须保留一个不带参数的构造器！import ;import ;import ;//班级类,在多对一关系中属于一的方，不持有其他多余的配置，反而是被多方持有public class ClassRoom {private int cid;//班级编号private String cname;//班级名称// 自动增长的主键@Id@GeneratedValuepublic int getCid() {return cid;}public void setCid(int cid) {this.cid = cid;}public String getCname() {return cname;}public void setCname(String cname) {ame = cname;}}View Code一方——班级类无需做多余的定义，下面是多方——学生实体和配置：import ;import ;import ;import ;import ;import ;import ;//学生实体类，属于多对一的多方，持有班级（一方）的引用@Entitypublic class Students {private int sid; //编号private String sname; //姓名private ClassRoom classroom;//学生班级//注意：多方一定要显式的定义不带参数的构造方法public Students() {public Students(String sname){this.sname = sname;}// 多方使用注解：@ManyToOne// fetch=FetchType.EAGER，急加载，加载一个实体时，定义急加载的属性会立即从数据库中加载。
框架学习之Hibernate 第六节关系映射学习各种映射关系时总结：①如何将对象之间的关联关系映射到数据库中②如何检索出关联对象 1.多对一映射它是用法最多的映射关系，性能上占有优势关系模型和对象模型：两者并不是一一对应的举个例子：告知员工属于哪个部门和告知部门有哪些员工对于数据库（关系模型）来说只要有一个就可以但是对于对象模型不是如此，告知员工属于哪个部门之后，部门并不会知道自己有哪些员工 2.一对多映射它的关系模型和上面一样，也就是表的结构并不转变，但是对象模型转变了 3.一对一映射主对象和从对象主对象假如没有从对象可以，但是从对象没有主对象是不可的查找主对象时只用了一条sql语句，用法了outer 查找从对象时用了两条语句，首先查从对象，然后查主对象（假如要用法从对象对应的主对象）两种映射办法：①基于主键的一对一②基于外键的一对一 4.多对多映射用法的不是无数，要注重数据量的大小对性能的影响，由于多对多需要查三张表 5. 组件映射当一个类的属性很特别，不是数据库中支持的类型，而且又算不上是一个实体，没有表与之对应时可以用法组件映射假如组件的属性不能和表中的字段容易对应的时候可以挑选用法自定义用户类型！ 6.关系映射的总结①对于关联关系的查询，Hibernate普通都是用法两条sql语句将它查出来，但是一对一的状况里的查主对象例外，它是一条sql 7.集合映射xml – Java集合类型 - 特点 xml中需要配置的信息：- Set 没有重复，不保存加入的挨次array：- Class[] 有挨次的 list-indlist：- List 可以重复，有挨次的 list-indexbag：- List 不保存挨次的List list-indexmap：- Map map键值对的映射类型 map-key编写 xml 办法用法原则：多数状况下都是用法set，需要保证挨次用法list，但是想用List而又不需要保证挨次用法bag 注重点：①定义成 Set，而不是 HashSet②本来是 HashSet，保存了之后就不再是 HashSet 了，强制转型时会报错的！缘由是Hibernate举行的封装，变成了PersitentSet，实现了 Set 接口，但是和 HashSet 没有关系，不能第1页共2页。
hibernate关联映射详解一对多关系 1.一对多关系（单向）：在一端映射文件中加入：name= student keyumn= classes / one-to-many > /set 2.一对多关系（双向）：（1）.在一端映射文件中加入： setname= student keycolumn= classesid / one-to-many > /set （2）.在多的一端加入： many-to-onename= classes column=classesid /many-to-one 多对一关系在多的一端加入：many-to-one name= classes column= classesid / 一对一关系 1. 一对一外键关联单向：（它其实就是一个多对一映射的一个特例，只是设置ue=”ue”）在维护关系一端的映射文件中加入：many-to-onename= card unique= true cascade= all /many-to-one 双向：在维护关系一端的映射文件中加入： many-to-onename= card unique= true cascade= all /many-to-one 在另一段的映射文件中加入： one-to-onename= users property-ref= card /one-to-one 因为 one-to-one name 标签默认是找关联主键，所以在这里需要property-ref= card 配置关联属性。
Cascade属性是级联的意思。
2. 一对一主键关联 a) 单向在维持关系一端的代码： classname= er_pk idname= id generator > paramname= property card_pk /param /generator /id propertyname= name unique= true /property one-to-onename= card_pk constrain= true /one-to-one /class 设置generator > constrained= true 设置该实体的主键是card_p的外键。
数据库采用外键来描述数据表之间的关系（1）一对多：客户和订单的关系创建customers、orders数据表在多方添加一方的外键（在orders表添加customer_id）（2）一对一：公司和公司收信地址关系创建company和address 数据表在任意一方添加对方的主键作为外键（3）多对多：订单和商品的关系创建orders和products数据表必须创建第三张（即中间表）关系表，分别引入双方的主键作为外键Hibernate是采用Java对象关系来描述数据表实体之间的关系：多对一的映射关系：* name:设定待映射的持久化类的名字。
* column:设定和持久化类的属性对应的表的外键。
* class:设定持久化类的属性的类型。
* not-null:是否允许为空。
一对多映射关系：name ：设定Customer中集合类型属性名称<key column ：设置生成数据表中外键字段名称not null ：设置外键字段非空约束<one-to-many > ：设置一对多映射关系class ：设置映射关联目标PO类在对象–关系映射文件中, 用于映射持久化类之间关联关系的元素, <set>, <many-to-one> 和<one-to-one> 都有一个cascade （级联操作）属性, 它用于指定如何操纵与当前对象关联的其他对象.单向维护：(inverse)通过inverse属性来设置由双向关联的哪一方来维护表和表之间的关系.inverse=false 的为主动方，inverse=true 的为被动方, 由主动方负责维护关联关系在one一方设置inverse=true，由集合端管理关系。
多对多关系：多对多的实体关系模型也是很常见的，比如学生和课程的关系。
一个学生可以选修多门课程，一个课程可以被多名学生选修。
在关系型数据库中对于多对多关联关系的处理一般采用中间表的形式，将多对多的关系转化成两个一对多的关系。
Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结引言简要介绍Hibernate框架以及关联关系映射在数据库设计中的重要性。
Hibernate关联关系映射概述关联关系的重要性讨论在现实世界中对象间关系的重要性以及如何在数据库中表示这些关系。
Hibernate关联关系类型列举Hibernate支持的关联关系类型，包括一对一、一对多、多对一和多对多。
一对多关联关系映射概念解释解释一对多关联关系的概念，例如一个部门拥有多个员工。
XML映射方式详细描述如何在XML映射文件中配置一对多关联关系。
实体类定义展示一对多关系中实体类的Java代码示例。
XML映射文件提供一对多关系映射的XML配置示例。
注解映射方式详细描述如何使用注解配置一对多关联关系。
实体类定义展示使用注解的一对多关系中实体类的Java代码示例。
注解配置提供一对多关系映射的注解配置示例。
多对多关联关系映射概念解释解释多对多关联关系的概念，例如学生和课程之间的关联。
XML映射方式详细描述如何在XML映射文件中配置多对多关联关系。
实体类定义展示多对多关系中实体类的Java代码示例。
XML映射文件提供多对多关系映射的XML配置示例。
注解映射方式详细描述如何使用注解配置多对多关联关系。
实体类定义展示使用注解的多对多关系中实体类的Java代码示例。
注解配置提供多对多关系映射的注解配置示例。
关联关系映射的高级特性级联操作讨论级联保存、更新和删除的概念及其配置。
双向关系管理解释如何管理双向关联关系，确保数据的一致性。
延迟加载与即时加载讨论延迟加载和即时加载的概念及其在关联关系中的应用。
实践案例分析一对多关联关系案例通过一个具体的一对多关联关系案例，展示映射配置和数据操作。
多对多关联关系案例通过一个具体的多对多关联关系案例，展示映射配置和数据操作。
常见问题与解决方案一对多关联关系常见问题列举一对多关联关系映射中可能遇到的问题及其解决方案。
hibernate的manytoone和onetomany用例-回复Hibernate是一个Java的持久化框架，常用于开发数据访问层的代码。
它提供了一种简化数据库操作的方法，可以通过对象和关系数据库进行交互。
在Hibernate中，常用的关系映射包括many-to-one和one-to-many。
本文将通过详细讲解这两种关系映射的用例来帮助读者更好地理解和使用Hibernate。
首先，我们来了解一下many-to-one关系映射。
这种映射关系表示一个实体对象（通常是较"多"的一方）可以与另一个实体对象（通常是较"一"的一方）建立多对一的关系。
在关系数据库中，这种关系通过外键实现。
在Hibernate中，我们可以通过注解或XML配置来映射这种关系。
假设我们要建立一个简单的图书和作者的many-to-one关系映射。
一个作者可以写多本图书，而一本图书只能由一个作者所写。
我们先创建一个Author类和一个Book类。
Author类包含作者的姓名、年龄等属性，并与多个Book对象建立关联，通过"books"字段来表示与图书的关系。
Book 类包含图书的名字、出版日期等属性，并通过"author"字段与一个Author 对象建立关联，表示与作者的关系。
javapublic class Author {private Long id;private String name;private int age;private List<Book> books;省略getter和setter方法}public class Book {private Long id;private String name;private LocalDate publishDate;private Author author;省略getter和setter方法}在Author类中，我们可以使用OneToMany注解来建立与Book对象的关联，并通过设置cascade属性来实现级联操作。
1. Hibernate Annotation关系映射有下面几种类型：1)一对一外键关联映射（单向）2)一对一外键关联映射（双向）3)一对一主键关联映射（不重要，有需要看下文档即可）在实际中很少用，使用注解@PrimaryKeyJoinColumn意思是说，我的主键去参考另外一张表中的主键，作为我的主键，但是在我测试使用注解一对一主键关联映射，在生成表的时候，数据库中并没有生成关联，使用XML映射可以生成。
Annotation注解一对一主键关联映，有些bug。
不过没空去研究它。
因为在实际开发中一对一很少用。
在实际开发中我机会没有用过，主键关联就更少了4)多对一关联映射（单向）5)一对多关联映射（单向）6)一对多关联映射（双向）7)多对多关联映射（单向）8)多对多关联映射（双向）2.介绍各种映射用法1）一对一外键关联映射（单向）Husband ---> Wifepublic class Husband{private Wife wife;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="wife_id",unique=true)public Wife getWife(){…}…}public class Wife{}一对一外键关联，使用@OneToOne，并设置了级联操作@JoinColum设置了外键的名称为wife_id（数据库字段名），如果不设置，则默认为另一类的属性名+ _id外键的值是唯一的(unique)，不可重复，与另一类的主键一致2）一对一外键关联映射（双向）Husband <---> Wifepublic class Husband{private Wife wife;@OneToOne(cascade=CascadeType.ALL)@JoinColumn(name="wife_id",unique=true)public Wife getWife(){…}...}public class Wife{private Husband husband;@OneToOne(mappedBy="wife",cascade=CascadeType.ALL)public Husband getHusband(){…}...}一对一双向关联关系，使用@OneToOne注意：需要加上mappedBy="wife"，如果不加上的话，Wife也会生成一个外键（husband_id）。
Hibernate框架Hibernate接口Configuration接口用于Hibernate的配置，读取配置文件创建SessionFactory。
SessionFactory接口用于产生Session对象，一个SessionFactory代表一个数据库Session接口提供对数据持久对象的操作的方法，可以看成一个缓冲区，hibernate可以自动检测缓冲区的持久对象是否已经改变，并及时刷新数据库，以保证Session中的对象和数据一致。
Transaction接口在hibernate轻量级框架中，不依赖于容器而是自己的API来调用底层事务API如JDBCAPI 、JTA做到事务处理的目的。
Query和Criteria接口Query接口提供对数据库及持久对象进行查询的方法，Criteria接口提供面向对象的标准化查询Hibernate对象-关系映射主要讲一下关联关系映射一对一（主键关联）两个实体域对象一个是客户类Customer 一个是客户身份正信息类IdCard关系一对一的下例讲解一对一主键关联类图结构数据库表的结构从类图可以看出 一对一主键关联的 Customer 类中有IdCard 的一个对象属性 IdCard 类中有Customer 的一个对象属性、 这就是你中有我我中有你数据库中都有一个C_ID 的字段映射配置文件<?xml version ="1.0" encoding ="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" > <hibernate-mapping > <class name ="类路径" table ="对应的表名"> <id name ="c_id" type ="ng.Integer"> <column name ="C_ID"/><generator class ="assigned"/></id ><property name ="name" type ="ng.String" column ="NAME"/> <one-to-one name ="对方包含在本方中的属性名称idCard" class ="类路径"cascade ="all"/></class ></hibernate-mapping >上面是Customer 类的映射文件 其中要包含一个one to one 的节点IdCard类的映射文件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" ><hibernate-mapping><class name="类路径" table="对应的表名"><id name="c_id" type="ng.Integer"><column name="C_ID"/><generator class="foreign"><param name="property">本类中的对方类名称customer</param> </generator></id><property name="carNo" type="ng.String"column="CARDNO"/><one-to-one name="对方包含在本方中的属性名称customer" class="类路径"constrained="true"/></class></hibernate-mapping>配置文件就完了由于是一对一的主键关联IdCard类的主键需要通过Customer类的主键来生成，所以在IdCard的映射文件中是试用foreign生成其中param 指定IdCard类中所引用的属性这里说的是Customer业务类调用的代码片段Customer cs = new Customer();cs.setC_id(1);cs.setName(“lifei”);IdCard idCard = new IdCard();idCard.setCarNo(“510125……”);cs.setIdCard(idCard);idCard.setCustomer(cs);ts = session.beginTransaction();session.save(cs);mit();执行过后到数据库中就可以看出我们并没有保存IdCard 但是同样在数据库中可以找到IdCard 的记录 这就是一对一主键关联的配置放发一对一唯一外键关联类图跟一对一主键关联没有区别数据库表Customer映射文件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" ><hibernate-mapping><class name="类路径" table="对应的表名"><id name="c_id" type="ng.Integer"><column name="C_ID"/><generator class="assigned"/></id><property name="name" type="ng.String" column="NAME"/><many-to-one name="对方包含在本方中的属性名称idCard" class="类路径"cascade="all"/></class></hibernate-mapping>注意这里是many-to-one了IdCard映射文件<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" ><hibernate-mapping><class name="类路径" table="对应的表名"><id name="id" type="ng.Integer"><column name="ID"/><generator class="foreign"/></id><property name="carNo" type="ng.String"column="CARDNO"/><one-to-one name="对方包含在本方中的属性名称customer" class="类路径"Property-ref=”idCard”/></class></hibernate-mapping>在one-to-one时要指明Customer类中的idCard属性，表明需要通过外加加载业务类调用的代码片段Customer cs = new Customer();cs.setC_id(1);cs.setName(“lifei”);IdCard idCard = new IdCard();IdCard.setId(1);idCard.setCarNo(“510125……”);cs.setIdCard(idCard);idCard.setCustomer(cs);ts = session.beginTransaction();session.save(cs);mit();比起主键关联就多了行代码为IdCard设置ID 生成的SQL语句会有三句多对一关联实体 客户 和 订单 的关系 类图表结构图在customer 的配置文件中就配置id 和单个属性的映射就可以了不存在什么many-to-one 或者其他表示关系的节点在多方order中<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd" ><hibernate-mapping><class name="类路径" table="对应的表名"><id name="id" type="ng.Integer"><column name="ID"/><generator class="foreign"/></id><property name="orderNo" type="ng.String"column="CARDNO"/><many-to-one name="对方包含在本方中的属性名称customer" class="类路"column="C_ID"/></class></hibernate-mapping>在多方中配置many-to-one节点column就只指定数据库中外键的映射这里是单向的关系还有一种单向的配置关系就是多方配置到了一方上那就是一对多类图数据库多方hbm配置文件中的内容很简单就是对其自身属性的一个映射（这里的多方是ORDER）一方的配置文件也是先将自的属性先映射后用Set来映射<set name="一方中包含的多方属性名称order" table="ORDER" cascade="all"> <key column="C_ID外键"/><one-to-many class="一方包含多方对象的类路径"/></set>这个就是对一方的配置以上两种都是一对多多对一的单向映射还有一种就是双向的类图数据库数据库结构不变配置文件是讲上面2中的结合一方中<set name="一方中包含的多方属性名称order" table="ORDER" cascade="all"> <key column="C_ID外键"/><one-to-many class="一方包含多方对象的类路径"/></set>多方中<many-to-one name="对方包含在本方中的属性名称customer" class="类路"column="C_ID"/>这就行成了双向的关系多对多假如有2个类一个Customer 类 一个Server 类 典型的多对多关系 类图数据库数据库表也是典型的多对多关系表 多对多是三张表 中间的只有主键被引用的就是中间表，就是靠这个来维持两个对象之间的关系也是两个HBM配置文件Customer中其他的本身属性映射不变<set name="多方中包含的多方属性名称server" table="中间表"cascade="save-update"><key column="C_ID中间表引用的字段"/><many-to-many class="对方的类路径" column="S_ID对方的主键"/> </set>Set节点下的写法Server中其他的本身属性映射不变<set name="多方中包含的多方属性名称customer" table="中间表"cascade="save-update"><key column="S_ID中间表引用的字段"/><many-to-many class="对方的类路径" column="C_ID对方的主键"/> </set>那么多对多的关系配置就是这样的上面只是简单的阐述了hibernate的集中映射关系其他的比如还有继承映射继承映射属于高级部分就不在本篇文章中提到了总结Hibernate中可以使用Set、List、Map 进行集合映射为了进行Set映射需要试用<Set>标签List要在映射文件中使用<index>来说明下标位置Map与List类似在关系数据库中只存在外间参照关系，且总是从多方参照一方，这样的好处是消除数据冗余一对一主键关联是让两个对象具有相同的主键值，以表明他们是一对一的关系如果加上唯一性的限制后，外间关联也可以用于一对一的关联关系外键关联多用于多对多映射为了避免一方的更新操作造成数据库同步更新多方，在一对多的关联情况下一端的inverse 属性设置为true多对多关联关系可以通过中间表映射的方式实现。
实验二使用hibernate实现关系映射1、实验目的(1) 理解什么是单向、双向、多对一、一对多的含义(2) 掌握action类的设计与实现2、实验设备与环境硬件：安装有Windows XP/7/8系统的微机一台。
软件：JDK1.6以上、MyEclipse 8.0以上，oracle9i以上。
3、实验内容(1) 使用hibernate配置文件创建学生信息表(学号、姓名、性别、出生日期、班级)、班级信息表(班级编号、班级名称、开班日期)。
(2) 使用hibernate完成两表的主外键关联。
(3) 将配置文件配置成单向多对一，完成对班级和学生信息的增删改查。
(4) 将配置文件配置成双向一对多，完成学生的增删改查。
班级的增、删。
4、实验要求(1) 实验前书写预习报告，包括类图和方法的代码描述。
(2) 记录程序调试中出现的问题和解决方法。
(3) 实验后必须按照要求独立完成实验报告。
(4) 打印源程序清单和测试结果附在实验报告的后面。
5、实验提示(1) 创建web 项目(也可以是java项目)hb1.(2) 将制定jar包导入到工程项目中。
包括：antlr-2.7.6.jarcommons-collections-3.1.jarcommons-logging-1.1.1.jardom4j-1.6.1.jarhibernate3.jarjavassist-3.4.GA.jarjta-1.1.jarlog4j-1.2.14.jarmsbase.jarslf4j-api-1.5.6.jarslf4j-log4j12-1.5.6.jarsqljdbc4.jar(3) 在src下创建制定名为：hibernate.cfg.xml的文件作为hibernate配置文件。
(4) src 下创建包com.hb.entity ,并创建班级信息、学生信息的实体类。
(5) 为相关实体类创建orm文件，并引入到配置文件中去(6) Student和Classinfo 两个类关系为例，进行多对一实体映射关联。
Many-to-oneStudent stuId : int stuName: String cla : Class stuId stuNameclaId1 zhangsan 12 lisi1class Classprivate int claId ;private String claName ; <hibernate-mapping ><class name ="com.softeem.pojo.Class" table ="tb_class"> <id name ="claId"><generator class ="native"></generator > </id ><property name ="claName"></property > </class ></hibernate-mapping > class Studentprivate int stuId ;private String stuName ; private Class cla ; <hibernate-mapping ><class name ="com.softeem.pojo.Student" table ="tb_student"><id name ="stuId"><generator class ="native"></generator > </id ><property name ="stuName"></property > <many-to-one name ="cla" column ="claId" cascade ="all"></many-to-one > </class ></hibernate-mapping >Save:ClassclaId : int claName: StringclaId claName 1 Java01 2Java02Hibernate: insert into tb_student (stuName) values (?) Hibernate: insert into tb_student (stuName) values (?) Hibernate: insert into tb_class (claName) values (?)Ont-to-many 单向class Studentprivate int stuId ;private String stuName ;<hibernate-mapping ><class name ="com.softeem.pojo.Student" table ="tb_student"><id name ="stuId"><generator class ="native"></generator > </id ><property name ="stuName"></property > </class ></hibernate-mapping >class Classprivate int claId ;private String claName ;private Set<Student> students ;<hibernate-mapping package ="com.softeem.pojo"> <class name ="Class" table ="tb_class"> <id name ="claId"><generator class ="native"></generator > </id ><property name ="claName"></property > <set name ="students"><key column ="claId"></key ><one-to-many class ="Student" />Student stuId : int stuName: StringClassclaId : int claName: String students: SetclaId claName 1 Java01 2Java02stuId stuNameclaId1 zhangsan 1 2lisi1</set></class></hibernate-mapping>Sava:Hibernate: insert into tb_student (stuName) values (?) Hibernate: insert into tb_student (stuName) values (?) Hibernate: insert into tb_class (claName) values (?) Hibernate: update tb_student set claId=? where stuId=? Hibernate: update tb_student set claId=? where stuId=?* Ont-to-many 双向class Classprivate int claId ;private String claName ;private Set<Student> students ;<hibernate-mapping package ="com.softeem.pojo"> <class name ="Class" table ="tb_class"> <id name ="claId"><generator class ="native"></generator > </id ><property name ="claName"></property > <set name ="students" inverse ="true"> <key column ="claId"></key ><one-to-many class ="Student" /> </set > </class ></hibernate-mapping > class Studentprivate int stuId ;private String stuName ; private Class cla ; <hibernate-mapping ><class name ="com.softeem.pojo.Student" table ="tb_student"><id name ="stuId"><generator class ="native"></generator > </id >Student stuId : int stuName: String cla : ClassClassclaId : int claName: String students: SetclaId claName 1 Java01 2Java02stuId stuNameclaId1zhangsan 1 2lisi1<property name="stuName"></property><many-to-one name="cla"column="claId"cascade="all"></many-to-one></class></hibernate-mapping>Save:Hibernate: insert into tb_student (stuName) values (?) Hibernate: insert into tb_student (stuName) values (?) Hibernate: insert into tb_class (claName) values (?)One-to-One 主键关联 单向(Student----->Card) Student stuId : int stuName: String cardId: Card stuId stuName1 zhangsan2 lisiclass Cardprivate int cardId ;private String cardCode ;Card.hbm.xml:<hibernate-mapping ><class name ="com.softeem.pojo.Card" table ="tb_card"> <id name ="cardId"><generator class ="native"></generator > </id ><property name ="cardCode"></property > </class ></hibernate-mapping >class Studentprivate int stuId ;private String stuName ;//只做为stuId 的参考,不能生成外键private Card cardId ; Student.hbm.xml : <hibernate-mapping ><class name ="com.softeem.pojo.Student" table ="tb_student"><id name ="stuId"><generator class ="foreign">CardcardId : int cardCode: StringcardId cardCode 1 1001101 21001102<param name="property">cardId</param></generator></id><property name="stuName"></property><one-to-one name="cardId"constrained="true"></one-to-one></class></hibernate-mapping>Hibernate: insert into tb_card (cardCode) values (?) Hibernate: insert into tb_student (stuName, stuId) values (?, ?)One-to-One 主键关联 双向(Student<----->Card) Student stuId : int stuName: String card: Card stuId stuName1 zhangsan2 lisiclass Cardprivate int cardId ;private String cardCode ; private Student student ;Card.hbm.xml:<hibernate-mapping ><class name ="com.softeem.pojo.Card" table ="tb_card"> <id name ="cardId"><generator class ="native"></generator > </id ><property name ="cardCode"></property > <one-to-one name ="student"></one-to-one > </class ></hibernate-mapping > class Studentprivate int stuId ;private String stuName ; private Card card ; Student.hbm.xml : <hibernate-mapping ><class name ="com.softeem.pojo.Student" table ="tb_student"><id name ="stuId"><generator class ="foreign"><param name ="property">card </param > </generator > </id >CardcardId : int cardCode: String student : StudentcardId cardCode 1 1001101 21001102<property name="stuName"></property><one-to-one name="card"constrained="true"></one-to-one></class></hibernate-mapping>One-to-One 唯一外键关联 单向(Student----->Card) Student stuId : int stuName: String card: Card stuId stuNamecardId1 zhangsan 102 lisi2class Cardprivate int cardId ;private String cardCode ;Card.hbm.xml:<hibernate-mapping ><class name ="com.softeem.pojo.Card" table ="tb_card"> <id name ="cardId"><generator class ="native"></generator > </id ><property name ="cardCode"></property > </class ></hibernate-mapping >class Studentprivate int stuId ;private String stuName ; private Card cardId ; Student.hbm.xml : <hibernate-mapping ><class name ="com.softeem.pojo.Student" table ="tb_student"><id name ="stuId"><generator class ="native"></generator > </id ><property name ="stuName" not-null ="true"></property >CardcardId : int cardCode: StringcardId cardCode 10 1001101 21001102<many-to-one name="cardId"unique="true" cascade="all"></many-to-one></class></hibernate-mapping>One-to-One 唯一外键关联 双向(Student<----->Card) Student stuId : int stuName: String card: Card stuId stuNamecardId1 zhangsan 102 lisi2class Studentprivate int stuId ;private String stuName ; private Card cardId ; <hibernate-mapping ><class name ="com.softeem.pojo.Student" table ="tb_student"><id name ="stuId"><generator class ="native"></generator > </id ><property name ="stuName"></property ><many-to-one name ="cardId" unique ="true" cascade ="all"></many-to-one > </class ></hibernate-mapping > class Cardprivate int cardId ;private String cardCode ; private Student student ;<hibernate-mapping package ="com.softeem.pojo"> <class name ="Card" table ="tb_card"> <id name ="cardId"><generator class ="native"></generator > </id ><property name ="cardCode"></property > <one-to-one name ="student" property-ref ="cardId"></one-to-one > </class ></hibernate-mapping >Many-to-many 单向CardcardId : int cardCode: String student : StudentcardId cardCode 10 1001101 21001102UseruserId : int userName: String roles:setclass Roleprivate int roleId ;private String roleName ;<hibernate-mapping package ="com.softeem.pojo"> <class name ="Role" table ="tb_role"> <id name ="roleId"><generator class ="native"></generator > </id ><property name ="roleName"></property > </class ></hibernate-mapping > class Userprivate int userId ;private String userName ; private Set<Role> roles ;<hibernate-mapping package ="com.softeem.pojo"> <class name ="User" table ="tb_user"> <id name ="userId"><generator class ="native"></generator > </id ><property name ="userName"></property > <set name ="roles" table ="tb_user_role">RoleroleId : int roleName: StringuserId userName 1 张三 2 李四 3王五userId roleId 1 1 2 1 2 2 2 3 323 3 roleId roleName 1 院长 2 厨师 3教师<key column="userId"></key><many-to-many class="Role"column="roleId"/> </set></class></hibernate-mapping>Many-to-many 双向UseruserId : int userName: String roles:setclass Userprivate int userId ;private String userName ; private Set<Role> roles ;<hibernate-mapping package ="com.softeem.pojo"> <class name ="User" table ="tb_user"> <id name ="userId"><generator class ="native"></generator > </id ><property name ="userName"></property > <set name ="roles" table ="tb_user_role"> <key column ="userId"></key ><many-to-many class ="Role" column ="roleId" /> </set > </class ></hibernate-mapping > class Roleprivate int roleId ;private String roleName ; private Set<User> users;<hibernate-mapping package ="com.softeem.pojo"> <class name ="Role" table ="tb_role"> <id name ="roleId"><generator class ="native"></generator >RoleroleId : int roleName: String users:setuserId userName 1 张三 2 李四 3王五userId roleId 1 1 2 1 2 2 2 3 323 3 roleId roleName 1 院长 2 厨师 3教师</id><property name="roleName"></property><set name="users"table="tb_user_role"><key column="roleId"></key><many-to-many class="User"column="userId"/> </set></class></hibernate-mapping>。
Hibernate关联关系映射介绍及其相应的应用示例Hibernate关联关系映射目录│├─单向关联│├─一对一外键单向关联│├─一对一主键单向关联│├─一对一连接表单向关联│├─一对多外键单向关联│├─一对多连接表单向关联│├─多对一外键单向关联│├─多对一连接表单向关联│└─多对多单向关联└─双向关联├─一对一外键双向关联├─一对一主键双向关联├─一对一连接表双向关联├─一对多外键双向关联├─一对多连接表双向关联└─多对多双向关联本系列实例的开发环境：Windows XP Professional 简体中文版MySQL 5.0.45Hibernate 3.12Java SDK 1.5.06系列实例中所用的Hibernate配置文件如下：<?xml version='1.0' encoding='gb2312'?><!DOCTYPE hibernate-configuration PUBLIC"-//Hibernate/Hibernate Configuration DTD 3.0//EN""[url]/hibernate-configuration-3.0.dtd[/url]"><hibernate-configuration><session-factory><!--指定连接数据库驱动--><property name="connection.driver_class">com.mysql.jdbc.Driver</property><!--指定连接数据库的url，hibernate连接的数据库名--><property name="connection.url">jdbc:mysql://localhost:3306/hbstudy</property> <!--指定连接数据库的用户名--><property name="ername">root</property><!--指定连接数据库的用户密码--><property name="connection.password">123456</property><!--指定连接池的大小--><property name="connection.pool_size">5</property><!--指定数据库的方言--><property name="dialect">org.hibernate.dialect.MySQLDialect</property><!--根据需要自动创建数据库,测试环境用--><property name="hbm2ddl.auto">create</property><!--在控制台显示执行的SQL语句--><property name="show_sql">true</property><!-- Enable Hibernate's automatic session context management --><property name="current_session_context_class">thread</property><!--映射文件列表--><!--单向关联--><mapping resource="com/lavasoft/dx/_n_1_fk/Addressn1fk.hbm.xml"/><mapping resource="com/lavasoft/dx/_n_1_fk/Personn1fk.hbm.xml"/><mapping resource="com/lavasoft/dx/_n_1_tab/Addressn1tab.hbm.xml"/><mapping resource="com/lavasoft/dx/_n_1_tab/Personn1tab.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_1_fk/Address11fk.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_1_fk/Person11fk.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_1_tab/Address11tab.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_1_tab/Person11tab.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_1_pk/Address11pk.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_1_pk/Person11pk.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_n_fk/Address1nfk.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_n_fk/Person1nfk.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_n_tab/Address1ntab.hbm.xml"/><mapping resource="com/lavasoft/dx/_1_n_tab/Person1ntab.hbm.xml"/><mapping resource="com/lavasoft/dx/_n_n/Addressnn.hbm.xml"/><mapping resource="com/lavasoft/dx/_n_n/Personnn.hbm.xml"/><!--双向关联--><mapping resource="com/lavasoft/sx/_1_n_fk/Address1nfk_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_n_fk/Person1nfk_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_n_tab/Address1ntab_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_n_tab/Person1ntab_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_n_n/Addressnn_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_n_n/Personnn_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_1_fk/Address11fk_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_1_fk/Person11fk_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_1_pk/Address11pk_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_1_pk/Person11pk_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_1_tab/Address11tab_sx.hbm.xml"/><mapping resource="com/lavasoft/sx/_1_1_tab/Person11tab_sx.hbm.xml"/> </session-factory></hibernate-configuration>系列实例中所用到Session工厂是：public class HibernateUtil {private static final SessionFactory sessionFactory;static {try {// Create the SessionFactory from hibernate.cfg.xmlsessionFactory = new Configuration().configure().buildSessionFactory();} catch (Throwable ex) {// Make sure you log the exception, as it might be swallowedSystem.err.println("初始化SessionFactory失败！" + ex);throw new ExceptionInInitializerError(ex);}}public static final ThreadLocal session = new ThreadLocal();public static Session getCurrentSession() throws HibernateException {Session s = (Session) session.get();//当原Session为空或已关闭时，打开一个新的Sessionif (s == null || !s.isOpen()) {s = sessionFactory.openSession();session.set(s);}return s;}public static void closeSession() throws HibernateException {Session s = (Session) session.get();session.set(null);if (s != null) {s.close();}}}Hibernate关联关系映射介绍及其相应的应用示例Hibernate关联关系映射目录│├─单向关联│├─一对一外键单向关联│├─一对一主键单向关联│├─一对一连接表单向关联│├─一对多外键单向关联│├─一对多连接表单向关联│├─多对一外键单向关联│├─多对一连接表单向关联│└─多对多单向关联└─双向关联├─一对一外键双向关联├─一对一主键双向关联├─一对一连接表双向关联├─一对多外键双向关联├─一对多连接表双向关联└─多对多双向关联Hibernate 一对一外键单向关联事实上，单向1-1与N-1的实质是相同的，1-1是N-1的特例，单向1-1与N-1的映射配置也非常相似。
