Hibernate之继承映射----采用单表继承
Hibernate之继承映射
每棵继承树映射成一张表
1、理解如何映射
因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
父类用普通的<class>标签定义
在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
如：<discriminator column=”XXX” type=”string”/>
子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：
Subclass标签的name属性是子类的全路径名
在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）
的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标
签平行。 当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值
是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。
2、理解如何存储
存储的时候hibernate会自动将鉴别字段值插入到数据库中，在加载数据的时候，hibernate能根据这个鉴别值
正确的加载对象
多态查询：在hibernate加载数据的时候能鉴别出正真的类型（使用instanceOf去辨别类型）
get支持多态查询
load只有在lazy=false，才支持多态查询
hql支持多态查询
所谓继承映射就是把继承关系映射到数据库里。就像A继承B这样的。
继承映射有三种实现策略：
1》单表继承。每棵类继承树使用一个表（table per class hierarcy）
2》具体表继承。每个子类一个表（table per subclass）
3》类表继承。每个具体类一个表（table per concrete class ）（有一些限制）
下面我们以动物类为例来讲解。建立一个动物类，然后建立猪和鸟继承这个动物类：
下面我们采用第一种，即单表继承，每棵类继承树使用一个表（table per class hierarcy）：
每棵继承树映射成一张表
t_animal
| id |
name |
sex |
weight |
height |
type |
| 1 |
猪猪 |
true |
100 |
|
P |
| 2 |
鸟鸟 |
false |
|
50 |
B |
public class Animal {
private int id;
private String name;
private boolean sex;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public boolean isSex() {
return sex;
}
public void setSex(boolean sex) {
this.sex = sex;
}
}
public class Pig extends Animal { private int weight; public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } }
下面是鸟的实体关系类：
public class Bird extends Animal { private int height; public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } }
第二步是写映射文件：
//其中的id和name以及sex是animal的普通属性，安正常的方法映射就可以了。
<hibernate-mapping package="com.bjsxt.hibernate">
<class name="Animal" table="t_animal" lazy="false">
<id name="id">
<generator class="native"/>
</id>
<discriminator column="type" type="string"/>//加入一个区分是什么类型的字段，使用discriminator 这个标签，这个标签必须在id，即主键的后面写
//这个标签叫鉴别器column="type" type="string"这个表示要加入的字段的名称和类型，string用小写
//表示是hibernate数据库类型，也可以使用java的类型，但是需要写全名。在这声明之后，在后面子类上加入
//相应的鉴别值，如discriminator-value="P"，另一个也要加入。以示区别。
<property name="name"/>
<property name="sex"/>
<subclass name="Pig" discriminator-value="P">//因为他是animal的子类，故在这做映射。使用subclass 标签
<property name="weight"/>
</subclass>
<subclass name="Bird" discriminator-value="B">
<property name="height"/>
</subclass>
</class>
</hibernate-mapping>
第三步，加入hibernate的配置文件：
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.url">jdbc:mysql://localhost/hibernate_extends_1</property>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">bjsxt</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="hibernate.show_sql">true</property>
<mapping resource="com/bjsxt/hibernate/extends.hbm.xml"/>
</session-factory>
</hibernate-configuration>
第四步，写测试代码：
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，lazy要使用动态代理，而且使用的代理是cglib类型的代理，即继承他生成一个子类，因为我们看到的是Animal的代理类的对象 //所以通过instanceof是反应不出正真的对象类型的 //因此load在默认情况下是不支持多态查询的（多态查询是指能鉴别出对象的真正对象类型的查询）
if (animal instanceof Pig) {//判断这个animal里面是不是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); } } }