hibernate继承映射 一张表存储



相同的属性的类

相同的属性的类

如果许多对象有相同的属性的类，就可以将相同的属性抽取成一个父类，不同的对象都继承父类。那应当如何应用hibernate映射和存储呢？根据不同的存储分为三种方法：

一张表存储，也就是一张表存储pig和Bird

父类存储在一张表，子类分别存储一张表，即Animal存一张表，Pig存一张表，Bird存一张表

子类分别存储一张表，即需Pig存一张表，Bird存一张表

1.1.1.一张表存储

将父类属性与子类属性都存储在一张表里，那我们怎么区别不同的子类？我们可以加入字段来分辩不同的子类。例如：

父类属性与子类属性

父类属性与子类属性

面就是用一个type字段来分辨不同的子类，即P：猪，B：鸟。

那怎么用hibernate进行映射呢？

步骤：

建立POJO: Animal.java、Bird.java、Pig.java

Bird和Pig分别继承Animal

写一个映射文件extends.hbm.xml。

代码实现实例：

Animal.java：

public class Animal {

    private int id;

    private String name;

    private boolean sex;

 

Bird.java：

public class Bird extends Animal {

    private int height;

Pig.java：

public class Pig extends Animal {

    private int weight;

 

extends.hbm.xml：

<hibernate-mapping package=”hibernate.po”>

    <class name=”Animal” table=”t_animal” lazy=”false”>

       <id name=”id”>

           <generator class=”native”/>

       </id>

       <discriminator column=”type” type=”string”/>

       <property name=”name”/>

       <property name=”sex”/>

       <subclass name=”Pig” discriminator-value=”P”>

           <property name=”weight”/>


       </subclass>

       <subclass name=”Bird” discriminator-value=”B”>

           <property name=”height”/>

       </subclass>

    </class>

</hibernate-mapping>

测试代码程序：

public class ExtendsTest extends TestCase {
public void testSave1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Pig pig = new Pig();
pig.setName(“猪猪”);
pig.setSex(true);
pig.setWeight(100);
session.save(pig);
Bird bird = new Bird();
bird.setName(“鸟鸟”);
bird.setSex(false);
bird.setHeight(50);
session.save(bird);
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 采用load，通过Pig查询
*/
public void testLoad1() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
Pig pig = (Pig)session.load(Pig.class, 1);
System.out.println(pig.getName());
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}
/**
* 采用load，通过Animal查询
*/
public void testLoad2() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

Animal animal = (Animal)session.load(Animal.class, 1);
System.out.println(animal.getName());

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

/**
* 采用load，通过Animal查询
*/
public void testLoad3() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

Animal animal = (Animal)session.load(Animal.class, 1);

//因为load默认只是lazy，因为我们看到的是Animal的代理对象
//所以通过instanceof是反应不出正真的对象类型的
//因此load在默认情况下是不支持多态查询的
if (animal instanceof Pig) {
System.out.println(animal.getName());
}else {
System.out.println(“不是猪”);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

/**
* 采用load，通过Animal查询,将<class>标签上的lazy=false
*/
public void testLoad4() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

Animal animal = (Animal)session.load(Animal.class, 1);
//可以正确的判断出Pig的类型，因为lazy=false，返回的是具体的
Pig类型
//此时load支持多态查询
if (animal instanceof Pig) {
System.out.println(animal.getName());
}else {
System.out.println(“不是猪”);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

/**
* 采用get，通过Animal查询
*/
public void testLoad5() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();

//可以正确的判断出Pig的类型，因为返回的是具体的Pig类型
//get支持多态查询
Animal animal = (Animal)session.get(Animal.class, 1);

if (animal instanceof Pig) {
System.out.println(animal.getName());
}else {
System.out.println(“不是猪”);
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

/**
* 采用get，通过Animal查询
*/
public void testLoad6() {
Session session = null;
try {
session = HibernateUtils.getSession();
session.beginTransaction();
// List animalList = session.createQuery(“from Animal”).list();
// for (Iterator iter = animalList.iterator(); iter.hasNext();) {
// Animal a = (Animal)iter.next();
// //能够正确的鉴别出正真的类型，hql是支持多态查询的
// if (a instanceof Pig) {
// System.out.println(“是Pig”);
// }else if (a instanceof Bird) {
// 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 Pig) {
System.out.println(“是Pig”);
}else if (o instanceof Bird) {
System.out.println(“是bird”);
}
}
session.getTransaction().commit();
}catch(Exception e) {
e.printStackTrace();
session.getTransaction().rollback();
}finally {
HibernateUtils.closeSession(session);
}
}

}

1、  理解如何映射

类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。这机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：

1)      父类用普通的<class>标签定义

2)      在父类中定义一个discriminator，即指定这个区分的字段的名称和类型, 如：<discriminator column=”XXX” type=”string”/>

3)      子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：Subclass标签的name属性是子类的全路径名，在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。 当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

2、  理解如何存储

存储的时候hibernate会自动将鉴别字段值插入到数据库中，在加载数据的时候，hibernate能根据这个鉴别值正确的加载对象

3、  多态查询

在hibernate加载数据的时候能鉴别出正真的类型（instanceOf），

get支持多态查询

load只有在lazy=false，才支持多态查询

hql支持多态查询