Hibernate继承映射与多态查询

最新推荐文章于 2022-10-12 21:24:37 发布
最新推荐文章于 2022-10-12 21:24:37 发布
阅读量853 收藏
点赞数
分类专栏： Hibernate

一、继承映射：


关系数据库的表之间不存在继承关系，为了把域模型的继承关系映射到数据库中，Hibernate提供了以下三种对继承关系映射的方法：

  • 每个子类一张表
  • 一张表存储继承体系中所有类的信息（该表由继承体系中所有类的属性的并集所映射的字段组成）
  • 公共信息放在父类表中，独有信息放在子类表中，每个子类对应一张表，并且子类表通过外键与父类表关联

以Person类和Person的两个子类Student、Teacher为例：

Person类：

[java] view plain copy
  1. public class Person {  
  2.     private Long id;  
  3.     private String name;  
  4.     //省略set、get方法  
  5. }  

Student类：
[java] view plain copy
  1. public class Student extends Person {  
  2.     private String idCard;  
  3.     //省略set、get方法  
  4. }  

Teacher类：
[java] view plain copy
  1. public class Teacher extends Person {  
  2.     private Integer salary;  
  3.     //省略set、get方法  
  4. }  


1.每个子类一张表：

(1)保存子类对象时，不必为Person写映射文件，只需为两个子类Student和Teacher编写映射文件；但是保存父类对象时需为父类写映射文件。

(2)子类继承于父类的属性id和name会映射到子类表中，两个子类表没有任何参照关系。

具体配置如下：

Student.hbm.xml：

[html] view plain copy
  1. <hibernate-mapping>  
  2.     <class name="bean.Student" table="students" >  
  3.         <!--id和name属性是Student继承于父类Person的属性而不是Student独有的属性  -->  
  4.         <id name="id" column="id" type="long">  
  5.             <generator class="increment">  
  6.             </generator>  
  7.         </id>  
  8.         <property name="name" column="student_name" type="string"></property>  
  9.         <property name="idCard" column="idCard" type="string"></property>  
  10.           
  11.     </class>  
  12. </hibernate-mapping>  

Teacher.hbm.xml：
[html] view plain copy
  1. <hibernate-mapping>  
  2.     <class name="bean.Teacher" table="teachers" >  
  3.         <id name="id" column="id" type="long">  
  4.             <generator class="increment"></generator>  
  5.         </id>  
  6.         <property name="name" column="teacher_name" type="string"></property>  
  7.         <!-- salary是Teacher类独有的属性 -->  
  8.         <property name="salary" column="salary" type="integer"></property>  
  9.     </class>  
  10. </hibernate-mapping>  
将两个映射文件加入到主配置文件中：
[html] view plain copy
  1. <mapping resource="Student.hbm.xml"/>  
  2. <mapping resource="Teacher.hbm.xml"/>  
两表的结构为：


2.用一张表存储继承体系中所有类的信息

(1)子类的信息都存储在这一张表中，表中的字段由所有父类子类的属性的集合映射而成。

(2)表中需要一个字段来标识“这一条记录究竟是属于哪一个子类”

(3)对于某子类没有的属性字段，其子类对象对应的记录的该字段值被填为NULL。

(4)对于这种方式，不需要为子类配置映射文件，只需为父类配置映射文件，因为所有的继承体系的信息都放置在这一张表中。

具体配置如下：

Person.hbm.xml：

[html] view plain copy
  1.     <class name="bean.Person" table="persons" discriminator-value="Person">  
  2.   
  3.         <id name="id" column="id" type="long">  
  4.             <generator class="increment">  
  5.             </generator>  
  6.         </id>  
  7.         <!-- 注意元素的顺序：discriminator要在property的上面 -->  
  8.         <!-- discriminator指定判别类的类型的那一个字段的字段名称及数据类型 -->  
  9.         <discriminator column="Type" type="string"></discriminator>  
  10.         <property name="name" column="name" type="string"></property>  
  11.         <!-- subclass配置Person的子类，其子元素<property>映射子类的属性，所以不需要为子类单独配置映射文件  
  12.              discriminator-value指定用于分辨子类的Type字段值 -->  
  13.         <subclass name="bean.Student" discriminator-value="Student">  
  14.             <property name="idCard" column="idCard" type="string"></property>  
  15.         </subclass>  
  16.         <subclass name="bean.Teacher" discriminator-value="Teacher">  
  17.             <property name="salary" column="salary" type="integer"></property>  
  18.         </subclass>  
  19.     </class>  
  20. </hibernate-mapping>  
（将Person.hbm.xml加入到主配置文件中，并将Student.hbm.xml和Teacher.hbm.xml从主配置文件中移除）

另外要注意元素的配置顺序，如：dsicriminator配置在property下面时就会出错。

persons表的结构如下：

保存对象：

[java] view plain copy
  1. Teacher teacher=new Teacher();  
  2. teacher.setName("teacher");  
  3. teacher.setSalary(10000);  
  4. Student student=new Student();  
  5. student.setIdCard("10020711");  
  6. student.setName("student");  
  7. Person person=new Person();  
  8. person.setName("person");  
  9. session.save(person);  
  10. session.save(teacher);  
  11. session.save(student);  
输出的SQL语句为：
[sql] view plain copy
  1. Hibernate: insert into persons (name, Type, id) values (?, 'Person', ?)  
  2. Hibernate: insert into persons (name, salary, Type, id) values (?, ?, 'Teacher', ?)  
  3. Hibernate: insert into persons (name, idCard, Type, id) values (?, ?, 'Student', ?)  
（可以看出Type字段的值已经确定）

persons表的内容为：

(可以看出某类没有的字段属性值就会被填为NULL，Type字段用于分辨“该记录对应哪个类？“”)


3.公共信息放在父类表中，独有信息放在子类表中，每个子类对应一张表，并且子类表通过外键与父类表关联

(1)与第二种方式相同，只需父类的配置文件Person.hbm.xml

(2)将公共信息即父类中的属性存储在父类表中，将子类的独有的属性存放在子类表中，并且子类表中的主键参照父类表的主键id以便关联父子表获取子类对象中父类属性的值。

(3)与第二种方式配置Person.hbm.xml不同，该方式使用了<joined-subclass元素，如下：

Person.hbm.xml：

[html] view plain copy
  1. <class name="bean.Person" table="persons">  
  2.   
  3.     <id name="id" column="id" type="long">  
  4.         <generator class="increment"></generator>  
  5.     </id>  
  6.     <property name="name" column="name" type="string"></property>  
  7.     <joined-subclass name="bean.Student" table="students">  
  8.         <!-- key元素指定了子类表中的外键（参照父类表的主键id），同时这也是子类表的主键 -->  
  9.         <key column="person_id"></key>  
  10.         <property name="idCard" column="idCard" type="string"></property>  
  11.     </joined-subclass>  
  12.     <joined-subclass name="bean.Teacher" table="teachers">  
  13.         <key column="person_id"></key>  
  14.         <property name="salary" column="salary" type="integer"></property>  
  15.     </joined-subclass>  
  16. </class>  
生成的这三个表的结构及参照关系为：

保存对象后的表的内容为：



二、多态查询：


多态查询指的是在检索当前类时，Hibernate会同时检索当前类的子类，检索结果是当前类及其子类的所有实例。

有网友提出：”get支持多态查询；load只有在lazy=false，才支持多态查询；HQL支持多态查询“

以及提出禁用多态查询的方式：将<class>的属性polymorphism改为"explicit"（默认为implicit）

下面我针对上述的三种继承映射的方式编码实分别验证：

保存对象：

[java] view plain copy
  1. Teacher teacher=new Teacher();  
  2. teacher.setName("teacher");  
  3. teacher.setSalary(10000);  
  4. Student student=new Student();  
  5. student.setIdCard("10020711");  
  6. student.setName("student");  
  7. Person person=new Person();  
  8. person.setName("person");  
  9. session.save(person);  
  10. session.save(teacher);  
  11. session.save(student);  

(1)第一种继承映射方式，即子类各一张表，父类也单独存取在一张表中，且各表之间无任何参照关系，所以当使用get或load查询父类的实例时当然会到父类表中查询了，由于get、load的参数需要id且它们都只返回一个Object，所以这种情况下就不支持多态查询了。

——HQL：支持多态查旬，将父类映射文件（即Person.hbm.xml）的<class>的属性polymorphism改为"explicit"可以“禁用多态查询”。

测试代码：

[java] view plain copy
  1.  Query query=session.createQuery("from Person");  
  2.  List list = query.list();  
  3.            
  4. for (int i = 0; i < list.size(); i++) {  
  5.     Object object = list.get(i);  
  6.     if (object instanceof Student) {  
  7.         Student s = (Student) object;  
  8.         System.out.println(s.getName() + ":" + s.getIdCard());  
  9.     } else if (object instanceof Teacher) {  
  10.         Teacher t = (Teacher) object;  
  11.         System.out.println(t.getName() + ":" + t.getSalary());  
  12.     }else System.out.println("Person");  
  13. }  

(2)第二种方式的继承映射：所有继承体系的信息都存储在一张表中：

——get方法：支持多态查询，但是将<class>的属性polymorphism改为"explicit"不能“禁用多态查询”。

——load方法：将<class>中的lazy属性值改为false后支持多态查询，但是将<class>的属性polymorphism改为"explicit"不能“禁用多态查询”。

——HQL：支持多态查旬，但是将<class>的属性polymorphism改为"explicit"不能“禁用多态查询”。

测试代码：

[java] view plain copy
  1.              Query query=session.createQuery("from Person");//测试HQL  
  2.              List list = query.list();  
  3.               
  4.             for (int i = 0; i < list.size(); i++) {  
  5.                 Object object = list.get(i);  
  6.                 if (object instanceof Student) {  
  7.                     Student s = (Student) object;  
  8.                     System.out.println(s.getName() + ":" + s.getIdCard());  
  9.                 } else if (object instanceof Teacher) {  
  10.                     Teacher t = (Teacher) object;  
  11.                     System.out.println(t.getName() + ":" + t.getSalary());  
  12.                 }else System.out.println("Person");  
  13.             }  
  14. //          Person p=(Person)session.get(Person.class, 2L);//测试get  
  15. //          Person p=(Person)session.load(Person.class, 2L);//测试load  
  16. //          System.out.println(p.getName());  
  17. //          if(p instanceof Teacher)  
  18. //          {  
  19. //              Teacher t=(Teacher)p;  
  20. //              System.out.println(t.getSalary());  
  21. //          }else if(p instanceof Student)  
  22. //          {  
  23. //              Student s=(Student)p;  
  24. //              System.out.println(s.getIdCard());  
  25. //          }else  
  26. //              System.out.println("person");  


(3)第三种方式的继承映射：公共信息放在父类表中，子类独有的属性放在子类表中，且通过外键与父类表关联

——get方法：支持多态查询，但是将<class>的属性polymorphism改为"explicit"不能“禁用多态查询”。

——load方法：将<class>中的lazy属性值改为false后支持多态查询，但是将<class>的属性polymorphism改为"explicit"不能“禁用多态查询”。

——HQL：支持多态查旬，但是将<class>的属性polymorphism改为"explicit"不能“禁用多态查询”。

测试代码：

[java] view plain copy
  1.              Query query=session.createQuery("from Person");//测试HQL  
  2.              List list = query.list();  
  3.               
  4.             for (int i = 0; i < list.size(); i++) {  
  5.                 Object object = list.get(i);  
  6.                 if (object instanceof Student) {  
  7.                     Student s = (Student) object;  
  8.                     System.out.println(s.getName() + ":" + s.getIdCard());  
  9.                 } else if (object instanceof Teacher) {  
  10.                     Teacher t = (Teacher) object;  
  11.                     System.out.println(t.getName() + ":" + t.getSalary());  
  12.                 }else System.out.println("Person");  
  13.             }  
  14. //          Person p=(Person)session.get(Person.class, 2L);//测试get  
  15. //          Person p=(Person)session.load(Person.class, 2L);//测试load  
  16. //          System.out.println(p.getName());  
  17. //          if(p instanceof Teacher)  
  18. //          {  
  19. //              Teacher t=(Teacher)p;  
  20. //              System.out.println(t.getSalary());  
  21. //          }else if(p instanceof Student)  
  22. //          {  
  23. //              Student s=(Student)p;  
  24. //              System.out.println(s.getIdCard());  
  25. //          }else  
  26. //              System.out.println("person");  

（如验证的不正确，请指正）


通过HQL查询表中所有的实体对象

    * HQL语句：session.createQuery("from java.lang.Object").list();

    * 因为所有对象都是继承Object类


转载请注明出处：http://blog.csdn.net/jialinqiang/article/details
openBlog
关注
专栏目录
Hibernate：继承映射之单表继承及多态查询的应用
SirouW的博客
09-05 364
单表继承的配置、原理以及应用，利用动态查询获取表中的数据
【Hibernate步步为营】--继承映射详解
热门推荐
航帆远洋
05-30 1万+
继承是面向对象很重要的特性，它实现了代码的服用，在关系模型中同样也有继承关系，这种继承关系其实可以看做是一种枚举关系，一种类型中可以枚举出很多子类型，这些子类型和父对象形成了继承关系，能够对其进行枚举的大部分都可以看做是一种继承映射，所以这种枚举关系可以看做是继承映射，
Hibernate继承、多态查询（五）
漂流幻境
04-19 1221
继承映射、多态查询   通过hibernate如何实现继承，有三种方式：    1）：每个子类一张表。每个子类对应一个hbm.xml文件，但是父类没有对应的hbm.xml文件。 Public class Parent implements Serilizable{ 　　　Private Long id;//主键 　　　Private String name; ...sette
【Hibernate】继承映射的支持多态查询
北漂的IT小白菜
02-07 662
在查询的时候都通常知道要使用get或者是load，但是对于有继承关系的对象该如何查询呢？大体上和常规一样，但是有细微的差别，体现在多态查询上面。       首先来个最简单的，就是使用get直接查询实体，get支持多态查询。我也就不多说。       需要跟大家说的是使用load查询的时候，只有当父类animal的lazy设置成false的时候才能支持多态查询，否则load查询出来的只是一个代
【Hibernate 5】继承映射配置及多态查询
该怎么解释？我懒得解释
07-09 1363
一、继承实现的三种策略 1.1，单表继承。每棵类继承树使用一个表(table per class hierarchy) ——>本文主要介绍的继承策略 类继承树对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤： 1，父类用普通的标签定义，在父类中
hibernate的多态查询
03-28
标题“hibernate的多态查询”指的是在Hibernate框架中，如何进行涉及不同子类的对象查询，这是ORM（对象关系映射）中的一个重要特性，旨在提高代码的灵活性和可扩展性。多态查询允许我们编写一次查询，而无需关心...
Hibernate继承映射(annotation)
04-22
**标题：“Hibernate继承映射(Annotation)详解”** 在Java持久化框架Hibernate中，继承映射是一种关键特性，它允许开发者将对象模型的继承结构映射到数据库的表结构。在传统的面向对象编程中，继承是实现代码复用和...
hibernate 表映射查询指定列_Hibernate之继承关系与多态查询
weixin_27210125的博客
12-27 215
我们知道在面向对象的Java语言的世界里，对象的组织是有继承和组合两种形式的。当面向对象的概念映射到关系型数据库时，有着这样的对应，类对应了表，对象对应了表行记录，对象属性对应了表列，对象的组合关系对应的是表之间的连接。但是关系型数据库并不能直接表示“继承”这种关系。想要对象继承在关系型数据库中表达出来，不难看有三种表达方法。父类单表模式，父类整棵对象继承树的所有属性共用一个表，表会有父类重复冗余...
Hibernate深入学习(二)：继承与多态查询-subclass
我要做的就是比昨天的我更强
06-22 4211
关于继承和多态查询，由于篇幅过长，将会放到两篇文章目前有一个Person类，Worker继承自Person，并添加了2个属性，省略setter和getter 具体如下：public class Person { private Integer id; private String name; private Integer age;} public class Worker
继承关系_整个继承树映射到一张表_每个类映射到一张表_鉴别器与内连接相结合(混合)_每个具体类映射一张独立表
dwt1220
02-09 804
整个继承树映射到一张表_每个类映射到一张表_鉴别器与内连接相结合(混合)_每个具体类映射一张独立表  整个继承树映射到一张表 描述： 在父类的配置文件中 1、添加鉴别器标签 column="type"给Hibernate使用，type属性设置column的类型，默认String 2、配置子类    name="类名"  discriminator-value="类对应的鉴别字段的数值
Java Web之Hibernate的高级应用(数据库实体关联之间的映射规则、实体继承关系映射、Hibernate查询语言)
最新发布
showswoller的博客
10-12 963
Java Web之Hibernate的高级应用(数据库实体关联之间的映射规则、实体继承关系映射、Hibernate查询语言) 包括对HQL的讲解等等
(8)hibernate四种继承映射
jianfpeng241241的专栏
11-20 955
一 一个类继承体系一张表 二 每个子类不同的部分用一张表 三 继承关系与内连接结合 四 每个具体类一张表
Hibernate的HQL查询
继承接口的博客
10-17 267
HQL查询所有 @Test public void testSelectHQL01(){ Session session = null; Transaction transaction = null; try { //1.：使用SessionFactory创建Session对象 //理解：类
hibernate映射 【映射继承关系】，初学例子六
想飞的鱼
06-11 815
Hibernate处理继承，如公司与员工存在一对多关系，对应的继承关系如图所思：hibernate处理：（1）继承关系树的每一个具体类对应一个表，所以有三个表，一个公司表，一个小时员工表，一个薪水员工表公司表对应的配置文件：小时员工对应的配置文件
Hibernate多对多关联映射和继承映射
致力于顶级java全栈工程师
01-12 948
多对多关联映射 1、多对多单向关联映射：     如同一般的数据库设计，多对多的关系需要一个第三方表来维护关系，Hibernate中的映射关系也一样，需要一个中间表一样来维护关系，Hibernate会自动生成中间表。使用标签来表示多对多的关联，采用集合的方式来映射字段。    单向关联的映射如下图所示：     用户User类：在User类中持有对Role的引用，采用Set集合
Hibernate"discriminator-value"用法
weixin_33779515的博客
12-22 274
转自：https://blog.csdn.net/iteye_3357/article/details/81862615     1 可能经常遇到这样的情况： 2 3 在数据库表中会有这样的一个字段用来区别记录的属性，如：在客户表中有一个字段表示客户级别，当这个记录为A时是一级客户，为B时是二级客户。在用hiberante做OR表示时类可能是这样的： 4 5 ...
hibernate-mapping-3.0.dtd
kaqi
01-11 498
&lt;!-- Hibernate Mapping DTD. &lt;!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"&gt; An instanc...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值