Java的Hibernate框架中的继承映射学习教程

一、继承映射
继承是面向对象很重要的特性,它实现了代码的服用,在关系模型中同样也有继承关系,这种继承关系其实可以看做是一种枚举关系,一种类型中可以枚举出很多子类型,这些子类型和父对象形成了继承关系,能够对其进行枚举的大部分都可以看做是一种继承映射,所以这种枚举关系可以看做是继承映射,例如动物就是一种抽象类,它是其它动物猪、猫等的父类,它们之间就是一种继承关系,如下图:

这种继承映射在转化为关系模型后会生成一张表,那么这张表是如何区分这两种类型的呢?用的是关系字段,需要在表中添加类型字段,使用关键字来标明对象的类型。所以上图中的对象模型对应的表结构如下:

在生成表结构时,需要添加对应的字段类型,所以需要在映射文件中添加对应的映射鉴别器,这里就需要使用discriminator-value属性。
1.类文件
类文件中没有需要注意的地方,在编写时注意之间的继承关系即可。
清单一:Animal类代码,只需要添加基本的属性。

package com.src.hibernate; 

public class Animal { 

 //id号
 private int id;
 public int getId() {
 return id;
 }
 public void setId(int id) {
 this.id = id;
 } 

 //名称
 private String name;
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 } 

 //性别
 private boolean sex;
 public boolean isSex() {
 return sex;
 }
 public void setSex(boolean sex) {
 this.sex = sex;
 }
}

清单二:Bird和Pig类,添加基本的属性,并继承Animal类。

package com.src.hibernate;
public class Bird extends Animal { 

 //高度
 private int height;
 public int getHeight() {
 return height;
 }
 public void setHeight(int height) {
 this.height = height;
 } 

} 

package com.src.hibernate;
public class Pig extends Animal { 

 //重量
 private int weight;
 public int getWeight() {
 return weight;
 }
 public void setWeight(int weight) {
 this.weight = weight;
 }
}

2.映射文件
映射文件中需要添加对应的映射,该模型中只需要添加一个映射文件,因为只生成一张表,在映射文件中添加对应的子类映射,使用<subclass>标签,标签中添加鉴别器discriminator-value,该鉴别器属性指明了在数据库中写入数据时指示写入的是何种类型,如下:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.src.hibernate.Animal" table="t_animal">
 <id name="id">
 <generator class="native"/>
 </id>
 <!-- 加入鉴别标签,且必须放在id后面 -->
 <discriminator column="type" />
 <property name="name"/>
 <property name="sex" type="boolean"/> 

 <subclass name="com.src.hibernate.Pig" discriminator-value="P">
 <property name="weight"/>
 </subclass>
 <subclass name="com.src.hibernate.Bird" discriminator-value="B">
 <property name="height"/>
 </subclass>
 </class> 

</hibernate-mapping>

3.分析结果
生成的MySQL数据库表中不仅会添加Animal的基本属性,而且会添加Pig和Bird的属性,因为在映射文件中使用<subclass>写出了所添加的属性,另外还添加了相应的鉴别器属性,所以在数据库中会添加对应的鉴别列,生成的表结构如下图:

二、数据操作

1.写入数据
在进行数据读取和写入操作时需要注意类中的操作使用了

public void testSave(){
 Session session=null;
 try{
 //创建session对象
 session=HibernateUtils.getSession();
 //开启事务
 session.beginTransaction(); 

 Pig pig=new Pig();
 pig.setName("小猪猪");
 pig.setSex(true);
 pig.setWeight(200);
 session.save(pig); 

 Bird bird=new Bird();
 bird.setName("xiaoniaoniao");
 bird.setSex(true);
 bird.setHeight(100);
 session.save(bird); 

 session.getTransaction().commit();
 }catch(Exception e){
 e.printStackTrace();
 session.getTransaction().rollback();
 }finally{
 HibernateUtils.closeSession(session);
 } 

}

2.多态查询--get和hql

基本的查询方法,只需要使用load和get方法即可,这里重点讨论多态查询。多态查询是指Hibernate在加载对象时能够采用instanceof鉴别出其真正的类型的对象即可为多态查询。
Note:多态查询不支持延迟加载,也就是说如果使用load方法,需要在映射文件中将延迟加载设置为false。

3.load延迟加载
load支持延迟加载,在加载对象时其实生成的是对象的代理,所以在使用多态查询时需要在映射文件中将延迟加载设置为false,如下:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
 <class name="com.src.hibernate.Animal" table="t_animal" lazy="false">
 <id name="id">
 <generator class="native"/>
 </id>
 <!-- 加入鉴别标签,且必须放在id后面 -->
 <discriminator column="type" />
 <property name="name"/>
 <property name="sex" type="boolean"/> 

 <subclass name="com.src.hibernate.Pig" discriminator-value="P">
 <property name="weight"/>
 </subclass>
 <subclass name="com.src.hibernate.Bird" discriminator-value="B">
 <property name="height"/>
 </subclass>
 </class>
</hibernate-mapping>

load加载方法,使用load加载该示例中支持多态查询,在配置文件中将延迟加载设置为false,所以这里使用load方法能够加载获得相应的对象类。

public void testLoad(){
 Session session=null;
 try{
 session=HibernateUtils.getSession();
 session.beginTransaction(); 

 Animal ani=(Animal)session.load(Animal.class,1);
 System.out.println(ani.getName());
 //因为load默认支持lazy,所以我们看到的是Animal的代理
 //所以采用了instanceof无法鉴别出真正的类型Pig
 //所以load在此情况下是不支持多态查询的
 if(ani instanceof Pig){
 System.out.println("我是小猪猪!");
 }else{
 System.out.println("我不是小猪猪!");
 }
 session.getTransaction().commit();
 }catch(Exception e){
 e.printStackTrace();
 session.getTransaction().rollback();
 }finally{
 HibernateUtils.closeSession(session);
 }
}

4.hql查询
hql支持多态查询,这主要由于查询出的是一个真正的对象,并不会返回一个代理,所以hql支持多态查询,另外在查询时需要注意查询语句中不要使用表名,而是要使用类名称,Hibernate会根据类名称将其映射为对应的表名称,如下:

public void testLoad5(){
 Session session=null;
 try{
 session=HibernateUtils.getSession();
 session.beginTransaction(); 

 List<Animal> list=session.createQuery("from Animal").list();
 for(Iterator iter=list.iterator();iter.hasNext();){
 Animal a=(Animal)iter.next();
 if(a instanceof Pig){
 System.out.println("我是小猪猪!");
 }else{
 System.out.println("我不是小猪猪!");
 }
 }
 session.getTransaction().commit();
 }catch(Exception e){
 e.printStackTrace();
 session.getTransaction().rollback();
 }finally{
 HibernateUtils.closeSession(session);
 }
}

查询结果:

Hibernate: select animal0_.id as id0_, animal0_.name as name0_, animal0_.sex as sex0_, animal0_.weight as weight0_, animal0_.height as height0_, animal0_.type as type0_ from t_animal animal0_
我是小猪猪!
我不是小猪猪!
我是小猪猪!
我不是小猪猪!

三、继承映射三种策略
1. 每个类分层结构一张表(Table per class hierarchy)

假设我们有接口Payment和它的几个实现类: CreditCardPayment, CashPayment, 和ChequePayment。则“每个类分层结构一张表”(Table per class hierarchy)的映射代码如下所示:

<class name="Payment" table="PAYMENT">
 <id name="id" type="long" column="PAYMENT_ID">
 <generator class="native"/>
 </id>
 <discriminator column="PAYMENT_TYPE" type="string"/>
 <property name="amount" column="AMOUNT"/>
 ...
 <subclass name="CreditCardPayment" discriminator-value="CREDIT">
 <property name="creditCardType" column="CCTYPE"/>
 ...
 </subclass>
 <subclass name="CashPayment" discriminator-value="CASH">
 ...
 </subclass>
 <subclass name="ChequePayment" discriminator-value="CHEQUE">
 ...
 </subclass>
</class>

采用这种策略只需要一张表即可。它有一个很大的限制:要求那些由子类定义的字段, 如CCTYPE,不能有非空(NOT NULL)约束。

2. 每个子类一张表(Table per subclass)

对于上例中的几个类而言,采用“每个子类一张表”的映射策略,代码如下所示:

<class name="Payment" table="PAYMENT">
 <id name="id" type="long" column="PAYMENT_ID">
 <generator class="native"/>
 </id>
 <property name="amount" column="AMOUNT"/>
 ...
 <joined-subclass name="CreditCardPayment" table="CREDIT_PAYMENT">
 <key column="PAYMENT_ID"/>
 ...
 </joined-subclass>
 <joined-subclass name="CashPayment" table="CASH_PAYMENT">
 <key column="PAYMENT_ID"/>
 <property name="creditCardType" column="CCTYPE"/>
 ...
 </joined-subclass>
 <joined-subclass name="ChequePayment" table="CHEQUE_PAYMENT">
 <key column="PAYMENT_ID"/>
 ...
 </joined-subclass>
</class>

需要四张表。三个子类表通过主键关联到超类表(因而关系模型实际上是一对一关联)。

3. 每个子类一张表(Table per subclass),使用辨别标志(Discriminator)

注意,对“每个子类一张表”的映射策略,Hibernate的实现不需要辨别字段,而其他 的对象/关系映射工具使用了一种不同于Hibernate的实现方法,该方法要求在超类 表中有一个类型辨别字段(type discriminator column)。Hibernate采用的方法更 难实现,但从关系(数据库)这点上来看,按理说它更正确。若你愿意使用带有辨别字 段的“每个子类一张表”的策略,你可以结合使用<subclass> 与<join>,如下所示:

<class name="Payment" table="PAYMENT">
 <id name="id" type="long" column="PAYMENT_ID">
 <generator class="native"/>
 </id>
 <discriminator column="PAYMENT_TYPE" type="string"/>
 <property name="amount" column="AMOUNT"/>
 ...
 <subclass name="CreditCardPayment" discriminator-value="CREDIT">
 <join table="CREDIT_PAYMENT">
 <property name="creditCardType" column="CCTYPE"/>
 ...
 </join>
 </subclass>
 <subclass name="CashPayment" discriminator-value="CASH">
 <join table="CASH_PAYMENT">
 ...
 </join>
 </subclass>
 <subclass name="ChequePayment" discriminator-value="CHEQUE">
 <join table="CHEQUE_PAYMENT" fetch="select">
 ...
 </join>
 </subclass>
</class>

可选的声明fetch="select",是用来告诉Hibernate,在查询超类时, 不要使用外部连接(outer join)来抓取子类ChequePayment的数据。

(0)

相关推荐

  • 举例讲解Java的Hibernate框架中的多对一和一对多映射

    多对一(Many-to-One)映射 多对一(many-to-one)关联是最常见的关联关系,其中一个对象可以与多个对象相关联.例如,一个相同的地址对象可以与多个雇员的对象相关联. 定义RDBMS表: 考虑一个情况,我们需要员工记录存储在EMPLOYEE表,将有以下结构: create table EMPLOYEE ( id INT NOT NULL auto_increment, first_name VARCHAR(20) default NULL, last_name VARCHAR(20

  • Hibernate映射解析之关联映射详解

    Hibernate中的关联映射 关联关系 平时开发中,类与类之间最普遍的的关系就是关联关系,而且关联是有方向的. 以部门(Dept)和员工(Employee)为例:一个部门下有多个员工,而一个员工只能属于一个部门. 从Employee到Dept的关联就是 多对一 关联. 这就说明 每个Employee对象只会引用一个Dept对象,因此在Employee类中应该定义一个Dept类型的属性,来引用所关联的Dept对象. 从Dept到Employee的关联就是 一对多 关联.这就说明 每个Dept对象

  • java Hibernate多对多映射详解及实例代码

    java Hibernate多对多映射 前言: 一.单向多对多 单向多对多的例子用人和职位来举例,一个人可以有多个职位,一个职位会有多个人.单向多对多是指只能在一端来查询获取另一端的内容.多对多的关系在生成关系模型时会生成对象之前的关联表,关联表中存放着两个关系表的主键,它们的关系如下所示: 代码部分:  (1)映射和关系类 因为是单向的关系,所以只需要在一端进行维护,所以我们需要在User.hbm.xml配置文件中添加<many-to-many>标签,并在标签中加上对应的列关系,在<s

  • 详解hibernate双向多对多关联映射XML与注解版

    双向多对多关联映射原理: 假设,一个员工可能有多个角色,一个角色可能有多个员工,从员工或角色的角度看,这就是多对多的关系,不管从哪一个角度看,都是多对多的联系.多对多关联映射关系一般采用中间表的形式来实现,即新增一种包含关联双方主键的表.实现多对多关联关系,在数据库底层通过添加中间表指定关联关系,而在hibernate框架在双方的实体中添加一个保存对方的集合,在双方的映射文件中使用<set>元素和<many-to-many>元素进行关联关系的配置. 如下图所示: (1)XML版 R

  • Java的Hibernate框架中的组合映射学习教程

    一.组合映射 组合是关联关系的一种特殊情况,是关联关系耦合度最高的一种关系,组合的主对象和子对象拥有相同的生命周期,主对像消亡的话子对象也会消亡.这里使用雇主和用户作为示例,用户和雇主都拥有联系方式属性,如果这里站在对象角度思考的话,常常会把对象模型绘制成为组合的方式,抽象出来一个共同的联系方式类,然后两种人分别包含相应的联系方式对象即可,向应的对象模型时它的对象示例如下图所示: 组合对象模型在生成相应的关系模型后会把对应的子类包含到主表中,所以对应的表结构会将相应的属性生成到对应的表中,相应的

  • Java的Hibernate框架中一对多的单向和双向关联映射

    一.一对多单向关联映射 一对多关系的对象模型在日常生活中也经常看到,就拿学生和班级来说,一个班级里有多个学生,所以班级和学生的关系是一对多的关系,映射到对象模型中,如下图: 对象模型说明了这种一对多的关系是由一的一端来维护的,那么映射成关系模型就是一个班级字段下面会有多个学生,这样就形成了一对多的关系,通过班级能够查询获得学生信息,对应的关系模型如下图: 1.基本配置 有了对象模型接下来就让它们映射为对应的关系代码,在进行关系映射时需要在一的一端添加<one-to-many>标签,另外还需要在

  • Java的Hibernate框架中集合类数据结构的映射编写教程

    一.集合映射 1.集合小介 集合映射也是基本的映射,但在开发过程中不会经常用到,所以不需要深刻了解,只需要理解基本的使用方法即可,等在开发过程中遇到了这种问题时能够查询到解决方法就可以了.对应集合映射它其实是指将java中的集合映射到对应的表中,是一种集合对象的映射,在java中有四种类型的集合,分别是Set.Map.List还有普通的数组,它们之间有很大的区别: (1)Set,不可以有重复的对象,对象是无序的: (2)List,可以与重复的对象,对象之间有顺序: (3)Map,它是键值成对出现

  • Hibernate映射之基本类映射和对象关系映射详解

    回想一些我们在没有学习ssh的时候,我们建立数据库的表时,首先是数据库建模E-R图,然后再通过实体模型来建立关系模型,再建立相应的表.实体间存在三种关系,一对一,一对多(或者说多对一),多对多.而如今我们要根据类来映射相应的表,那只能是通过类与类之间的关系加上映射文件来映射数据库的表.我们学习UML建模,类与类之间存在五种关系,继承,实现,关联,依赖,聚合/组合,在hibernate中实体类之间的关系也是如此,对于不同的关系对应的代码实现我们已经很熟悉了,所以对于实体类是复习的知识. Hiber

  • Java的Hibernate框架中复合主键映射的创建和使用教程

    复合主键映射需要在映射配置文件中使用<composite-id>标签,该标签是指将一个类指定为相应的复合主键,它的name属性需要指定类文件中定义的属性值,并在该标签中添加<key-property>子标签. Note:想要使用复合映射必须要将复合主键放到一个类中,也就是讲复合主键属性和其它属性分到两个类中,并将复合主键的类实现接口Serializable,该接口隶属于java.io. 复合主键的映射关系的主键是由多个列复合而成的,对应到数据表中相当的简单,如下图: 1.类文件 这

  • Java的Hibernate框架中的继承映射学习教程

    一.继承映射 继承是面向对象很重要的特性,它实现了代码的服用,在关系模型中同样也有继承关系,这种继承关系其实可以看做是一种枚举关系,一种类型中可以枚举出很多子类型,这些子类型和父对象形成了继承关系,能够对其进行枚举的大部分都可以看做是一种继承映射,所以这种枚举关系可以看做是继承映射,例如动物就是一种抽象类,它是其它动物猪.猫等的父类,它们之间就是一种继承关系,如下图: 这种继承映射在转化为关系模型后会生成一张表,那么这张表是如何区分这两种类型的呢?用的是关系字段,需要在表中添加类型字段,使用关键

  • Java的Hibernate框架中的基本映射用法讲解

    Hibernate进行了分类整合发现其实Hibernate分为三大部分:核心对象.映射.HQL,这三大部分开发过程中最常使用,前几篇讨论了核心对象及对象之间的转换方法,接下来讨论Hibernate的映射使用方法.   Hibernate一个重要的功能就是映射,它能够在对象模型和关系模型之间转换,是面向对象编程思想提倡使用的,使用映射程序开发人员只需要关心对象模型中代码的编写.对象和关系数据库之间的映射通常是由XML文档来定义的.这个映射文档被设计为易读的,并且可以手动修改.这种映射关系我总结为下

  • Java的Hibernate框架结合MySQL的入门学习教程

    零.关于Hibernate Hibernate是冬眠的意思,它是指动物的冬眠,但是本文讨论的Hibernate却与冬眠毫无关系,而是接下来要讨论的SSH2框架中的一员.Hibernate是一个开源的项目,它是一个对象关系模型的框架,并且对JDBC进行了非常轻量级的封装,程序员在开发时可以使用对象编程思维进行开发. 下载地址:http://hibernate.org/orm/downloads/ Note:轻量级和重量级的区别,轻量级的框架包较小,并且使用较简单,而且测试容易,开发效率高:重量级框

  • 浅析Java的Hibernate框架中的继承关系设计

    这次我们来说一下hibernate的层次设计,层次设计也就是实体之间的继承关系的设计.  也许这样比较抽象,我们直接看例子.  1)我们先看一下普通的做法  直接上代码:三个实类如下: public class TItem implements Serializable{ //省略Get/Set方法 private int id; private String manufacture; private String name; } public class TBook extends TItem

  • 详解Java的Hibernate框架中的set映射集与SortedSet映射

    Set 集合Set是一个java集合不包含任何重复的元素.更正式地说,Set不包含任何元素对e1和e2,使得e1.equals(e2),和至多一个空元素.所以被添加到一组对象必须实现equals()和hashCode()方法,使Java可以判断任何两个元素/对象是否是相同的. 集被映射到与映射表中<set>元素,并在java.util.HashSet中初始化.可以使用Set集合在类时,有一个集合中不需要重复的元素. 定义RDBMS表: 考虑一个情况下,我们需要我们的员工记录存储在EMPLOYE

  • 解析Java的Hibernate框架中的持久化类和映射文件

    持久化类 Hibernate的整个概念是采取从Java类属性的值,并将持久到数据库表.一个映射文件Hibernate的帮助确定如何从拉动类的值,并将它们映射与表和相关的域. 其对象或实例将存储在数据库表中的Java类在Hibernate中称为持久化类. Hibernate的效果最好,如果这些类遵循一些简单的规则,也称为普通Java对象(POJO)编程模型.有下列持久化类的主要规则,但是,这些规则并不是必需的. 将所有的持久化Java类需要一个默认的构造函数. 所有类应该包含为了让容易识别对象内H

  • 深入解析Java的Hibernate框架中的持久对象

    一.持久对象生命周期 应用程序在使用Hibernate框架后,创建的持久对象会经历一整套生命周期来完成数据库的操作,其中主要的三个状态分别是瞬态(Transient).持久化(Persistent).脱管(detached).这三种状态的转换是能够在应用程序中控制的,如下图: 为了能清楚的了解这几种状态,这里使用一个实例来查看下这几种状态下对象的不同,下面状态内的代码,具体步骤如下: (1)创建Hibernate_session程序集,并添加像相应的jar包: (2)配置Hibernate,添加

随机推荐