Hibernate实体关联关系映射

柔情只为你懂 2022-05-16 23:20 331阅读 0赞

一、什么是Hibernate中的关联映射？

　　简单来说Hibernate是ORM映射的持久层框架，全称是（Object Relational Mapping），即对象关系映射。

　　它将数据库中的表映射成对应的对象，以对象的形式展现，这样我们就可以通过映射的对象来对数据库中的数据进行间接的操作。

　　关联映射是将数据库中的表映射成与之相对应的对象，当你对这个对象进行操作的时候，Hibernate会对数据库中对应的表执行相应的操作，你对该实体的操作实际上就是在间接的操作数据库中与之相对应的表。

　　Hibernate正是实现了这种思想，达到了方便开发人员以面向对象的思想来实现对数据库的操作。

二、Hibernate主要实现的映射关系：

　　　　　　　　1068913-20161126130657253-1188602387.png

三、Hibernate映射的基本结构

　　 hibernate在实现ORM功能的时候主要用到的文件有：映射类（*.Java）、映射文件（*.hbm.xml）和数据库配置文件（*.properties/*.cfg.xml），它们各自的作用如下。

映射类（*.java）：它是描述数据库表的结构，表中的字段在类中被描述成属性，将来就可以实现把表中的记录映射成为该类的对象了。

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

数据库配置文件（*.properties/*.cfg.xml）：它是指定与数据库连接时需要的连接信息，比如连接哪种数据库、登录数据库的用户名、登录密码以及连接字符串等。当然还可以把映射类的地址映射信息放在这里。

四、hibernate中的关联关系有四种：一对一、一对多、多对一、多对多。

1、单向关联与双向关联

　单向关联：单向关联是指只有一方有另一方的关联信息而另一方没有关联信息 　　

　　例：

　　　　A——>B

　　　　A对象中有B对象的关联信息

　　　　B对象中没有A对象的关联信息

　　　　我们可以通过A对象中B的关联信息查询或修改B对象的信息但无法通过B对象来查询修改A对象的信息

　双向关联：双向关联是指两方都有另一方的关联信息

　　例：

　　　　A<——>B

　　　　A对象中有B对象的关联信息

　　　　B对象中也有A对象的关联信息

　　　　我们可以通过A对象中B的关联信息查询或修改B对象的信息也可以通过B对象来查询修改A对象的信息

单向关联一般在一方配置多方不进行配置

　　如：一对多 单向关联在“一”的一方配置文件里进行配置,”多”的一方不进行配置

双向关联两方都要配置

　　如：一对多 双向关联在“一”的一方配置文件里需要配置，“多”的一方也需要进行配置

2、一对一关联映射

　　一对一关联：一对一是指一个对象对应一个对象 如：一个人只有一个身份证。

　　在两个数据表之间的一对一关系可以有两种实现方法，其中一种就是通过两个表的主键相关联，另一种是通过外键相关联

　　　　如：一个人（Person）对应一个地址（Address）代码如下。

　（1）一对一主键单向关联：　

　　　　Person——>Address

  1. public class Person {
  2.     private int personid;
  3.     private String name;
  4.     private int age;
  5.     //在Person对象中有Address对象的关联信息
  6.     private Address address;
  8. public class Address{
  9.     //Address对象中没有Person对象的关联信息
  10.     private int addressid;
  11.     private String addressdetail;

这种单方面有另一个对象的关联信息的时候我们称为单向关联,再来看一下两个表中的映射hbm.xml文件:

Person.hbm.xml 

  1. <hibernate-mapping>
  2.     <class name="com.entity.Person" table="PERSON">
  3.         <id name="personid" column="presonid">
  4.             <!--基于主键关联时，主键生成策略是foreign，表明根据关联类生成主键-->
  5.             <generator class="foreign">
  6.                 <!--关联持久化类的属性名-->
  7.                 <param name="property">address</param>
  8.             </generator>
  9.         </id>
  10.         <property name="name"/>
  11.         <property name="age"/>
  12.         <!--constrained设定为true，表示的主键必须与Person中对应资料的主键相同。-->
  13.         <one-to-one name="address" constrained="true"/>
  14.     </class>
  15. </hibernate-mapping>

单向关联和双向关联的区别主要在于单向只在一方配置而双向两方都要配置

Address.hbm.xml

因为是单方面关联所以只在Person.hbm.xml中配置了关联信息而Address.hbm.xml中不做任何配置

所以我们省略Address.hbm.xml

　　…………

　

（2）一对一主键双向关联：

　　Person<——>Address

  1. public class Person implements java.io.Serializable { 
  3.   private Long id; 
  4.   private String name; 
  5.   //双向关联中Person对象中有Adderss对象的关联信息  
  6.   private Address address;
  8. public class Address implements java.io.Serializable { 
  9.   private Long id; 
  10.   //Adderss对象中也有Person对象的关联信息  
  11.   private Person person; 
  12.   private String detail;

这种两方面都有另一个对象的关联信息的时候我们称为双向关联,再来看一下两个表中的映射hbm.xml文件:

Person.hbm.xml

  1. <hibernate-mapping> 
  2.   <class name="entity.Person" table="person"> 
  3.     <id name="id" type="java.lang.Long"> 
  4.       <column name="id" /> 
  5.       <generator class="identity" /> 
  6.     </id> 
  7.     <property name="name" type="java.lang.String"> 
  8.       <column name="name" length="24" not-null="true"> 
  9.         <comment>姓名</comment> 
  10.       </column> 
  11.     </property> 
  12.     <one-to-one name="address"/> 
  13.   </class> 
  14. </hibernate-mapping>

单向关联和双向关联的区别主要在于单向只在一方配置而双向两方都要配置

Address.hbm.xml

  1. <hibernate-mapping> 
  2.   <class name="entity.Address" table="address" catalog="mydb"> 
  3.     <id name="id" type="java.lang.Long"> 
  4.       <column name="id" /> 
  5.       <!-- class="foreign": 一对一主键映射中，使用另外一个相关联的对象的标识符 --> 
  6.       <generator class="foreign"> 
  7.         <param name="property">person</param> 
  8.       </generator> 
  9.     </id> 
  10.     <property name="detail" type="java.lang.String"> 
  11.       <column name="detail" length="120" not-null="true"> 
  12.         <comment>详细地址</comment> 
  13.       </column> 
  14.     </property> 
  15.     <!-- 表示在address表存在一个外键约束，外键参考相关联的表person --> 
  16.     <one-to-one name="person" constrained="true" /> 
  17.   </class> 
  18. </hibernate-mapping>

当我们操作Person对象时，可以对Address对象进行操作，也可以操作Address对象时对Person对象进行操作这样就形成了双向的关联

双向关联还需要在hibernate.cfg.xml中进行配置

  1. <hibernate-configuration> 
  3.   <session-factory> 
  4.     <property name="connection.username">root</property> 
  5.     <property name="connection.url"> 
  6.       jdbc:mysql://localhost:3306/testdb 
  7.     </property> 
  8.     <property name="dialect"> 
  9.       org.hibernate.dialect.MySQLDialect 
  10.     </property> 
  11.     <property name="connection.password">xiaohui</property> 
  12.     <property name="connection.driver_class"> 
  13.       com.mysql.jdbc.Driver 
  14.     </property> 
  15.     <property name="show_sql">true</property> 
  16.     <property name="format_sql">true</property> 
  18. 　　 <!--在hibernate.cfg.xml中配置hbm.xml文件-->
  19.     <mapping resource="com/entity/Person.hbm.xml" /> 
  20.     <mapping resource="com/entity/Address.hbm.xml" /> 
  22.   </session-factory> 
  24. </hibernate-configuration>

（3）一对一外键单向关联：

　　Person——>Address

  1. public class Person {
  2.     private int personid;
  3.     private String name;
  4.     private int age;
  5.     private Address address;
  7. public class Address{
  8.     private int addressid;
  9.     private String addressdetail;

Address.hbm.xml

  1. <!--address中不做任何配置所以我们省略-->
  3. 　　…………………………
  5. <!--单向关联和双向关联的区别在于单向关联只在一方配置双向关联两方都要配置-->
  6. Person.hbm.xml
  7. <hibernate-mapping> 
  8.         <class name="com.entity.Person" table="PERSON"> 
  9.                 <id name="personid"> 
  10.                         <generator class="identity"/> 
  11.                 </id> 
  12.                 <property name="name"/> 
  13.                 <property name="age"/> 
  14.                 <!--用来映射关联PO column是Address在该表中的外键列名,增加unique变成唯一的--> 
  15.                 <many-to-one name="address" unique="true"/> 
  16.         </class> 
  17. </hibernate-mapping>

关联和主键关联不同的地方是采用标签来映射，一对一唯一外键关联映射其实是多对一的特例。指定多的一端unique为true，这样就限制了多的一端的多重性为一，就是这样来映射的。

（4）一对一外键双向关联：

　　Person<——>Address

  1. public class Person implements java.io.Serializable { 
  3.   private Long id; 
  4.   private String name; 
  5.   private Address address;
  7. public class Address implements java.io.Serializable { 
  8.   private Long id; 
  9.   private Person person; 
  10.   private String detail;

Person.hbm.xml 

  1. <hibernate-mapping> 
  2.   <class name="com.entity.Person" table="person"> 
  3.     <id name="personid" type="java.lang.Long"> 
  4.       <column name="personid" /> 
  5.       <generator class="identity" /> 
  6.     </id> 
  7.     <property name="name" type="java.lang.String"> 
  8.       <column name="name" length="24" not-null="true"> 
  9.         <comment>姓名</comment> 
  10.       </column> 
  11.     </property> 
  12. 　　<!--双向关联配置-->
  13.     <one-to-one name="address" /> 
  14.   </class> 
  15. </hibernate-mapping>

Address.hbm.xml

  1. <hibernate-mapping> 
  2.   <class name="com.entity.Address" table="address" catalog="testdb"> 
  3.     <id name="addressid" type="java.lang.Long"> 
  4.       <column name="addressid" /> 
  5.       <generator class="identity" /> 
  6.     </id> 
  7.     <property name="detail" type="java.lang.String"> 
  8.       <column name="detail" length="120" not-null="true"> 
  9.         <comment>详细地址</comment> 
  10.       </column> 
  11.     </property> 
  12.     <many-to-one name="person" class="entity.Person" unique="true"> 
  13.       <column name="personid"> 
  14.         <comment>人的ID</comment> 
  15.       </column> 
  16.     </many-to-one> 
  17.   </class> 
  18. </hibernate-mapping>

单向关联和双向关联的区别主要在于单向只在一方配置而双向两方都要配置所以一对一双向关联比单向关联多了一个在Person.hbm.xml文件中配置

双向关联还需要在hibernate.cfg.xml中进行配置

  1. <hibernate-configuration> 
  3.   <session-factory> 
  4.     <property name="connection.username">root</property> 
  5.     <property name="connection.url"> 
  6.       jdbc:mysql://localhost:3306/testdb 
  7.     </property> 
  8.     <property name="dialect"> 
  9.       org.hibernate.dialect.MySQLDialect 
  10.     </property> 
  11.     <property name="connection.password">xiaohui</property> 
  12.     <property name="connection.driver_class"> 
  13.       com.mysql.jdbc.Driver 
  14.     </property> 
  15.     <property name="show_sql">true</property> 
  16.     <property name="format_sql">true</property> 
  18. 　　 <!--在hibernate.cfg.xml中配置hbm.xml文件-->
  19.     <mapping resource="com/entity/Person.hbm.xml" /> 
  20.     <mapping resource="com/entity/Address.hbm.xml" /> 
  22.   </session-factory> 
  24. </hibernate-configuration>

注意：因为一对一的主键关联映射扩展性不好，当我们的需要发生改变想要将其变为一对多的时候变无法操作了，所以我们遇到一对一关联的时候经常会采用唯一外键关联来解决问题，而很少使用一对一主键关联。

3、一对多关联映射

　一对多关联：一对多是指一个对象对应多个对象 同样也分为单向关联和双向关联 如：一个教室可以有多个学生

（1） 一对多单向关联：

　　　Classes——>Student

  1. public class Classes {  
  2.     private int id;  
  3.     private String name;     
  4.     //Set支持延迟加载因为多个学生所以我们用Set集合关联  
  5.     private Set students;  
  6. }  
  7. public class Student {  
  8.     private int id;  
  9.     private String name;      
  10. }

单向关联只需在一方配置hbm.xml文件Student不需要配置所以就省略了

Classes对象中使用了set属性，但是只是说明了延迟加载的属性，并没有为属性配置对应的对象，属性的对象是要在映射文件中来配置的，需要添加set标签，并在set标签中添加标签，具体如下代码：

Classes.hbm.xml

  1. <hibernate-mapping>  
  2.     <class name="com.hibernate.Classes" table="t_classes">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>  
  7.         <set name="students">  
  8.             <key column="classesid"></key>  
  9.             <one-to-many class="com.hibernate.Student"></one-to-many>  
  10.         </set>  
  11.     </class>  
  12. </hibernate-mapping>

因为Classes一方是一方对应的Student是多方 所以我们要用来关联一方

Student.hbm.xml不做任何改变

　　省略………………

（2）一对多双向关联：

　　　Classes<——>Student

  1. public class Classes {  
  2.     private int id;  
  3.     private String name;     
  4.     //Set支持延迟加载  
  5.     private Set<Student> students;  
  6. }  
  7. public class Student {  
  8.     private int id;  
  9.     private String name; 
  10.     //添加class对象关联信息因为是一方所以我们用一个对象关联
  11.     private Classes classes;     
  12. }

Classes.hbm.xml

　　因为与单向一对多配置一样所以就省略了 可以参考上面单向一对多的代码

Student.hbm.xml

双向我们需要两方都要配置代码如下：

  1. <hibernate-mapping>  
  2.     <class name="com.hibernate.Student" table="t_student">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>  
  7.         <!-- 在多的一端Student中添加一行新的Classes列 ,并且列的名称要和Classes.hbm.xml的列明相同-->  
  8.         <many-to-one name="classes" column="classesid"></many-to-one>  
  9.     </class>  
  10. </hibernate-mapping>

因为Student一方是多方对应的Classes是一方 所以我们要用来关联一方

4、多对多关联映射

　**多对多关联**：多对多关联是指多个对象对应多个对象 如：老师可以有多个学生，学生也可以有多个老师

（1）多对多单向关联：

　　　Teacher——>Student

  1. public class Teacher {
  2.     private int id;
  3.     private String name;
  4.     private Set<Student> students = new HashSet<Student>();
  5. ｝
  7. public class Student {
  8.     private int id;
  9.     private String name;
  10.     private String title;
  11. ｝

Teacher.hbm.xml

  1. <hibernate-mapping>  
  2.     <class name="com.hibernate.Teacher" table="t_teacher">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>  
  7. 　　　　　<!--生成一张新表存放两个关联对象的ID-->
  8.         <set name="students" table="Teacher_Sutdent">  
  9. 　　　　　　　<!--将Teacher表的外键关联 注意不是对象的属性是表中的字段-->
  10.             <key column="teacher_id"></key>  
  11. 　　　　　　　<!--将Student表的外键关联 注意不是对象的属性是表中的字段--> 
  12. 　　　　　　　<many-to-many class="com.hibernate.Student" column="student_id"></many-to-many> 
  13. 　　　　  </set> 
  14. 　　　</class> 
  15. </hibernate-mapping>

文件中要使用标签，并且在标签中添加上对应的列关系，因为你要让两个对象中都要清楚它们之间的映射是如何使用的，并且在生成的关系表中哪一列是对应的自己的外键，所以要在该标签中指明，另外在标签中添加table属性会指明要生成新表，下面的示例中添加了t_user_role，所以会生成新的关联表。　

Student.hbm.xml不做任何配置所以省略

　　…………

（2）多对多双向关联：

　　Teacher<——>Student

  1. public class Teacher {
  2.     private int id;
  3.     private String name;
  4.     private Set<Student> students = new HashSet<Student>();
  5. ｝
  7. public class Student {
  8.     private int id;
  9.     private String name;
  10.     private String title;
  11.     private Set<Teacher> teachers = new HashSet<Teacher>();
  12. ｝

Teacher.hbm.xml同单向多对多一样故省略

　　…………

Student.hbm.xml

  1. <hibernate-mapping>  
  2.     <class name="com.hibernate.Student" table="t_student">  
  3.         <id name="id">  
  4.             <generator class="native"/>  
  5.         </id>  
  6.         <property name="name"/>  
  7. 　　　　　<!--生成一张新表存放两个表的Id-->
  8.         <set name="teachers" table="Teacher_Student">  
  9. 　　　　　　　<!--将Teacher表的外键关联 注意不是对象的属性是表中的字段-->
  10.             <key column="student_id"></key>  
  11. 　　　　　　　<!--将Student表的外键关联 注意不是对象的属性是表中的字段--> 
  12. 　　　　　　　<many-to-many class="com.hibernate.Teacher" column="teacher_id"></many-to-many> 
  13. 　　　　  </set> 
  14. 　　　</class> 
  15. </hibernate-mapping>

5、多对一关联

　　 对比一对一关联映射和多对一唯一外键关联映射，其实它们两个都是使用了本质上都是外键约束，只不过一对一的是唯一映射，需要添加unique=”true”的属性，其它的它们两个是相同的。

　　多对一关联：多对一关联是指多个对象对应一个对象 如：多个员工对应一个部门

（1）多对一单向关联：

  1. public class Department {  
  2.     private int id;  
  3.     private String name;  
  4. }  
  6. public class Employee {  
  7.     private int id;  
  8.     private String name;  
  9.     private Department depart;//注意这里是以部门的对象来作为员工的属性的，这个思想很关键，是建立起部门和员工关联的关键  
  11. }

Department.hbm.xml不做任何配置故省略　　

　　…………　　　　

Employee.hbm.xml

  1. <hibernate-mapping package="com.suo.domain">  
  3.     <class name="Employee">  
  4.         <id name="id">  
  5.             <generator class="native"/>  
  6.         </id>  
  7.         <property name="name"/>  
  8.         <many-to-one name="depart"></many-to-one>  
  9.         <!-- many-to-one指明了外键 ，会根据反射机制，找到要和Employee建立多对一关系的类，该列默认的是可以为空的-->  
  10.     </class>  
  12. </hibernate-mapping>

（2）多对一双向关联：

  1. public class Department {  
  2.     private int id;  
  3.     private String name;
  4.     private Set<Employee> emps;//用集合来存储员工     
  5. }  
  7. public class Employee {  
  8.     private int id;  
  9.     private String name;  
  10.     private Department depart;//注意这里是以部门的对象来作为员工的属性的，这个思想很关键，是建立起部门和员工关联的关键  
  12. }

Departement .hbm.xml

  1. <hibernate-mapping package="com.suo.domain">  
  3.     <class name="Department">  
  4.         <id name="id">  
  5.             <generator class="native"/>  
  6.         </id>  
  7.         <property name="name"/>  
  9.         <set name="emps">  
  10.             <key column="depart_id"/><!-- key指明了员工表中的外键-->  
  11.             <one-to-many class="Employee"/><!-- one-to-many指明了和哪个类进行一对多的映射 -->  
  12.         </set>  
  13.         <!--   
  14.             用set标签表示Department中的员工集合的属性，这个属性并没有映射到数据库中的部门表中，  
  15.             即部门表中，并没有emps这样的一个列。  
  16.          -->  
  17.     </class>  
  19. </hibernate-mapping>

Employee.hbm.xml同单向关联配置相同故省略

　　…………

五、 级联操作 Cascade：

1、简单的介绍

cascade和inverse (Employee – Department)

l Casade用来说明当对主对象进行某种操作时是否对其关联的从对象也作类似的操作，常用的cascade:

  1.      none,all,save-update,delete, lock,refresh,evict,replicate,persist,
  3.      merge,delete-orphan(one-to-many)。

　　　一般对many-to-one,many-to-many不设置级联，

　　 在和中设置级联。

l inverse表“是否放弃维护关联关系”(在Java里两个对象产生关联时，对数据库表的影响)，在one-to-many和many-to-many的集合定义中使用，inverse=”true”表示该对象不维护关联关系；

　　　该属性的值一般在使用有序集合时设置成false（注意hibernate的缺省值是false）。

  1.      one-to-many维护关联关系就是更新外键。many-to-many维护关联关系就是在中间表增减记录。
  3.      注: 配置成one-to-one的对象不维护关联关系

2、属性的解析
class元素的lazy属性设定为true，表示延迟加载，如果lazy设为false，则表示立即加载。以下对这二点进行说明。
立即加载：表示Hibernate在从数据库中取得数据组装好一个对象(如学生1)后， 会立即再从数据库取得数据组装此对象所关联的对象(如学生证1)。
延迟加载：表示Hibernate在从数据库中取得数据组装好一个对象(如学生1)后，不会立即再从数据库中取得数据组装此对象所关联的对象(如学生1)，而是等到需要时，才会从数据库取得数据组装此关联对象。

元素的cascade属性表明操作是否从父对象级联到被关联的对象，

它的取得可以是以下几种：

  1.  none：在保存，删除或修改当前对象时，不对其附属对象（关联对象）进行级联操作。它是默认值。  
  2.  save-update：在保存，更新当前对象时，级联保存，更新附属对象(临时对象，游离对象)。  
  3.  delete：在删除当前对象时，级联删除附属对象。  
  4.  all：所有情况下均进行级联操作，即包含save-update和delete操作。  
  5.  delete-orphan：删除和当前对象解除关系的附属对象。

元素的fetch属性的可选值是join和select，默认是select。当fetch属性设定为join时，表示连接抓取(Join fetching)：Hibernate通过在Select语句中使用outer join(外连接)来获得对象的关联实例或者关联集合。

　　当fetch属性设定为select时，表示查询抓取(Select fetching)：需要另外发送一条Select语句抓取当前对象的关联实体或集合。

3、代码练习


六、总结：

1、单向关联

　　(1)、一对一主键关联：单向关联时我们需要在有关联信息一方的配置文件里加入并且将constrained属性设置为true 表示的主键必须与这个对象中对应资料的主键相同

　　(2)、一对一外键关联：单向关联时我们需要在有关联信息一方的配置文件里加入并且将unique属性设置为true 表示这个主键是唯一的

　　(3)、一对多单向关联：单向关联时我们需要在有关联信息一方的配置文件里加入在中加入

　　　　　　　　

　　　　　　　　　

　　　　　　　　　

　　　　　　

　　(4)、多对多单向关联：单向关联时我们需要在有关联信息一方的配置文件里加入在中加入

　　　　　　

　　　　　　　　　　

　　　　　　　　　　

　　　　　　

　　(5)、多对一单向关联：单向关联时我们需要在有关联信息一方的配置文件里加入

2、双向关联

　　(2)、一对一主键关联：在从表的一方加入还需要在主表加入

　　(2)、一对一外键关联：除了在从表中加入也需要在主表加入

　　(3)、一对多双向关联：除了在一方中加入还需要在多放加入

　　(4)、多对多双向关联：需要在两方都加入 注：中的table=”表名” 表明两方的配置要一样

　　　　　　　

　　　　　　　　　

　　　　　　　　　

　　　　　　　

　 (5)、多对一双向关联：要在多方中加入还要在一方中加入

　　　　　　　　　　　　

　　　　　　　　　　　　　　　

　　　　　　　　　　　　　　　

　　　　　　　　　　　　

发表评论

表情：
评论列表 （有 0 条评论，331人围观）

还没有评论，来说两句吧...

相关阅读

    相关 Hibernate 03-配置关联关系映射

    一、了解关联关系 类与类之间最普遍的关系就是关联关系，并且关联是有方向的。以部门（Dept）和员工（Emp）类为例，一个部门下有多个员工，而一个员工只能属于一个部门

    朱雀朱雀/ 0 赞/ 332 阅读