【Hibernate】Hibernate系列（一）

【概念】

Hibernate是一个持久化的框架，它对JDBC进行了轻量级的封装。对于源程序来说没有侵入性。能让我们通过操作实体关系模型来操作数据库。大大减轻了sql语句的书写，事务的处理，查询结果的管理等数据库操作。下面是一张hibernate的基本知识点的框架。总体来说hibernate还是比较好学习的，但是需要深入和优化性能还是需要仔细的研究。

【一对多映射】

一对多三种关系：单向一对多，单向多对一，双向一对多。我这里统称为它一对多。一对多关系是非常重要的关系，也是现实世界中最多的关系。这三个关系对应的是UML中的关联关系，也可以分成聚合和组合。

之所以把一对多分成三种类型，是因为它们站的角度不同。这里就拿学生和班级的关系举例，站在学生的角度看这个关系是多对一，站在班级的角度看是一对多。但是为了更好的使用这个关系，也考虑到实际操作的原因。一般把它们设置成双向一对多。

单向多对一


单向多对一是站在多的角度去看关系的，在本例中就是站在学生的角度去看。首先看这个关系的UML图。

多个学生对应一个班级。这里的关系就是多对一的关系，站在学生的角度看。如果我们只是需要知道学生位于那个班级。这样就只是单向的关系，也就是拿到Student，hibernate会自动的给你抓取到对应的Classes。单向的多对一是由需求产生的。是人为的设定的。这样的关系中，Studnet一端负责维护关系。它的映射原理是在Studnet表的一段加入外键，指向一的一端。

下面看这两个实体对应的配置文件Student.hbm.xml和Classes.hbm.xml

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <classnameclassname="com.lsh.hibernate.Classes" table="t_class">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="name"/>  
  11. </class>  
  12. </hibernate-mapping>  

关系在多的一端维护，就在多的一端配置。

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <classnameclassname="com.lsh.hibernate.Student" table="t_student">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="name"/>  
  11. <many-to-onenamemany-to-onename="student" column="classId"cascade="save-update"/>  
  12. </class>  
  13. </hibernate-mapping>  
  14.    

 

单向一对多


同单向多一对的关系类似，单向一对多关系是同一个实体模型映射的不同关系模型。它是站在班级的角度去看问题的。也就是一的这一端去维护关系。也就是在加载一的时候，Hibernate会自动加载上多的一端数据。他的映射原理和单向一对多是一样的，都是在多的一端加入一个外键，指向一的一端。它的UML图如下，注意箭头的指向不同了。

 

对应的配置文件Student.hbm.xml和Classes.hbm.xml如下：

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <class name="com.lsh.hibernate.Student" table="t_student">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="name"/>  
  11. </class>  
  12. </hibernate-mapping>  

一的一端维护关系

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <class name="com.lsh.hibernate.Classes" table="t_classes">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="name"/>  
  11. <setnamesetname="students">  
  12. <!-- 
  13. <keycolumn="classesid" not-null="true"/> 
  14.  -->  
  15.  <key column="classesid"/>  
  16. <one-to-many class="com.lsh.hibernate.Student"/>  
  17. </set>  
  18. </class>  
  19. </hibernate-mapping>  

 

双向一对多


上
面的两种关系都是单向的，但是在实际应用中，我们往往需要双向的加载。比如我拿到学生想知道他所在的班级，拿到班级想知道班里面有的学生。这样就需要双向
的关系。还有一个很重要的原因就是，单向一对多关系在维护关系的过程中存在很大的缺陷。在插入学生的时候，如果班级不能为空，则学生是插入不了的。还有如
果插入成功，在开始解决班级字段是空的，在事务提交阶段，班级需要更新每一个学生的班级ID，这样会产生大量的Update语句。影响效率。所以一对多关系大多使用双向一对多映射。

双向一对多映射的UML图是这样的。

它是一个双向的关联（这里仅限于对Hibernate使用，和现实关系有不一致的地方）

双向一对多的配置文件Student.hbm.xml和Classes.hbm.xml如下：

 

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <classnameclassname="com.lsh.hibernate.Student" table="t_student">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="name"/>  
  11. <many-to-onenamemany-to-onename="classes" column="classesid"/>  
  12. </class>  
  13. </hibernate-mapping>  
  14.    

 

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <classnameclassname="com.lsh.hibernate.Classes" table="t_classes">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="name"/>  
  11. <setnamesetname="students" inverse="true">  
  12.  <key column="classesid"/>  
  13. <one-to-manyclassone-to-manyclass="com.lsh.hibernate.Student"/>  
  14. </set>  
  15. </class>  
  16. </hibernate-mapping> 

它的映射原理是

  •  在一的一端的集合上采用<key>标签，在多的一端加入一个外键
  •  在多的一端采用<many-to-one>标签

也就是两端都要配置，和上面的两种有所不同。但是需要注意的是

  • <key>标签和<many-to-one>标签加入的字段保持一直，否则会产生数据混乱
  • 在一的一端加上inverse="true"属性，让一的一端不去维护关系，专业就不会发出更新语句。

下面解释一下配置文件中各个标签的意义和用法：

<many-to-one>

通过many-to-one元素,可以定义一种常见的与另一个持久化类的关联。这种关系模型是多对一关联（实际上是一个对象引用－译注）：这个表的一个外键引用目标表的主键字段。

<one-to-many>

一对多关联，定义一个表的外键到另一个表的主键，另一个是多的一端。

<inverse>

inverse的值有两种，“true”和“false”。inverse="false"是默认的值,如果设置为true则表示对象的状态变化不会同步到数据库 ;设置成false则相反;

inverse的作用：在hibernate中是通过inverse的设置来决定是有谁来维护表和表之间的关系的。

需要说明的几点：

1:hibernate中的实体类和我们以前做的实体类不太一样，主要是以前的实体类如果包含其它表的字段，直接加上一个String或者int类型的数据就行。而Hibernate中需要加入的是一个实体类属性字段。但是两者生成的表是一样的。就像上面UML图体现的那样，第一个是Studnet实体类中有一个Classes类型的字段，第二个是Classes中有一个Student类型的集合。第三个是他们双方都有对方的一个引用。

2：一对多关系是比较常用的关系，很多时候都会映射出双向的一对多。

3：学习Hibernate要认真体会里面的实体关系，由此去推出映射关系。这里面用到了很多UML的知识。需要重点研究。

【一对一映射】

单向一对一


单向一对一是站在其中的一端看的，主要是根据需求决定的。单向标明一端持有另一端的引用，而另一端则没有引用。如下UML图：

这里面Student持有Card的引用，在加载Student的时候，Hibernate会自动加载上Card来。它们的hbm配置文件如下：

Student.hbm.xml.负责维护关系

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <classnameclassname="com.lsh.hibernate.Student" table="t_student">  
  7. <idnameidname="id">  
  8. <!--采用foreign生成策略，forgeign会取得关联对象的标识 -->  
  9. <generatorclassgeneratorclass="foreign">  
  10. <!--property只关联对象 -->  
  11. <paramnameparamname="property">card</param>  
  12. </generator>  
  13. </id>  
  14. <propertynamepropertyname="name"/>  
  15. <!--  
  16. one-to-one指示hibernate如何加载其关联对象，默认根据主键加载  
  17. 也就是拿到关系字段值，根据对端的主键来加载关联对象  
  18.    
  19. constrained="true表示，当前主键(person的主键)还是一个外键  
  20. 参照了对端的主键（IdCard的主键），也就是会生成外键约束语句  
  21.  -->  
  22. <one-to-onenameone-to-onename="idCard" constrained="true"/>  
  23. </class>  
  24. </hibernate-mapping>  

Card.hbm.xml不负责维护主键，是一个简单的映射文件。

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <classnameclassname="com.lsh.hibernate.Card" table="t_card">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="school"/>  
  11. </class>  
  12. </hibernate-mapping>  
  13.   

双向一对一


双向一对一是彼此都持有对方的引用，在一端加载的时候，另一端就会自动加载上来。看看双向一对一的UML图

配置文件如下

[html] view plain copy

  1. Student.hbm.xml  
  2. <?xmlversionxmlversion="1.0"?>  
  3. <!DOCTYPEhibernate-mapping PUBLIC  
  4. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  5. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  6. <hibernate-mapping>  
  7. <class name="com.lsh.hibernate.Student" table="t_student">  
  8. <idnameidname="id">  
  9. <!--采用foreign生成策略，forgeign会取得关联对象的标识 -->  
  10. <generatorclassgeneratorclass="foreign">  
  11. <!--property只关联对象 -->  
  12. <param name="property">card</param>  
  13. </generator>  
  14. </id>  
  15. <propertynamepropertyname="name"/>  
  16. <!--  
  17. one-to-one指示hibernate如何加载其关联对象，默认根据主键加载  
  18. 也就是拿到关系字段值，根据对端的主键来加载关联对象  
  19.    
  20. constrained="true表示，当前主键(person的主键)还是一个外键  
  21. 参照了对端的主键（IdCard的主键），也就是会生成外键约束语句  
  22.  -->  
  23. <one-to-one name="card" constrained="true"/>  
  24. </class>  
  25. </hibernate-mapping>  

它和上面的单向的Student.hbm.xml配置一样，这两个不同的是在Card.hbm.xml中使用<one-to-one>标签把它持有的student加载上来。

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <class name="com.lsh.hibernate.Card" table="t_card">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <property name="school"/>  
  11. <one-to-one name="student"/>  
  12. </class>  
  13. </hibernate-mapping>  
  14.    

上面的两种一对一都是采用主键关联的方式，即它们两个表的主键是一样的，student用的表是采用foreign的方式，引用Card的主键。一对一关联还有一种外键关联的方式。它的UML图和双向一对一一样，只是配置文件不一样。

首先看一下它们各自的配置文件。Student.hbml.xml和Card.hbm.xml

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <classnameclassname="com.lsh.hibernate.Student" table="t_student">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="name"/>  
  11. <many-to-onenamemany-to-onename="card" unique="true"/>  
  12. </class>  
  13. </hibernate-mapping>  

 

[html] view plain copy

  1. <?xmlversionxmlversion="1.0"?>  
  2. <!DOCTYPEhibernate-mapping PUBLIC  
  3. "-//Hibernate/HibernateMapping DTD 3.0//EN"  
  4. "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  5. <hibernate-mapping>  
  6. <classnameclassname="com.bjpowernode.hibernate.Card" table="t_card">  
  7. <idnameidname="id">  
  8. <generatorclassgeneratorclass="native"/>  
  9. </id>  
  10. <propertynamepropertyname="school"/>  
  11. <
时间： 2024-04-26 06:45:39

【Hibernate】Hibernate系列（一）的相关文章

纯 hibernate hibernate.cfg.xml 事务 数据库操作 CRUD

import org.hibernate.Session; import org.hibernate.SessionFactory; import org.hibernate.cfg.Configuration; public class test1 { /** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub Student s = new Students;

【SSH系列】---Hibernate的基本映射

       开篇前言       在前面的博文中,小编分别介绍了[SSH系列]-- hibernate基本原理&&入门demo,通过这篇博文,小伙伴们对hibernate已经有了基本的了解,以及hibernate的核心,采用对象化的思维操作关系型数据库.     [SSH系列]-- Hibernate持久化对象的三种状态 ,通过这篇博文的讲解,小伙伴们了解到java对象的生命周期,是从通过new语句创建开始,到不再被任何引用变量引用结束,结束后它占用的内存将被JVM垃圾回收机制收回.在h

【SSH系列】-- hibernate基本原理&amp;amp;&amp;amp;入门demo

      什么是hibernate?      hibernate在英文中是冬眠的意思,当冬季来临,世界万物开始准备冬眠,但是程序猿这种动物好像不冬眠,因为需求变了,要改bug,冬眠,对于对象来说就是持久化.什么叫做持久化呢?持久化,就是把数据(如内存中的对象)保存到可永久保存的存储设备中,比如磁盘,持久化的主要应用就是将内存中的对象存储在数据库中,或者存储在磁盘文件中.xml文件中等等.持久化是将程序数据在持久状态和瞬时状态间转换的机制.JDBC就是一种持久化机制,文件IO也是一种持久化机制

【SSH系列】hibernate映射 -- 一对一双向关联映射

       开篇前言       上篇博文[SSH进阶之路]hibernate映射--一对一单向关联映射,小编介绍了一对一的单向关联映射,单向是指只能从人(Person)这端加载身份证端(IdCard),但是反过来,不能从身份证端加载人得信息.为什么呢,因为对象模型具有方向性,在前面的博文Hibernate基本映射中,小编介绍了单向和双向,所谓的单向就是一段只能加载另一个端,不能反过来:双向就是两端都可以加载另一端,可以这样来理解,单向就是一厢情愿,双向就是两情相悦.ok,那么问题来了,如果我

hibernate系列（五）Session接口方法

Session接口方法主要有save.persist.load.get.update.saveOrUpdat.merge.delete等,这里主要是对我看hibernate书籍的一个实践加总结.  首先是save()方法:  以之前的Customer和Order为例,看下类文件:  ? 1 2 3 4 5 6 7 8 9 public class Customer {       private Long id;     private String name;     private Stri

hibernate系列（一）hibernate入门

最近开始学习hibernate,然后就想把这个学习历程总结下来.还是打算主要分两个过程,第一个过程:学会使用hibernate,第二个过程:做一些源码分析,更加深入的理解.  言归正传,开始入门案例,这里的入门案例不牵扯其他框架,所以一开始学习的时候尽量不要牵扯其他框架,如SpringMVC.如果入门时牵涉其他框架,有时候会搞不清楚hibernate和其他框架的责任机制,本工程虽然搭建的是SpringMVC项目,主要是为后来服务,但是目前几乎用不到:  hibernate有两种配置文件,一种就是

hibernate系列（二）一对多的关联关系

上一篇文章介绍了基本知识后,本篇该介绍下现实中的一对多的关联关系.如Customer和Order,一个Customer可以拥有多个Order,每个Order只属于一个Customer.这样就存在几种表示形式,可以分为单向关联和双向关联.  形式1:Order拥有一个Customer引用,这种属于单向关联  形式2:Customer拥有Order的集合,这种也属于单向关联  形式3:Order拥有一个Customer引用,同时Customer拥有Order集合,这种属于双向关联  先来说说形式1:

【SSH系列】Hibernate映射 -- 一对一单向关联映射

       映射原理       一对一关联映射:两个实体对象之间是一对一的关联映射,即一个对象只能与另外唯一的一个对象相对应.有两种策略可以实现一对一的关联映射:       a.主键关联:即让两个对象具有相同的主键值,以表明她们之间的一一对应的关系:数据库表不会有额外的字段来维护她们之间的关系,仅通过表的主键来关联.       b.唯一外键关联:外键关联,本来适用于多对一的配置,但是如果加上唯一的限制之后,也可以表示一对一关联关系,谈恋爱就是一一对应,一个男朋友对应一个女朋友,如果不是,

【SSH系列】Hibernate映射 -- 多对多关联映射

     映射原理         在数据库学习阶段,我们知道,如果实体和实体之间的关系是多对多,那么我们就抽出来第三张表,第一张表和第二张表的主键作为第三表的联合主键,结合我们的hibernate,多对多关联,无论是单向关联还是双向关联都是通过第三张表,将两个表中的主键放到第三张表中做一个关联,用第三张表来解决可能造成的数据冗余问题.今天这篇博文小编来简单的介绍一下hibernate中的多对多关联映射.        在某些系统中,一个用户可以有多个角色,一个角色也可以有多个用户,so,她们之

【SSH系列】Hibernate映射-- 多对一单向关联映射

      在hibernate中非常重要的就是映射,在前面的博文中,小编简单的介绍了基本映射,基本映射是对一个实体进行映射,关联映射就是处理多个实体之间的关系,将关联关系映射到数据库中,所谓的关联关系在对象模型中有一个或多个引用.这个比较简单,但是基础知识还是需要好好掌握的哦,还有一些关联映射,比如user && group,她们之间的关系是一对多,我们知道一个用户只能属于一个组,但是一个组可以包好N多个用户,所以他们之间的关系就是多对一的关系,接着我们来看他们的对象模型以及关系模式.