十三、实体继承映射（每个子类映射成一张表）
2011-05-26 13:42
411 查看
一、实体继承映射（每个子类映射成一张表）
（1）实体类与表间的关系
Animal t_animal t_pig t_bird
id:int id:int pid:int bid:int
name:String name:varchar weight:int height:int
sex:boolean sex:big
Ping Bird
weight:int height:int
（2）、创建表语句
CREATE TABLE `t_animal` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`sex` bit(1) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `t_pig` (
`pid` int(11) NOT NULL,
`weight` int(11) DEFAULT NULL,
PRIMARY KEY (`pid`),
KEY `FKCB61614F874887C1` (`pid`),
CONSTRAINT `FKCB61614F874887C1` FOREIGN KEY (`pid`) REFERENCES `t_animal` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `t_bird` (
`bid` int(11) NOT NULL,
`height` int(11) DEFAULT NULL,
PRIMARY KEY (`bid`),
KEY `FKA005AF0E87485333` (`bid`),
CONSTRAINT `FKA005AF0E87485333` FOREIGN KEY (`bid`) REFERENCES `t_animal` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into t_animal (name, sex) values ('猪猪', true);
insert into t_pig (weight, pid) values (100, 1);
insert into t_animal (name, sex) values ('
鸟鸟
', false);
insert into t_bird (height, bid) values (50, 2);
（3）、创建实体类与映射文件
Animal.java
public class Animal {
private int id;
private String name;
private boolean sex;
public Animal(){
}
//省略set、get方法
}
Bird.java
public class Bird extends Animal {
private int height;
public Bird(){
}
//省略set、get方法
}
Pig.java
public class Pig extends Animal1 {
private int weight;
public Pig1(){
}
//省略set、get方法
}
extends.hbm.xml
<hibernate-mapping package="com.keli.pojo">
<class name="Animal2" table="t_animal">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="sex"/>
<joined-subclass name="Pig" table="t_pig">
<key column="pid"/>
<property name="weight"/>
</joined-subclass>
<joined-subclass name="Bird" table="t_bird">
<key column="bid"/>
<property name="height"/>
</joined-subclass>
</class>
</hibernate-mapping>
（4）、测试
public class ExtendsTest2 extends TestCase {
public void testSave1() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Pig2 pig = new Pig2();
pig.setName("猪猪");
pig.setSex(true);
pig.setWeight(100);
session.save(pig);
Bird2 bird = new Bird2();
bird.setName("鸟鸟");
bird.setSex(false);
bird.setHeight(50);
session.save(bird);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用load，通过Pig查询
*/
public void testLoad1() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Pig2 pig = (Pig2) session.load(Pig2.class, 1);
System.out.println(pig.getName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用load，通过Animal查询
*/
public void testLoad2() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTr
4000
ansaction();
Animal2 animal = (Animal2) session.load(Animal2.class, 1);
System.out.println(animal.getName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用load，通过Animal查询
*/
public void testLoad3() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Animal2 animal = (Animal2) session.load(Animal2.class, 1);
// 因为load默认值是lazy，因为我们看到的Animal的代理对象
// 所以通过instanceof是反应不出真实的对象类型的
// 因此load在默认情况下是不支持多态查询的
if (animal instanceof Pig2) {
System.out.println(animal.getName());
} else {
System.out.println("不是猪");
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用load，通过Animal查询,将<class>标签上的lazy=false
*/
public void testLoad4() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Animal2 animal = (Animal2) session.load(Animal2.class, 1);
// 可以正确的判断出Pig的类型，因为lazy=false，返回的是具体的Pig类型
// 此时load支持多态查询
if (animal instanceof Pig2) {
System.out.println(animal.getName());
} else {
System.out.println("不是猪");
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用get，通过Animal查询
*/
public void testLoad5() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Animal2 animal = (Animal2) session.get(Animal2.class, 1);
// 可以正确的判断出Pig的类型，因为返回的是具体的Pig类型
// get支持多态查询
if (animal instanceof Pig2) {
System.out.println(animal.getName());
} else {
System.out.println("不是猪");
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用get，通过Animal查询
*/
public void testLoad6() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
// List animalList = session.createQuery("from Animal1").list();
// for(Iterator iter = animalList.iterator();iter.hasNext();){
// Animal1 a =(Animal1)iter.next();
// //能够正确的鉴别出真实的类型，hql是支持多态查询的
// if(a instanceof Pig2){
// System.out.println("是Pig");
// }else if(a instanceof Bird2){
// System.out.println("是Bird");
// }
// }
List list = session.createQuery("from java.lang.Object").list();
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object o = iter.next();
if (o instanceof Pig2) {
System.out.println("是Pig");
} else if (o instanceof Bird2) {
System.out.println("是Bird");
}
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
}
说明：
每个子类映射成一张表
1、理解如何映射
这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。
在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，
这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。实现这种策略的时候，
有如下步骤：
父类用普通的<class>标签定义即可
父类不再需要定义discriminator字段
子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：
Joined-subclass标签的name属性是子类的全路径名
Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。
如：<key column=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。
Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass
标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。
（1）实体类与表间的关系
Animal t_animal t_pig t_bird
id:int id:int pid:int bid:int
name:String name:varchar weight:int height:int
sex:boolean sex:big
Ping Bird
weight:int height:int
（2）、创建表语句
CREATE TABLE `t_animal` (
`id` int(11) NOT NULL AUTO_INCREMENT,
`name` varchar(255) DEFAULT NULL,
`sex` bit(1) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `t_pig` (
`pid` int(11) NOT NULL,
`weight` int(11) DEFAULT NULL,
PRIMARY KEY (`pid`),
KEY `FKCB61614F874887C1` (`pid`),
CONSTRAINT `FKCB61614F874887C1` FOREIGN KEY (`pid`) REFERENCES `t_animal` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
CREATE TABLE `t_bird` (
`bid` int(11) NOT NULL,
`height` int(11) DEFAULT NULL,
PRIMARY KEY (`bid`),
KEY `FKA005AF0E87485333` (`bid`),
CONSTRAINT `FKA005AF0E87485333` FOREIGN KEY (`bid`) REFERENCES `t_animal` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
insert into t_animal (name, sex) values ('猪猪', true);
insert into t_pig (weight, pid) values (100, 1);
insert into t_animal (name, sex) values ('
鸟鸟
', false);
insert into t_bird (height, bid) values (50, 2);
（3）、创建实体类与映射文件
Animal.java
public class Animal {
private int id;
private String name;
private boolean sex;
public Animal(){
}
//省略set、get方法
}
Bird.java
public class Bird extends Animal {
private int height;
public Bird(){
}
//省略set、get方法
}
Pig.java
public class Pig extends Animal1 {
private int weight;
public Pig1(){
}
//省略set、get方法
}
extends.hbm.xml
<hibernate-mapping package="com.keli.pojo">
<class name="Animal2" table="t_animal">
<id name="id">
<generator class="native"/>
</id>
<property name="name"/>
<property name="sex"/>
<joined-subclass name="Pig" table="t_pig">
<key column="pid"/>
<property name="weight"/>
</joined-subclass>
<joined-subclass name="Bird" table="t_bird">
<key column="bid"/>
<property name="height"/>
</joined-subclass>
</class>
</hibernate-mapping>
（4）、测试
public class ExtendsTest2 extends TestCase {
public void testSave1() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Pig2 pig = new Pig2();
pig.setName("猪猪");
pig.setSex(true);
pig.setWeight(100);
session.save(pig);
Bird2 bird = new Bird2();
bird.setName("鸟鸟");
bird.setSex(false);
bird.setHeight(50);
session.save(bird);
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用load，通过Pig查询
*/
public void testLoad1() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Pig2 pig = (Pig2) session.load(Pig2.class, 1);
System.out.println(pig.getName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用load，通过Animal查询
*/
public void testLoad2() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTr
4000
ansaction();
Animal2 animal = (Animal2) session.load(Animal2.class, 1);
System.out.println(animal.getName());
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用load，通过Animal查询
*/
public void testLoad3() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Animal2 animal = (Animal2) session.load(Animal2.class, 1);
// 因为load默认值是lazy，因为我们看到的Animal的代理对象
// 所以通过instanceof是反应不出真实的对象类型的
// 因此load在默认情况下是不支持多态查询的
if (animal instanceof Pig2) {
System.out.println(animal.getName());
} else {
System.out.println("不是猪");
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用load，通过Animal查询,将<class>标签上的lazy=false
*/
public void testLoad4() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Animal2 animal = (Animal2) session.load(Animal2.class, 1);
// 可以正确的判断出Pig的类型，因为lazy=false，返回的是具体的Pig类型
// 此时load支持多态查询
if (animal instanceof Pig2) {
System.out.println(animal.getName());
} else {
System.out.println("不是猪");
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用get，通过Animal查询
*/
public void testLoad5() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
Animal2 animal = (Animal2) session.get(Animal2.class, 1);
// 可以正确的判断出Pig的类型，因为返回的是具体的Pig类型
// get支持多态查询
if (animal instanceof Pig2) {
System.out.println(animal.getName());
} else {
System.out.println("不是猪");
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
/**
* 采用get，通过Animal查询
*/
public void testLoad6() {
Session session = null;
try {
session = HibernateInitialize.getSession();
session.beginTransaction();
// List animalList = session.createQuery("from Animal1").list();
// for(Iterator iter = animalList.iterator();iter.hasNext();){
// Animal1 a =(Animal1)iter.next();
// //能够正确的鉴别出真实的类型，hql是支持多态查询的
// if(a instanceof Pig2){
// System.out.println("是Pig");
// }else if(a instanceof Bird2){
// System.out.println("是Bird");
// }
// }
List list = session.createQuery("from java.lang.Object").list();
for (Iterator iter = list.iterator(); iter.hasNext();) {
Object o = iter.next();
if (o instanceof Pig2) {
System.out.println("是Pig");
} else if (o instanceof Bird2) {
System.out.println("是Bird");
}
}
session.getTransaction().commit();
} catch (Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
} finally {
HibernateInitialize.closeSession();
}
}
}
说明：
每个子类映射成一张表
1、理解如何映射
这种策略是使用joined-subclass标签来定义子类的。父类、子类，每个类都对应一张数据库表。
在父类对应的数据库表中，实际上会存储所有的记录，包括父类和子类的记录；在子类对应的数据库表中，
这个表只定义了子类中所特有的属性映射的字段。子类与父类，通过相同的主键值来关联。实现这种策略的时候，
有如下步骤：
父类用普通的<class>标签定义即可
父类不再需要定义discriminator字段
子类用<joined-subclass>标签定义，在定义joined-subclass的时候，需要注意如下几点：
Joined-subclass标签的name属性是子类的全路径名
Joined-subclass标签需要包含一个key标签，这个标签指定了子类和父类之间是通过哪个字段来关联的。
如：<key column=”PARENT_KEY_ID”/>，这里的column，实际上就是父类的主键对应的映射字段名称。
Joined-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候，需要在Joined-subclass
标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在joined-subclass标签的内部。
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- Hibernate映射类继承之每个带有隐式多态的具体类一张表(每个子类各一张表,有各自的映射文件)
- Hibernate继承映射方式之每个子类一张表
- Hibernate映射类继承之每个带有联合的具体类一张表(每个子类各一张表,共用一个父类映射文件)
- Hibernate学习笔记：继承映射之每个子类一张表,使用辨别标志
- Hibernate/JPA中的继承映射 实体extends的关系(每个子类独立一个表)
- Hibernate继承映射：每个子类一张表(joined-subclass)表结构
- hibernate继承映射之每个子类一张表（无辨识）
- hibernate继承映射策略之每个子类一张表
- hibernate继承关系映射关系方法（二）--每个子类一张表
- Hibernate学习笔记：继承映射之每个子类一张表
- Hibernate继承映射：每个子类一张表(joined-subclass)表结构
- 每个子类映射成一张表
- Hibernate继承映射之每个类一张表
- Hibernate继承映射之每个具体类一张表
- Hibernate基础------》映射关系---》继承映射-》join_subclass映射（每个类对应一张表）
- hibernate继承映射策略之每个具体类一张表
- hibernate继承关系映射方法（三）--每个具体类一张表TPC
- 继承映射（二）每个类一张表JOINED
- Hibernate映射类继承之每个类层次结构一张表(父子类共用一张表,一个映射文件)
- 继承映射（三）每个具体的类一张表TABLE_PER_CLASS