hibernate的对象关系映射,hibernate有几种映射关系
hibernate的对象关系映射,hibernate有几种映射关系详细介绍
本文目录一览： hibernate有几种映射关系
Hibernate的关联关系映射大概有这么几种:
1、单向N-1
2、单向1-1
3、单向1-N
4、单向N-N
5、双向1-N
6、双向N-N
7、双向1-1
下面就对这七种关联关系映射进行一个简单的总结:
一、单向的多对一
看两个POJO
public class Person{
private int pid;
private String name;
private Address address;
...//生成相应的getter、setter方法
}
----------------------------------------
public class Address{
private int id;
private String detail;
...//生成相应的getter、setter方法
}
这里我们需要维护的关系是多个Person可以对应同一个地址,使用单向的N-1映射我们只需要在多的一端加入一个外键指向一的一端即可
**看配置文件
...//部分字段配置省略
//关键配置
这样配置以后hibernate就会帮我们在多的一端（Person）添加一个外键addressId指向一的一端
二、单向的1-1(外键关联)
可以采用
标签，指定多的一端的unique=true，这样就限制了多的一端的多重性唯一
通过这种手段映射一对一唯一外键关联
配置文件只需要修改为:
三、单向的1-N
**看代码,我们知道一个班级有多名学生，这就是一个典型的1-N关系
public class Classes {
private int id;
private String name;
private Set students;
...//生成相应的getter、setter方法
}
---------------------------------------------------------------------------
public class Student {
private int id;
private String name;
..//生成相应是getter、setter方法
}
**映射原理:一对多关联映射，在多的一端添加一个外键指向一的一端,它维护的关系是一指向多
**配置文件:
//在一的一端添加的外键指向多的一端(默认情况下市主键匹配)
//注意它维护的是一指向多的关系
四、双向1-N
上面提到了单向的1-N在一的一端添加的外键指向多的一端即可,对于双向的1-N则类似于N-N，集合元素中不使用
元素映射关联属性，而使用
元素，但是为了保证一的一端，因此需要增加unique="true"属性
**配置,简单修改单向1-N的配置文件
五、单向多对多
**先看两个POJO
public class User {
private int id;
private String name;
private Set roles;
..//生成相应的getter、setter方法
}
---------------------------------------------------------------------------
public class Role {
private int id;
private String name;
..//生成相应的getter、setter方法
}
现在需要映射这样的N-N关系，一个User可以有多个Role，而一个Role有可以被多个User所拥有
这样我们就可以将一个N-N关系拆分为两个N-1的关系
**看配置文件
这样我们的关系的明确了
t_user t_user_role t_role
id name < -------userid roleid ----- > id name
六、双向的多对多关系
双向的多对多映射需要在两边都增加集合元素，用于映射集合属性
修改上面的单向N-N映射
在Role中添加集合属性
public class Role {
private int id;
private String name;
privarte Set user
..//生成相应的getter、setter方法
}
修改配置文件
------------------------------------------------------------------------------------------------
注意点:1、双向多对多关联两边都需要指定连接表的表名和外键列的列名
2、两个集合元素Set的table值必须指定,而且需要相同
七、双向的一对一关联
双向的1-1关联有两种形式:
1、基于外键的双向1-1关联
我们可以回想一下上面提到的单向1-1映射,它是有N-1的一个特例，只需要在
标签多的一端添加unique="true"属性就可以形成单向的1-1映射关系,那么该怎么样将这种映射改为双向的呢?
下面我们再举个例子：一个User必须要有一个唯一的identityId
首先创建两个POJO类
public class Person {
private int id;
private String name;
private IdentityId identityId;
..//生成相应的getter、setter方法
}
public class IdentityId {
private int id;
private String cardNo;
private Person person;
..//生成相应的getter、setter方法
}
**看配置文件
-----------------------------------------------------------------------------------
注意：这里的property-ref属性为identity表明建立了从identity对象到person对象的关联.
因此只要调用identity持久化对象的getIdentityId()方法就可以导航到Person对象 由此可见：
Person对象和IdentityId对象之间为双向的关联关系person.getIdentityId().getPerson()
2、基于主键的1-1双向关联
上面的POJO类不需要有任何变化，我们只需要修改配置文件
identityId
注意：这里的constrained="true"表明Person表的主键ID同时作为外键参考IdentityId表
--------------------------------------------------------------------------------------
注意：这里Person表中ID既是主键同时还作为外键参照表IdentityId,因为使用了foreign标识符生成策略Hibernate就保证了Person
对象与关联的IdentityId对象共享一个主键
综上所述，hibernate的实体映射方式很灵活,如果我们使用hibernate映射得当将可以大大简化持久层数据的访问!
以实例说明什么是“对象—关系映射”？
对象关系映射(ObjectRelationalMapping，简称ORM)是通过使用描述对象和数据库之间映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。
这也同时暗示着额外的执行开销;然而，如果ORM作为一种中间件实现，则会有很多机会做优化，而这些在手写的持久层并不存在。更重要的是用于控制转换的元数据需要提供和管理;但是同样，这些花费要比维护手写的方案要少;而且就算是遵守ODMG规范的对象数据库依然需要类级别的元数据。
一个简单的映射例子(hibernate)，我们定义User对象和数据库中user表之间的关联，user表中只有两列：id和name。
Hibernate框架之间的关系是什么以及怎么处理
Hibernate是一个开源Java持久化项目，一个功能强大的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命
意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。
在.NET下有移植的NHibernate.
Hibernate是一个开放源代码的对象关系映射框架。
对JDBC进行了非常轻量级的对象封装，使Java程序员可以随心所欲地使用对象编程思维来操纵数据库，
Hibernate持久化对象是基于简单的Java对象（Plain Old Java Objects）以及Java对象集合。
Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP
的Web应用中使用，最具有革命意义的是，Hibernate可以应用EJB的J2EE架构中取代CMP，
完成数据库持久化的重任。
注：
不要将持久化层逻辑与视图表现层逻辑或者业务逻辑层混合在一起。
要避免正在JSP等视图表现层组件直接访问数据库，将数据持久代码都放在持久层中，
这样程序更具有柔韧性且可以灵活地改变而不会影响到其他层。
举一个例子来讲：
如果将Hibernate用其他ORM框架（如JDO或IBATIS）来替换，只需要修改持久层，而不需要修改其他层的代码。
Java开源--Web框架Struts
在视图表现层，采用Struts框架构建Java Web应用程序。
Web应用程序不同于传统上的网站，这些网站通常仅提供静态页面，而Web应用程序可以和数据交互，
当用户与系统交互的时候，业务逻辑可以给用户一个用户化的响应。
在Web应用程序发展初期，Web应用程序通常是基于JSP（Java Server Pages）的，
使用JSP编写代码时通常读取数据库、页面设计代码以及控制流程代码都混合在一起
（维护过于复杂，亟待优化，尤其是大型项目）。
MVC（Model-View-Controller）体系结构的出现
Model表示业务逻辑或者是数据库代码，View代表页面设计代码，而Model本质上是一个Servlet，
将客户请求转发到相应的Action类。
Struts是一个为开发基于模型（Model）-视图（View）-控制器（Controller）模式应用框架的开源框架。
Struts提供了什么功能：
1、管理用户的请求，做出相应的响应
2、提供一个流程控制器，委派调用业务逻辑和其他上层处理
3、处理异常
4、装配需要显示的数据模型
5、执行页面验证
下面所提及的虽然Struts会涉及，但是不应该在视图层中出现。在视图层中引入这些代码，后期维护艰难。
6、直接与数据库通信的代码
7、系统的业务逻辑以及验证代码
8、事务处理
Java开源--J2EE框架Spring
spring是一个轻量级的J2EE框架。
核心是一个轻量级容器，实现IOC模式的容器，本身是一个全方位的整合框架，在Spring框架下可实现
对多个子框架的组合。Spring的核心即IoC/DI的容器，可以为设计人员完成各个组件之间的依赖关系的注入，
使组件之间的依赖性减小，提高了组件的重用性，容器特性使组件可以轻易地加入和脱离框架。
Spring的另一个方面使支持AOP，然而AOP框架知识Spring支持的其中一种框架，所以说Spring框架是AOP框架
并不是一种恰当的描述，但是Spring对AOP的支持使人们更加关注于Spring的AOP方面的能力，也成了Spring的
一大特色。
此外，Spring提供了一个自己的MVC Web框架的解决方案，但Spring并不要求程序员一定要使用该MVC Web框架，
而是可以使用自己所熟悉的MVC Web框架与Spring结合，如Struts Webwork等，它们都可以与Spring整合而
成为适合的解决方案。
Spring还提供其他方面的整合，比如持久化方面的整合，JDBC、O/R Mapping工具、事务处理等，Spring自己也做了多方面整合的努力，因此Spring是一个全方位的框架。
最后：
架构采用多层非分布式的结构，除数据库这一层外，可以分为表现层（Presentation Layer）、业务逻辑层（Bussiness Logic Layer）和数据持久层（Persistence Layer），这3层将存在于同一个Web容器中，
作为一个整体提供J2EE服务。
定义良好的接口可以相对隔离每一层的职责，使应用更简单，并且有很好的伸缩性。数据持久层是介于
业务逻辑层和数据库层之间的桥梁，它封装了与数据库层交互的逻辑，利用ORM（对象关系映射）技术可以
完全实现面向对象的逻辑处理。
在Hibernate中为什么需要进行关联映射？有哪几种关联映射。
hibernate为什么关联？不关联你用hibernate怎么操作数据库，怎么把数据库表对象化它内部需要这些映射关系不然无法使用hibernate。
几种映射关系 “凌霜梅花”已经说了
Hibernate 是一个操作数据库的框架,你在查询数据什么的的时候,查的都是实体！这些实体和数据库的列通过Hibernate关联在一起,
为了方便实体之间的操作
这样可以更加方便的操作数据库。
关联映射就是将关系数据库中表的数据映射为java中的对象，以对象的形式表示，这样可以把对数据库的操作转化为对对象的操作。
Hibernate有7中映射关系：
1、单向一对一关联映射
2、 单向多对一关联映射（many-to-one）
3、 单向一对多关联映射（one-to-many）
4、 单向多对多映射（many-to-many）
5、 双向一对一关联映射
6、 双向一对多关联映射（非常重要）
7、 双向多对多关联映射
PS：以上也是我从网上搜的然后总结的，网上很多，自己搜一下，认真看看就知道了
hibernate 关系映射有什么好处
因为数据库是关系数据库，与现在面向对象的软件设计方式格格不入。
hibernate映射关系可以将关系数据库屏蔽在软件设计之外。达到松耦合的效果。
还有hibernate这种映射关系使我们的软件更具有移植性，数据库从mysql变为oracle、db2只需要改配置文件下的翻译器就可以了，而不需要修改程序。
在大数据量的情况下使用关系映射会影响使用性能
hibernate的关系映射主要是对于数据库中表之间的关系。例如：账单表、客户表。账单表与客户表的关系是多对一的关系。用hibernate的关系映射就不必考虑如何在程序中对应了。查找出某个客户的时候，就可以用客户对象点出属于本人的账单信息。
hibernate怎么用注解方式映射
1. 使用Hibernate Annotation来做对象关系映射
1) 添加必须包：
hibernate-jpa-2.0-api-1.0.0.Final.jar
2) 在实体类中添加JPA的标准注解来进行对象关系映射.注解可以添加在属性上，也可以添加在getXxx()方法之上。
a) @Entity 映射一个实体类
@Table 指定关联的表
b) @Id 映射OID
c) @GeneratedValue 指定OID的生成策略
d) @Version 映射版本号属性
e) @Column 指定属性对应的列的信息
f) @Temporal 指定日期时间的类型(TIMESTAMP,DATE,TIME)
g) 简单属性可以不用注解。默认就是@Basic
h) @Transient 指定属性不需要映射
i) 复杂属性：关联，继承，组件，联合主键，集合
3) 在Hibernate全局配置文件中使用声明映射类的方式：
4) 使用Annotation来映射对象关系时，加载Hibernate全局配置要使用AnnotationConfiguration类
5) 持久化操作与之前没有区别。
2. Hibernate Annotation 基本映射
3. 映射多对一
1) @ManyToOne
2) 指定关联列@JoinColumn(name="xxx_id")
4. 映射一对多
1) @OneToMany 默认会使用连接表做一对多的关联
2) 添加@JoinColumn(name="xxx_id")后，就会使用外键关联，而不使用连接表了。
5. 映射双向一对多
1) 在多端：
@ManyToOne
2) 在一端：
@OneToMany(mappedBy="多端的关联属性名"):----升级后--> @OneToMany
@JoinColumn(name="外键名")
6. cascade属性：指定级联操作的行为(可多选)
CascadeType.PERSIST ：调用JPA规范中的persist()，不适用于Hibernate的save()方法
CascadeType.MERGE：调用JPA规范中merge()时，不适用于Hibernate的update()方法
CascadeType.REMOVE：调用JPA规范中的remove()时，适用于Hibernate的delete()方法
CascadeType.REFRESH：调用JPA规范中的refresh()时，适用于Hibernate的flush()方法
CascadeType.ALL：JPA规范中的所有持久化方法。
7. mappedBy属性：用在双向关联中，把关系的维护权反转
跟hibernate XML映射中的property-ref一样。
8. cascade属性和mappedBy用在一起时，一定要通过调用双方的set方法来建立关系。
10. 双向一对一
1) 基于外键
a) 在主控方：@OneToOne
b) 在被控方：@OneToOne(mappedBy="对方的关联属性名")
2) 基于主键: JPA标准中没有提供共享主键生成问题的标准方法，使用Hibernate的扩展
a) 在主控方：Car
@Id
@GeneratedValue(generator="my-uuid")
@GenericGenerator(name="my-uuid", strategy="uuid")
private String id;
@OneToOne(cascade={CascadeType.ALL})
@PrimaryKeyJoinColumn
private Brand brand;
b) 在被控方：Brand
@Id
@GeneratedValue(generator="myFG")
@GenericGenerator(name="myFG", strategy="foreign",parameters=@Parameter(name="property",value="car"))
private String id;
@OneToOne(mappedBy="brand")
private Car car;
11. 双向多对多
1. 在主控方：
//从学生到课程的多对多: 最好由某一端来维护这个关系会更有效率
@ManyToMany
@JoinTable(name="student_course",
joinColumns={@JoinColumn(name="student_id")},
inverseJoinColumns={@JoinColumn(name="course_id")})
private Set
courseSet = new HashSet
();
2. 在被控方：
//课程到学生的多对多
@ManyToMany(mappedBy="courseSet")
private Set
stus = new HashSet
();
12. 把双向多对多拆成两个一对多: 1-->*<--1
13. 继承映射：
1. 整个继承树一张表
在父类中添加从下注解
@Entity
@Inheritance(strategy=InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name="type",length=3)
@DiscriminatorValue("u")
子类中添加以下注解
@Entity
@DiscriminatorValue("w")
2. 每个子类一张表
在父类添加如下注解
@Entity
@Table(name="user")
@Inheritance(strategy=InheritanceType.JOINED)
在子类中跟普通实体类的映射相同
3. 每个具体类一张表
在父类中
@Entity
@Inheritance(strategy=InheritanceType.TABLE_PER_CLASS)
public class User {
@Id
@GeneratedValue(strategy=GenerationType.TABLE,generator="xxGen")
@TableGenerator(name="xxGen",allocationSize=1)
private Long id;
...
}
在子类中跟普通实体类的映射相同
14. 组件映射
在组件类中用@Emabbedable
在使用这个组件类中用
@Emabbed
@AttributeOverrides({
@AttributeOverride(name="email", column=@Column(name="p_email")),
@AttributeOverride(name="address", column=@Column(name="p_address")),
@AttributeOverride(name="mobile", column=@Column(name="p_mobile"))
})
15. 联合主键映射
1. 主键类：用@Emabbedable映射。并实现Serializable接口，使用主键属性重写hashCode()和equals()方法。
2. 使用这个主键类的类中。用@Id映射。
Hibernate映射文件
student.hbm.xml是对象关系映射文件，它设定数据库表与实体类进行关联，让用户以面向对象的方式去操作持久化类(也就是实体bean)，而不再是操作数据库表，免去了用户频繁书写sql语句的麻烦
就是一个关系映射文件，如下面的user.hbm.xml文件
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
目的和你在数据库中创建表是一样的
最好改成注解形式的，在实体里边加注解，出错好调
Hibernate的持久化类和关系数据库之间的映射通常是用一个XML文档来定义的。
该文档通过一系列XML元素的配置，来将持久化类与数据库表之间建立起一一映射，这意味着映射文档是按照持久化类的定义来创建的，而不是表的定义。
默认情况下，Hibernate会使用属性的get/set方法对，如果指明access="field"，则Hibernate会忽略get/set方法对，直接使用反射来访问成员变量。
formula属性是个特别强大的的特征，这些属性应该定义为只读，属性值在装载时计算生成。用一个SQL表达式生成计算的结果，它会在这个实例转载时翻译成一个SQL查询的SELECT子查询语句。
如：
.
hibernate的关联关系映射
Hibernate的关联关系映射
1.单向关联:
a.多对一:
在子表中加入:
<many-to-one
name="address"
column="addressId"
not-null="true"/>
b.一对一:其实就是many-to-one的一种情况.唯一不同的就是关联中的外键字段具有唯一性约束.
在子表中加入:(unique="true")
<many-to-one
name="address"
column="addressId"
unique="true"
not-null="true"/>
或者
在主表加入:
<one-to-one
name="person"
constrained="true"/>
c.一对多:
在主表中加入:
<set
name="addresses">
<key
column="personId"
not-null="true"/>
<one-to-many
class="Address"/>
2.使用连接表的单向关联
a.一对多:通过制定unique="true"，我们可以把多样性从多对多改变为一对多。
在主表中添加:
<set
name="addresses"
table="PersonAddress">
<key
column="personId"/>
<many-to-many
column="addressId"
unique="true"
class="Address"/>
b.多对一:
在子表中添加:
<join
table="PersonAddress"
optional="true">
<key
column="personId"
unique="true"/>
<many-to-one
name="address"
column="addressId"
not-null="true"/>
c.一对一:
在子表中添加:
<join
table="PersonAddress"
optional="true">
<key
column="personId"
unique="true"/>
<many-to-one
name="address"
column="addressId"
not-null="true"
unique="true"/>
d.多对多:
<set
name="addresses"
table="PersonAddress">
<key
column="personId"/>
<many-to-many
column="addressId"
class="Address"/>
3.双向连接:
a.一对多/多对一:
在子表中添加:(子表跟单向的完全相同)
<many-to-one
name="address"
column="addressId"
not-null="true"/>
在主表中添加:(主表比单向多一个inverse="true")
<set
name="people"
inverse="true">
<key
column="addressId"/>
<one-to-many
class="Person"/>
b.一对一:
基于外键关联:
在子表中添加:(子表跟单向的完全相同)
<many-to-one
name="address"
column="addressId"
unique="true"
not-null="true"/>
在主表中添加:(主表比单向不同的是constrained="true"改成property-ref="address")
<one-to-one
name="person"
property-ref="address"/>
或者
基于主键关联的:
在子表中添加:
<one-to-one
name="address"/>
在主表中添加:
<one-to-one
name="person"
constrained="true"/>
4.使用连接表的双向关联:
a.一对多/多对一
在子表中添加:
<set
name="addresses"
table="PersonAddress">
<key
column="personId"/>
<many-to-many
column="addressId"
unique="true"
class="Address"/>
在主表中添加:
<join
table="PersonAddress"
inverse="true"
optional="true">
<key
column="addressId"/>
<many-to-one
name="person"
column="personId"
not-null="true"/>
b.一对一:
在子表中添加:
<join
table="PersonAddress"
optional="true">
<key
column="personId"
unique="true"/>
<many-to-one
name="address"
column="addressId"
not-null="true"
unique="true"/>
在主表中添加:
<join
table="PersonAddress"
optional="true"
inverse="true">
<key
column="addressId"
unique="true"/>
<many-to-one
name="address"
column="personId"
not-null="true"
unique="true"/>
c.多对多:
<set
name="addresses">
<key
column="personId"/>
<many-to-many
column="addressId"
class="Address"/>
<set
name="people"
inverse="true">
<key
column="addressId"/>
<many-to-many
column="personId"
class="Person"/>
</many-to-many
</key
</set
</many-to-many
</key
</set
</many-to-one
</key
</join
</many-to-one
</key
</join
</many-to-one
</key
</join
</many-to-many
</key
</set
</one-to-one
</one-to-one
</one-to-one
</many-to-one
</one-to-many
</key
</set
</many-to-one
</many-to-many
</key
</set
</many-to-one
</key
</join
</many-to-one
</key
</join
</many-to-many
</key
</set
</one-to-many
</key
</set
</one-to-one
</many-to-one
</many-to-one
hibernate 为什么关系映射时两个类，一个建set，一个对方的对象？
这是在建立之间的关系啊， 没有关系，怎么去获取对方？
一对一如果只设置一边 怎么从另外一边获取当前这边？
同理啊。
标题这种是一对多，多对一双向关联
如果是单单的多对一，不需要set，不过要对象
为什么多的那一方~~要建对象，因为多的这方要知道自己属于哪个上级
比如有张表是group，还有张表是user
每个用户要知道自己是属于哪个组
所以要
Group a=new Group();
User b =new User();
User c =new User();
b.setGroup(a);
c.setGroup(a);
这样hibernate就知道，用户b和c的所属的组是a
set就这样理解
组里有哪些成员，所以有了set这个集合，来放这些成员
一对一建两个对象，这也是双向关联，这样，你查询的时候查询一个就知道另一个是什么了
多对多，表实际不存在，但在java中是存在的，这样是为了让程序员更好的编程，思维逻辑更顺
你这有我的set，我那有你的set，