在java中，类之间可以有继承关系，但是在数据库中是没有继承关系的。不过Hibernate是为了把面向对象的关系反映到数据库中，Hibernate为我们提供了3种方案：
第一、一个继承体系放在一张表中（就是把父类与子类的所有属性反映在一张表中）
第二、每个子类映射一张表，然后与父类对应的表用主键一对一关联起来
第三、每个具体类映射一张表
我们假设有三个类：Employee（员工）、Skill（技术）、Sales（销售）
员工分为技术人员和销售人员两种类型，技术和销售类继承员工类：
Employee.java：
private String id; private String name; private Department depart;
Skill.java：
private String skill; //定义技术类型
Sales.java：
private int sell; //定义销售数量
第一种：一个继承体系放在一张表中
（用画图画的，没用Rose，可能不是太好看，见谅了）
在这上边，我们把三个类映射在了一张表：Employee上边，我们看一下Employee.hbm.xml：
<?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
package="cn.itcast.hibernate.domain">
<class name="Employee" discriminator-value="0">
<id name="id">
<generator class="uuid"/>
</id>
<discriminator column="type" type="int" />
<property name="name" />
<many-to-one name="depart" column="depart_id" />
<subclass name="Skill" discriminator-value="1">
<property name="skill" />
</subclass>
<subclass name="Sales" discriminator-value="2">
<property name="sell" />
</subclass>
</class>
</hibernate-mapping>
我们在<class>标签中定义discriminator-value="0"这样的字段用来区别记录的属性，然后我们增加了一个标签<discriminator column="type" type="int" />，意思是这个字段在数据库中映射为type列，类型为int。然后我们用了两个<subclass>标签定义了两个继承关系，其中的<property>是每个继承类的对象，name属性会映射在数据库中成为对应的列。
我们写一个测试类：Many2OneExtend.java
public class Many2OneExtend {
public static void main(String[] args) {
add();
}
static void add(){
Session s = null;
Transaction tx = null;
try{
Employee emp1 = new Employee();
emp1.setName("emp1 name");
Sales emp2 = new Sales();
emp2.setName("emp2 name");
emp2.setSell(100);
Skill emp3 = new Skill();
emp3.setName("emp3 name");
emp3.setSkill("我是做java开发的");
s = HibernateUtil.getSession();
tx = s.beginTransaction();
s.save(emp1);
s.save(emp2);
s.save(emp3);
tx.commit();
}finally{
if(s!=null){
s.close();
}
}
}
}
然后我们查看下数据库中的Employee的表：
可以看到，三个类都是已经映射在了一张表中。
第二、每个子类映射一张表，然后与父类对应的表用主键一对一关联起来
首先，我们在Sales.java和Skill.java两个类中增加一个属性：
private String id;
然后，我们编辑Employee.hbm.xml文件：
<?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
package="cn.itcast.hibernate.domain">
<class name="Employee" >
<id name="id">
<generator class="uuid"/>
</id>
<property name="name" />
<many-to-one name="depart" column="depart_id" />
<joined-subclass name="Skill" >
<key column="id" />
<property name="skill" column="skill" type="string"></property>
</joined-subclass>
<joined-subclass name="Sales">
<key column="id" />
<property name="sell" type="integer"></property>
</joined-subclass>
</class>
</hibernate-mapping>
这里我们采用的是<joined-subclass>标签
我们写一个测试类运行一下：Many2OneExtend
package cn.itcast.hibernate;
import java.util.HashSet;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import cn.itcast.hibernate.domain.Employee;
import cn.itcast.hibernate.domain.Sales;
import cn.itcast.hibernate.domain.Skill;
public class Many2OneExtend {
public static void main(String[] args) {
add();
}
static void add(){
Session s = null;
Transaction tx = null;
try{
Employee emp1 = new Employee();
emp1.setName("emp1 name");
Sales emp2 = new Sales();
emp2.setName("emp2 name");
emp2.setSell(100);
Skill emp3 = new Skill();
emp3.setName("emp3 name");
emp3.setSkill("我是做java开发的");
s = HibernateUtil.getSession();
tx = s.beginTransaction();
s.save(emp1);
s.save(emp2);
s.save(emp3);
tx.commit();
}finally{
if(s!=null){
s.close();
}
}
}
}
然后，我们查看一下三张数据库表的情况：
第三、每个具体类映射一张表
在这种情况下，Employee类被看做一个抽象的类，Sales和Skill类继承Employee的所有属性。所以最后只会有Sales和Skill表，没有Employee表。
下边我们看一下Employee.hbm.xml文件：
<?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
package="cn.itcast.hibernate.domain">
<class name="Employee" abstract="true">
<id name="id">
<generator class="uuid"/>
</id>
<property name="name" />
<many-to-one name="depart" column="depart_id" />
</class>
<union-subclass name="Skill" extends="Employee">
<property name="skill" column="skill" type="string"></property>
</union-subclass>
<union-subclass name="Sales" extends="Employee">
<property name="sell" type="integer"></property>
</union-subclass>
</hibernate-mapping>
在这里边，我们的<class>标签定义了一个属性：abstract="true"，设置这个类是抽象的。
在<class></class>标签之外，我们定义了两对<union-subclass></union-subclass>标签，这两对标签定义了两个继承类。
我们写一下测试文件：Many2OneExtend.java
public class Many2OneExtend {
public static void main(String[] args) {
add();
}
static void add(){
Session s = null;
Transaction tx = null;
try{
Sales emp2 = new Sales();
emp2.setName("emp2 name");
emp2.setSell(100);
Skill emp3 = new Skill();
emp3.setName("emp3 name");
emp3.setSkill("我是做java开发的");
s = HibernateUtil.getSession();
tx = s.beginTransaction();
s.save(emp2);
s.save(emp3);
tx.commit();
}finally{
if(s!=null){
s.close();
}
}
}
}
然后，我们看一下数据库中的表：
可以看到，我们仅仅得到了两个表：Skill表和Sales表