Hibernate学习笔记：继承映射之每个类继承结构一张表

对象之间除了拥有，使用的关系，还有继承关系。Hibernate在作继承关系映射的时候有多种做法，今天学习第一种：每个类继承结构一张表，也就是说父类和子类在一张表中， 通过额外字段区分子类型。为了演示这种映射关系的做法，本文引入了四个对象，Animal, Monkey, Tiger，Zoo. Monkey和Tiger继承自Animal. 每个Animal都归属一个动物园Zoo,关系表animal(id, name, zoo_id,age, kind, animal_type), 其中animal_type用来标识子类是Tiger还是Monkey, age是monkey的专有属性， kind是tiger的专有属性。 关系表zoo(id, name, address).
package model; public class Animal { private int id; private String name; private Zoo zoo; //getter setter ignored }

package model; public class Monkey extends Animal{ private int age; public int getAge() { return age; } public void setAge(int age) { this.age = age; } public String toString(){ return super.toString() + "/nage: " + age; } }

package model; public class Tiger extends Animal{ private String kind; public String getKind() { return kind; } public void setKind(String kind) { this.kind = kind; } public String toString(){ return super.toString() + "/nkind: " + kind; } }

public class Zoo { private int id; private String name; private String address; private Set animals; //getter and setter ignored }

Zoo.hbm.xml:

<hibernate-mapping> <class name="model.Zoo" table="zoo" schema="dbo" catalog="hibernate"> <id name="id" column="id"> <generator class="native" /> </id> <property name="name" /> <property name="address" /> <set name="animals" fetch="join" lazy="false"> <key column="zoo_id" /> <one-to-many class="model.Animal" /> </set> </class> </hibernate-mapping> <!-- create table zoo( id int identity(1,1) primary key, name varchar(20) not null, address varchar(50) ) -->

只有父类Animal有映射文件， 子类的配置通过subclass来标识。

Animal.hbm.xml:

<hibernate-mapping package="model"> <class name="Animal" table="animal" schema="dbo" catalog="hibernate"> <id name="id" column="id"> <generator class="native" /> </id> <!-- 定义子类区分字段 --> <discriminator column="animal_type" type="string" /> <property name="name" /> <many-to-one name="zoo" class="model.Zoo" column="zoo_id" /> <!-- 映射子类 --> <subclass name="Monkey" discriminator-value="MONKEY"> <property name="age" /> </subclass> <!-- 映射子类 --> <subclass name="Tiger" discriminator-value="TIGER"> <property name="kind" /> </subclass> </class> </hibernate-mapping> <!-- create table animal( id int primary key identity(1,1), name varchar(20) not null, zoo_id int, age int, kind varchar(20), animal_type varchar(20) ) create table zoo( id int identity(1,1) primary key, name varchar(20) not null, address varchar(50) ) alter table animal add constraint fk_zoo_id foreign key (zoo_id) references zoo(id) insert into zoo (name,address)values('beijing zoo', 'beijing road') insert into zoo (name,address)values('shanghai zoo', 'shanghai road') insert into etl.animal(name, zoo_id, age, kind, animal_type) values('monkey1',1, 7, null,'MONKEY') insert into etl.animal(name, zoo_id, age, kind, animal_type) values('tiger9',2, null, 'south china tiger','TIGER') -->

dao和测试用例:

public interface AnimalDao { public List listTiger(); public List listMonkdy(); public void save(Animal a); public void delete(Animal a); public Zoo getZooById(int id); public List getAgedMonkey(int age); public List useCriteria(); public List useDetachedCriteria(); }

public class AnimalHibernateDao extends BaseHibernateDao implements AnimalDao{ public List<Tiger> listTiger() { return getSession().createQuery("from Tiger").list(); } public List<Monkey> listMonkdy() { return getSession().createQuery("from Monkey").list(); } public void save(Animal a) { Transaction tx = getSession().beginTransaction(); getSession().saveOrUpdate(a); tx.commit(); } public void delete(Animal a) { Transaction tx = getSession().beginTransaction(); getSession().delete(a); tx.commit(); } public List getAgedMonkey(int age){ String hql = "From Monkey m where m.age>:age"; Query q = getSession().createQuery(hql); q.setInteger("age", age); return q.list(); } //test case public static void main(String[] args){ AnimalDao dao = new AnimalHibernateDao(); List l = dao.list(); System.out.println(l.size()); } }

在向数据库中填充测试数据的时候注意animal_type的数据，本例用"MONKEY"和"TIGER"来标识子类， 所以最好对这个字段有约束。

这种做法的优点是：简单， 增加子类方便，数据存储快(因为在一张表中)，方便制作报表；

这种做法的优点是：耦合性高； 潜在的数据空间浪费。

需要注意的是： 子类专有的字段不能有非空约束。