Hibernate映射解决问题

合集下载

Hibernate(6)—— 一对多和多对多关联关系映射(xml和注解)总结

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实体关联关系映射----总结

Hibernate实体关联关系映射----总结在我看来，Hibernate提供这些映射关系，常⽤就是⼀对⼀和多对⼀，并且在能不⽤连接表的时候尽量不要⽤连接表。

多对多会⽤到，如果⽤到了，应该⾸先考虑底层数据库设计是否合理。

在实际开发中，在Hibernate关联关系之外常常还有另外⼀种选择⽅案，表各⾃作为单表映射，业务逻辑控制外键关系（有时候就是⼀个相关联的列，但不⼀定要加外键约束），这样更加灵活，并且数据的完整性同样有保证。

当然，“单表映射，业务控制外键关系”并不是说Hibernate的实体关联功能是多余的，Hibernate的实体关联的优点很多，随便拿本书都是讲优点，⽤好了会让开发⼈员感觉更⽅便，现在我也是两种⽅案结合使⽤。

⽐如对于不很确定的两个实体，常常选⽤单表关联。

以前在初学Hibernate还没有完全搞清楚这些关联关系的时候，就是⽤单表映射，业务控制外键关系做的，发现没有任何问题，程序同样运⾏得很好。

看了这些是不是后悔浪费时间学习映射关系了？呵呵，Hibernate的OR Mapping是Hibernate的灵魂，我相信Hibernate的创始⼈⽐我们⼀般⼈的理解更深刻。

只有学会了这些才能体会Hibernate设计者的思想。

学⼀个东西，不光⾃⼰写代码，还应该能看懂别⼈的代码才⾏。

因此系统学习这些关联映射还是⼤有必要的。

以上都是我⾃⼰的观点。

欢迎在此交流讨论。

Hibernate在实际项⽬开发中，hbm.xml包括数据库脚本都是通过Xdoclet⽣成的，在此不采⽤Xdoclet的⽬的是为了便于理解这些映射模型。

实体-数据表-映射⽂件三者对⽐看，太直观了。

瞌睡了，暂时先写到此，有新思路了再补上。

-----------------------------------------------------回Hibernate：Hibernate关联关系映射⽬录│├─单向关联│├─│├─│├─│├─│├─│├─│├─│└─└─双向关联├─├─├─├─├─└─。

Hibernate映射

Street.hbm.xml
• •
• • • •
• • • •
<hibernate-mapping> <class name="com.xdf.bean.Street" table="Street"> <id name="id" type="ng.Integer"><column name="id" /> <generator class="sequence"> <param name="sequence">str_id</param> </generator> </id> <many-to-one name="district" class="com.xdf.bean.District" column="district_id" notnull="false"></many-to-one> <property name="street_name" type="ng.String"> <column name="street_name" length="50" notnull="false"></column> </property></class> </hibernate-mapping>
租房系统中街道和区的映射文件
District.hbm.xml <hibernate-mapping> <class name="cn.jbit.houserent.bean.District" table="district"> <id name="id" type="ng.Long"> <column name="id" /> <generator class="native" /> Street.hbm.xml </id> <hibernate-mapping> <property name="name" type="ng.String"> <class name="cn.jbit.houserent.bean.Street" table="street”> <column name="name" length="50" not-null="true" /> <id name="id" type="ng.Long"> </property> <column name="id" /> </class> <generator class="native" /> 设置关系的对象 </hibernate-mapping> </id> <many-to-one name="district" class="cn.jbit.houserent.bean.District"> <column name="district_id" /> 设置关系的字段 </many-to-one> <property name="name" type="ng.String"> <column name="street_name" length="50" not-null="true" /> </property> 与Street 对应的street 表是通过district_id 的值关联至 </class> district 表的 </hibernate-mapping>

hibernate关系映射总结

5.2.2.3、一对一主键关系映射(非延迟抓取) 配置 1（UserModel.hbm.xml） Java 代码 1. <one-to-one name="userGeneral" cascade="all"/>
配置 2（UserGeneralModel.hbm.xml） Java 代码 1. 2. 3. 4. 5. 6. 7. 8. 关联的对象所对应的数据库表之间，通过一个外键引用对主键进行约束。 <id name="uuid"> <generator class="foreign"> <param name="property">user</param> </generator> </id> <one-to-one name="user" class="erModel"/>
四、如何把数据库关系表示为面向对象中的关系： 1、关联：将数据库表之间的关系转化为对象之间的关系；在 Hibernate 中总指实体之间的关系。 2、映射：完成 java 对象到数据库表的双向转换。 3、级联（可选）：将数据库中的级联转化为对象中的级联（两者（对象和数据库表）没关系）。 4、Hibernate 的表和对象的映射： 1、实体类型映射： 4.1.1、主键之间的映射
5.2.2、实体关联关系映射： 5.2.2.1、单向关联关系映射，不演示。 5.2.2.2、双向关联关系映射
Java 代码 1. 2. 3. 4. 5. 6. 单向定义：不知道另一端什么情况，获取一端另一端自动获取，因为单向，你不知道另一侧是什么。如 class A{ B b;} class B{ } 只能从 A 导航到 B，不能从 B 导航到 A 关系维护：另一端维护，如 B 维护

hibernate关联映射详解

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的外键。

Hibernate使用注解映射取代映射文件

Hibernate使用注解映射取代映射文件hibernate官方文档参考——查询：在编写Hibernate的时候，需要将实体类映射到数据库中的表。

通常需要一个配置文件(hibernate.cfg.xml)，一个实体类(XX.java)，还有一个映射文件(XX.hbm.xml)。

从JAVA5.0之后，可以利用注解来简化配置。

简单来说就是不再需要映射文件了，hibernate需要的元数据(metadata)通过注解实体类就行了。

下面是一个简单的基于注解映射的Hibernate Hello World项目：用到的工具和技术：1.Eclipse4.2.22.Maven 33.Hibernate4.2.2.Final4.JPA首先是项目的整体架构：项目的依赖(pom.xml):[html]view plaincopy1.<dependencies>2.<dependency>3.<groupId>junit</groupId>4.<artifactId>junit</artifactId>5.<version>3.8.1</version>6.<scope>test</scope>7.</dependency>8.<dependency>9.<groupId>org.hibernate</groupId>10.<artifactId>hibernate-core</artifactId>11.<version>4.2.2.Final</version>12.</dependency>13.</dependencies>JPA jar包在hibernate3.6之后被放入hibernate-core包中。

hibernate一对一映射

hibernate一对一映射一、建立两个对象：一个Person，一个身份证这两个类是一对一的映射二、建立实体之间的关系:1、首先从Person的角度，先看看这个人，要知道他的身分证号是什么，所以要持有一个身分证的引用。

反过来，拿到身分证的时候，要知道这个人。

所以在IdCard中要持有Person的引用。

所谓的单双向，是指从一个对象可以访问到另一个对象，从另一个对象访问不到它。

而双向它们就可以互相访问了。

从Person可以看到IdCard，从IdCard可以看到Person.这叫做双向。

我们先看它的单向。

如果只看单向，则Person要持有IdCard的引用。

Person IdCard这两个对象之间是有有关系的，所以有一个箭头连接两者。

所以表面看它们的关系和用户和组的关系似乎是一样的。

所以必须通过映射标签才能区别两者。

2、一对一关联映射有两种:一种是主键关联，一种是外键关联。

主键关联就是我们的两个实体而生成的两个表的主键相同。

也就是说，如果IdCard这个表里有一个主键是1，则Person这个表里也有一个主键是1.这样就不用加任何字段让主键一致。

主键关联不用增加字段，还是原来的字段就可以了。

因为person引用了idCard,所以idCard一定先有值。

三、如何映射实现主键一致。

一、新建项目hibernate_one2one_pk_1:单向关联二、建立实体类1、IdCard类。

package com.bjsxt.hibernate;public class IdCard {private int id;private String cardNo;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getCardNo() {return cardNo;}public void setCardNo(String cardNo) {this.cardNo = cardNo;}}2、Person.classpackage com.bjsxt.hibernate;public class Person {private int id;private String name;IdCard idCard;public IdCard getIdCard() {return idCard;}public void setIdCard(IdCard idCard) { this.idCard = idCard;}public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}}三、实体有了之后，要建立映射文件，将两者的关系建立起来1、选建立简单的。

hibernate对象关系映射文件节点说明

N
outer-join
是否使用外连接
True：总是使用outer-join
False：不使用outer-join
Auto：如果关联对象没有采用proxy机制，则使用outer-join
N
fetch
Fetch=“join”等同于outer-join=“true”
Fetch=“select”等同于outer-join=“false”
数据库Schema名称
N
catalog
数据库catalog名称
N
default-cascade
默认级联模式默认是none
N
default-access
默认属性访问模式对于大多数情况采用property即可，这种方式将通过getter/setter方法对影射类属性进行存取，默认是property
N
default-lazy
dynamic-update="false|true"dynamic-insert="false|true"
select-before-update="false|true"polymorphism="implicit|explicit"
where="arbitrary sql where condition"persister="persisterClass"
节点内容：
<classname="ers"
table="users"discriminator-value="1"mutable="true|false"
schema="dbo"catalog="shopping"proxy="ProxyInterface"

hibernate 映射总结

1.1单张表：<hibernate-mapping package="pojo"><class name="User" table="H_USER"><id name="id" column="user_id" type="int"><generator class="increment"></generator></id><property name="name" column="user_name"></property><property name="age" column="user_age"></property></class></hibernate-mapping>1.2细粒度模型：用component建一张关联两个类的表（User类中有Address类）<hibernate-mapping package="pojo"><class name="User" table="H_USER"><id name="id" column="user_id" type="int"><generator class="increment"></generator></id><property name="name" column="user_name"></property><property name="age" column="user_age"></property><component name="add" class="Address"><property name="city" column="CITY" type="string"length="20"></property><property name="street" column="STREET" type="string"length="20"></property></component></class></hibernate-mapping>2.1一对多关联用set（公司类中有一个员工集合emps，员工类中有一个公司属性com）<hibernate-mapping package="pojo"><class name="Company" table="ONE2MANY_COMPANY" lazy="false"><id name="id" ><generator class="increment"></generator></id><property name="name" column="NAME"></property><set name="emps" cascade="all" lazy="false" inverse="false"><key column="COMID"/><one-to-many class="Employee"/></set></class></hibernate-mapping><hibernate-mapping package="pojo"><class name="Employee" table="ONE2MANY_EMPLOYEE" lazy="false"><id name="id" ><generator class="increment"></generator></id><property name="name" column="NAME" type="string"></property><many-to-one name="com" column="COMID" class="Company"></many-to-one></class></hibernate-mapping>column:COMID是ONE2MANY_EMPLOYEE表中的一列foreign key (COMID) references ONE2MANY_COMPANY2.2一对多关联用list（公司类中有一个员工集合emps，员工类中有一个公司属性com，多加一个索引属性idx）hibernate-mapping package="pojo"><class name="Company" table="COLLECTION_LIST_COMPANY" lazy="false"> <id name="id"><generator class="increment" /></id><property name="name" column="NAME" /><list name="emps" lazy="false" cascade="all" inverse="true" ><key column="COMID" /><index column="idx" /><one-to-many class="Employee" /></list></class></hibernate-mapping><hibernate-mapping package="pojo"><class name="Employee" table="COLLECTION_LIST_EMPLOYEE" lazy="false"> <id name="id" ><generator class="increment" /></id><property name="name" /><property name="idx" column="idx"/><many-to-one name="com" column="COMID" class="Company" /></class></hibernate-mapping>2.3一对多关联用bag（公司类中有一个员工集合（list）emps，员工类中有一个公司属性com）<hibernate-mapping package="pojo"><class name="Company" table="COLLECTION_BAG_COMPANY" lazy="false"> <id name="id"><generator class="increment" /></id><property name="name" column="NAME" /><bag name="emps" lazy="false" cascade="all"><key column="COMID" /><one-to-many class="Employee" /></bag></class></hibernate-mapping>hibernate-mapping package="pojo"><class name="Employee" table="COLLECTION_BAG_EMPLOYEE" lazy="false"> <id name="id" ><generator class="increment" /></id><property name="name" /><many-to-one name="com" column="COMID" class="Company" /> </class></hibernate-mapping>2.4一对多关联用map（公司类中有一个员工集合（map）emps，员工类中有一个公司属性com）<hibernate-mapping package="pojo"><class name="Company" table="COLLECTION_MAP_COMPANY" lazy="false"> <id name="id"><generator class="increment" /></id><property name="name" column="NAME" /><map name="emps" lazy="false" cascade="all"><key column="COMID" /><map-key column="mapkey" type="string"/><one-to-many class="Employee" /></map></class></hibernate-mapping><hibernate-mapping package="pojo"><class name="Employee" table="COLLECTION_MAP_EMPLOYEE" lazy="false"> <id name="id" ><generator class="increment" /></id><property name="name" /><many-to-one name="com" column="COMID" class="Company" /> </class></hibernate-mapping>COLLECTION_MAP_EMPLOYEE表里多一列mapkey3.1一对一（主键）（car类里有一个engine属性，engine类里有个car属性）<hibernate-mapping package="pojo"><class name="Car" table="ONE2ONE_CAR" lazy="false"><id name="id" column="id" type="int" ><generator class="increment"></generator></id><property name="name" column="NAME"></property><one-to-one name="engine" class="Engine" cascade="all"></one-to-one></class></hibernate-mapping><hibernate-mapping package="pojo"><class name="Engine" table="ONE2ONE_ENGINE" lazy="false"><id name="id" column="id" type="int"><generator class="foreign"><param name="property">car</param></generator></id><property name="model" column="model" type="string"></property><one-to-one name="car" class="Car" constrained="true"></one-to-one> </class></hibernate-mapping>从表的主键既是外键关联主表3.2一对一（外键）在一对多基础上加唯一约束car<one-to-one name="engine" class="Engine" property-ref="car" cascade="save-update"/> property-ref="car"表示engine引用了car表的主键作为他的主键engine<many-to-one name="car" class="Car" unique="ture" colun="carid"/>最后两句表示engine表中的外键carid加上唯一约束使之一对多的关系强制转为一对一4多对多public class Animal implements Serializable {private int aid;private String name;private Set<Food> food=new HashSet<Food>();public class Food implements Serializable {private int fid;private String name;private Set<Animal> animal=new HashSet<Animal>();<hibernate-mapping package="pojo"><class name="Animal" table="MANY2MANY_ANIMAL" lazy="false"><id column="A_ID" name="aid" type="int" ><generator class="increment"></generator></id><property name="name" column="name" type="string"></property><set name="food" table="MANY2MANY_ANIMAL_FOOD" cascade="all" lazy="false" inverse="false"><key column="A_ID"/><many-to-many class="Food" column="F_ID"/></set></class></hibernate-mapping><hibernate-mapping package="pojo"><class name="Food" table="MANY2MANY_FOOD" lazy="false"><id column="F_ID" name="fid" type="int" ><generator class="increment"></generator></id><property name="name" column="name" type="string"></property><set name="animal" table="MANY2MANY_ANIMAL_FOOD" cascade="none" lazy="false" inverse="true"><key column="F_ID"/><many-to-many class="Animal" column="A_ID"/></set></class></hibernate-mapping>多对多需要一个中间表5.1实现hibernate继承关系：所有的类在一张表中体现-加一个类型识别字段<hibernate-mapping package="pojo"schema="zhq"><class name="Computer"table="EXTENDS_1TABLE"discriminator-value="C"><id name="id"><generator class="increment"></generator></id><discriminator column="D_N"type="string"/><property name="price"></property><property name="manufacturer"></property><subclass name="Desktop"discriminator-value="D"><property name="islcd"></property></subclass><subclass name="NotePad"discriminator-value="N"><property name="weight"></property><property name="thickness"></property></subclass></class></hibernate-mapping>hibernate提供一个Discriminator映射的方法，就是把一个表映射成不同的类，有不同的属性。

hibernate的两种映射

*/
@Entity
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "type", discriminatorType = DiscriminatorType.STRING)
@DiscriminatorValue("product")
import java.util.Date;
...
private Date publishDate;
...
public Date getPublishDate() {
return publishDate;
}
public void setPublishDate(Date publishDate) {
return this.unitprice;
}
public void setCategory(Category category) {
this.category = category;
}
public void setDescn(String descn) {
this.descn = descn;
}
public void setId(Integer id) {
this.id = id;
}
public void setInventory(Integer inventory) {
public class UserByZhuJie {
private Integer id;
@Id
@Column(updatable=false, insertable=false)

hibernate关系配置与映射

《hibernate开发》第二章：Hibenrate常规操作POJO三种状态在Hibernate中，最核心的概念就是对PO的状态管理。

一个PO有三种状态Hibernate的对象有三种状态，分别为：瞬时态(Transient)、持久态(Persistent)、脱管态(Detached)。

处于持久态的对象也称为PO(Persistence Object)，瞬时对象和脱管对象也称为VO（V alue Object）。

瞬时态由new命令开辟内存空间的java对象，eg. User user =new User()如果没有变量对该对象进行引用，它将被java虚拟机回收。

瞬时对象在内存孤立存在，它是携带信息的载体，不和数据库的数据有任何关联关系，在Hibernate中，可通过session的save()或saveOrUpdate()方法将瞬时对象与数据库相关联，并将数据对应的插入数据库中，此时该瞬时对象转变成持久化对象。

持久态处于该状态的对象在数据库中具有对应的记录，并拥有一个持久化标识。

如果是用hibernate的delete()方法，对应的持久对象就变成瞬时对象，因数据库中的对应数据已被删除，该对象不再与数据库的记录关联。

当一个session执行close()或clear()、evict()之后，持久对象变成脱管对象，此时持久对象会变成脱管对象，此时该对象虽然具有数据库识别值，但它已不在HIbernate持久层的管理之下。

持久对象具有如下特点：1.和session实例关联；2. 在数据库中有与之关联的记录。

脱管态当与某持久对象关联的session被关闭后，该持久对象转变为脱管对象。

当脱管对象被重新关联到session 上时，并再次转变成持久对象。

脱管对象拥有数据库的识别值，可通过update()、saveOrUpdate()等方法，转变成持久对象。

脱管对象具有如下特点：1. 本质上与瞬时对象相同，在没有任何变量引用它时，JVM会在适当的时候将它回收；2. 比瞬时对象多了一个数据库记录标识值。

Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结

Hibernate(V)——一对多与多对多关联关系映射(xml与注解)总结引言简要介绍Hibernate框架以及关联关系映射在数据库设计中的重要性。

Hibernate关联关系映射概述关联关系的重要性讨论在现实世界中对象间关系的重要性以及如何在数据库中表示这些关系。

Hibernate关联关系类型列举Hibernate支持的关联关系类型，包括一对一、一对多、多对一和多对多。

一对多关联关系映射概念解释解释一对多关联关系的概念，例如一个部门拥有多个员工。

XML映射方式详细描述如何在XML映射文件中配置一对多关联关系。

实体类定义展示一对多关系中实体类的Java代码示例。

XML映射文件提供一对多关系映射的XML配置示例。

注解映射方式详细描述如何使用注解配置一对多关联关系。

实体类定义展示使用注解的一对多关系中实体类的Java代码示例。

注解配置提供一对多关系映射的注解配置示例。

多对多关联关系映射概念解释解释多对多关联关系的概念，例如学生和课程之间的关联。

XML映射方式详细描述如何在XML映射文件中配置多对多关联关系。

实体类定义展示多对多关系中实体类的Java代码示例。

XML映射文件提供多对多关系映射的XML配置示例。

注解映射方式详细描述如何使用注解配置多对多关联关系。

实体类定义展示使用注解的多对多关系中实体类的Java代码示例。

注解配置提供多对多关系映射的注解配置示例。

关联关系映射的高级特性级联操作讨论级联保存、更新和删除的概念及其配置。

双向关系管理解释如何管理双向关联关系，确保数据的一致性。

延迟加载与即时加载讨论延迟加载和即时加载的概念及其在关联关系中的应用。

实践案例分析一对多关联关系案例通过一个具体的一对多关联关系案例，展示映射配置和数据操作。

多对多关联关系案例通过一个具体的多对多关联关系案例，展示映射配置和数据操作。

常见问题与解决方案一对多关联关系常见问题列举一对多关联关系映射中可能遇到的问题及其解决方案。

浅析Hibernate映射——基本映射

浅析Hibernate映射——基本映射在说Hibernate映射之前，先下了解下面的概念。

对象-关系映射（Object/Relation Mapping，简称ORM），是随着面向对象的软件开发方法发展而产生的,是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术,本质上就是将数据从一种形式转换到另外一种形式。

面向对象的开发方法是当今企业级应用开发环境中的主流开发方法，关系数据库是企业级应用环境中永久存放数据的主流数据存储系统。

对象和关系数据是业务实体的两种表现形式，业务实体在内存中表现为对象，在数据库中表现为关系数据。

内存中的对象之间存在关联和继承关系，而在数据库中，关系数据无法直接表达多对多关联和继承关系。

因此，对象-关系映射(ORM)系统一般以中间件的形式存在，主要实现程序对象到关系数据库数据的映射。

简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将java程序中的对象自动持久化到关系数据库中实现ORM的框架很多,其中当属Hibernate最为流行,下面通过几篇文章来看一下Hibernate 是如何实现ORM的，即Hibernate的几种映射。

Hibernate在实现ORM功能的时候主要用到的文件有：1、映射类（*.java）：它是描述数据库表的结构，表中的字段在类中被描述成属性，将来就可以实现把表中的记录映射成为该类的对象了。

2、映射文件（*.hbm.xml）：它是指定数据库表和映射类之间的关系，包括映射类和数据库表的对应关系、表字段和类属性类型的对应关系以及表字段和类属性名称的对应关系等。

3、hibernate核心配置文件（*.properties/*.cfg.xml）：它指定hibernate的一些核心配置，包含与数据库连接时需要的连接信息，比如连接哪种数据库、登录数据库的用户名、登录密码以及连接字符串等。

映射文件的地址信息也放在这里基本映射：java 对象关系模型实体类--->表，采用标签映射实体类中的普通属性（不包括集合、自定义类和数组）------->表字段，采用标签映射映射类：[java] view plaincopyprint?package com.jialin.hibernate;import java.util.Date;public class User {private int id;private String name;private String password;public int getId() {return id;}public void setId(int id) {this.id = id;}public String getName() {return name;}public void setName(String name) { = name;}public String getPassword() {return password;}public void setPassword(String password) {this.password = password;}}注：实体类的设计原则：* 实现无参的默认的构造函数* 提供一个标识* 建议不要使用final修饰实体类（因为采用load延时加载数据的时候会继承实体类生成代理对象）* 建议为实体类生成getter和setter方法（如果不使用，需要用属性field标识）映射文件具体说明：[html] view plaincopyprint?"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.jialin.hibernate"><generator class="native" />。

Hibernate对象关系映射总结

一对一双向关联（外键关联）每个人己的身份证每张身份证对应着一个人部门通depart_id的员工员工通过外键depart_id能够找到自己所属的部门这是用户表user3的结构多对多双向关联public class Student {p rivate int id;p rivate String name;p rivate Set<Teacher> teachers; …………………………………. } public class Teacher {private int id;private String name;private Set<Student> students; ………………………………….}用户组知道自己有哪些用户：通过groupid就能查询到用户用户不知道自己所于哪个用户组多个订单对应一个客户：订单通过外键：customer_id能够找到自己的客户客户不知道自己有什么订单因为是单向关联public int getId() {id;return}…………………..}在t_jpa_user1表的映射如下结构：多对多单向关联学生老师public class Student1 {privateintid;privateStringname; …………………………………. } public class Teacher1 {private int id;private String name;private Set<Student1> students = new HashSet<Student1>(); ………………………………….}@Entity@Entity@Table(name="t_jpa_teacher2")@Table(name="t_jpa_Student2")public class Teacher2 {public class Student2 {privateintid;privateintid;privateStringname;privateStringname;private Set<Student2> students = new HashSet<Student2>(); ………………………………….@ManyToMany}@JoinTable(name="t_jpa_teacher_student",joinColumns={@JoinColumn(name="teacher_id")},inverseJoinColumns={@JoinColumn(name="student_id")})………………………………….}单向关系中的JoinColumn在单向关系中没有mappedBy,主控方相当于拥有指向另一方的外键的一方。

hibernate关系映射注解配置

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映射解析---继承映射

现实世界中有很多种动物，比如：Pig（猪），Bird（鸟）等等，当我用面向对象的思想分析时，我们一般会将它们的共同部分抽取出来增加一个抽象类Animal（动物），这样在编写程序时Pig和Bird只需要继承它们的父类Animal就可以省去很多重复的代码。

Java代码中只需要extends关键字就可以轻松实现这种继承关系，但是对于我们使用的关系型数据库是没有任何关键字可以指明这种继承关系的。

为了将这种继承关系反映到数据库中，Hibernate 为我们提供了3种解决方案：1、每个具体类对应一张表该方案是使继承体系中每一个具体的类都对应数据库中的一张表。

示意图如下：每个子类对应的数据库表都包含了父类的信息，并且还有自己独有的属性，每个子类对应一张表，这个表具备完整的信息，包含了所有父类继承下来的属性映射的字段，这种策略是使用<union-subclass>标签来定义子类的。

注意：在保存对象的时候id不能重复（不能使用数据库的自增方式生成主键）部分代码展示：<?xml version="1.0"?><!DOCTYPE hibernate-mapping PUBLIC"-//Hibernate/Hibernate Mapping DTD 3.0//EN""/hibernate-mapping-3.0.dtd"> <hibernate-mapping package="com.hibernate"><class name="Animal" table="t_animal" abstract="true"><id name="id"><generator class="assigned"/></id><property name="name"/><property name="sex"/><union-subclass name="Pig" table="t_pig"><property name="weight"/></union-subclass><union-subclass name="Bird" table="t_bird"><property name="height"/></union-subclass></class></hibernate-mapping>2、每个类一张表这种策略是使用<joined-subclass>标签来定义子类的。

Hibernate映射文件

(2).数据库和JavaBean的关联:Hibernate映射文件中用<hibernate-mapping>节点下的<class name="JavaBean名称(该节点的父节点中用package属性指定了JavaBean的包名时用)/全路径(该节点的父节点中没用package属性指定JavaBean的包名时用)" table="对应数据库中的表名">节点指定数据库表和JavaBean的关联
(19).persister: 指定一个Persister类
(20).discriminator-value: 子类识别标识默认值为类名
(21).optimistic-lock: 指定乐观锁定的策略默认值为vesion
4.class节点的字节点
(1).id: 定义当前映射文件对应的持久类的主键属性和数据表中主键字段的相关信息
(3).meta: 设置类或属性的元数据属性
(4).typedef:Leabharlann 设置新的Hibernate数据类型
(5).joined-subclass: 指定当前联结的子类
(6).union-subclass: 指定当前联结子的类
(7).query: 定义一个HQL查询
(4).catalog: 设置当前指定的持久类对应的数据库表的catalog名
(5).lazy: 设置是否使用延迟加载
(6).batch-size: 设置批量操作记录的数目(默认值为1)
(7).check: 指定一个SQL语句用于Schema前的条件检查
⑨.uuid.hex:由Hibernate基于128位唯一值产生算法生成16进制数值(编码后以长度32的字符串表示)作为主键

hibernate注解处理映射关系

private int id; private String name;
3 / 14
private int age; private ClassRoom room;
@ManyToOne(fetch=ZY) ---> ManyToOne 指定了多对一的关系，fetch=ZY 属性表示在多的那一方通过延迟加载的方式加载对象(默认不是延迟加载)
return name; }
--->
指定了 OneToOne 的关联关系，mappedBy 同样指定由对方来进
5 / 14
public void setName(String name) {
= name; }
}
IDCard 类：
@Entity @Table(name="t_id_card") public class IDCard {
this.room = room; } @Id @GeneratedValue public int getId() {
return id; } public void setId(int id) {
this.id = id; } public String getName() {
return name; } public void setName(String name) {
@Entity @Table(name="t_person") public class Person {
private int id; private String name; private IDCard card;
@OneToOne(mappedBy="person") 行维护关联关系

Hibernate映射解决问题

Hibernate映射解决问题Hibernate映射解决问题做Hibernate映射已经做了五天了,期间遇到了不少错误,有的时候错误很细小,很难发现.现在就来总结一下,常见的错误,有的也是在网上搜了看到的!第一种问题:Could not execute JDBC batch update网上说有两种可能:1.因为Hibernate Tools（或者Eclipse本身的Database Explorer）生成*.hbn.xml工具中包含有catalog="***"（*表示数据库名称）这样的属性,将该属性删除就可以了2.估计是你的列名里面有关键字的原因吧，命名列的时候不要单独使用date,ID...这种关键字但是,我觉得他写得不完全啦!我遇到的就不是两种原因,而是List映射时,对应表的索引项没有设成主键,所以就出错了.虽然找了蛮长时间的.同样,它也会出现Duplicate entry '1' for key 1的错误啦!第二种问题(归纳下):1．Caused by: org.dom4j.DocumentException: Invalid byte 2 of 2-byte UTF-8 sequence. Nested exception: Invalid byte 2 of 2-byte UTF-8 sequence.如果出现这行错误说明你的XML配置文件有不规范的字符，检查下。

2．net.sf.hibernate.MappingException: Error reading resource: hibernate/Hello_Bean.hbm.xml如果出现这行错误说明你的hibernate的XML配置文件有错3．net.sf.hibernate.MappingException: Resource: hibernate/Hello_Bean.hbm.xml not found如果出现这行错误说明hibernate的XML配置文件没有找到，你应该把XML文件放在与你的类文件同个目录下,一般跟同名的java持久化类放在一起，也就是跟Hello_Bean.class类文件一起。

Hibernate中的继承关系的映射实现

Hibernate中的继承关系的映射实现1、继承关系的描述在域模型中，类与类之间除了关联关系和聚集关系，还可以存在继承关系，在下面的图中所示的域模型中，Company类和Employee类之间为一对多的双向关联关系（假定不允许雇员同时在多个公司兼职），Employee类为抽象类，因此它不能被实例化，它有两个具体的子类：HourlyEmployee类和SalariedEmployee 类。

由于Java只允许一个类最多有一个直接的父类，因此Employee类、HourlyEmployee类和SalariedEmployee类构成了一棵继承关系树。

2、OOP中的多态的概念---OOP中的多态（1）OOP中的多态在面向对象的范畴中，还存在多态的概念，多态建立在继承关系的基础上。

简单地理解，多态是指当一个Java应用变量被声明为基类的类型时（如定义为Employee类时），这个变量实际上既可以引用其各个子类的实例（如HourlyEmployee类的实例，也可以引用SalariedEmployee类的实例）。

（2）代码示例以下这段程序代码就体现了多态：List employees= businessService.findAllEmployees();Iterator it=employees.iterator();while(it.hasNext()){Employee oneEmployee =(Employee)it.next();if(oneEmployee instanceof HourlyEmployee){System.out.println(oneEmployee.getName()+" "+((HourlyEmployee) oneEmployee).getRate());}else{System.out.println(oneEmployee.getName()+" "+((SalariedEmployee) oneEmployee).getSalary());}3、多态查询的应用（1）多态查询如果我们在BusinessService类的findAllEmployees()方法中通过Hibernate API从数据库中检索出所有Employee对象（基类），则将会在findAllEmployees()方法返回的集合中将包含Employee基类的各个子类的对象，也就是既包含有HourlyEmployee类的实例，同时也包含SalariedEmployee类的实例，这种查询被称为多态查询。