Hibernate高级映射--继承映射

 
继承映射
继承映射的实现主要有四种方式：

此处我以员工为实例对四种方式进行理解，以员工所掌握的技术为子类。

Domain层实例类的创建：

Employee（员工）的实例化 ：

public class Employee {
    private Integer id;
    private String name;
    private Department depart;
   
    public Integer getId() {
       return id;
    }
    public void setId(Integer id) {
       this.id = id;
    }
    public String getName() {
       return name;
    }
    public void setName(String name) {
       this.name = name;
    }
    public Department getDepart() {
       return depart;
    }
    public void setDepart(Department depart) {
       this.depart = depart;
    }
 
}

 

Skiller（技术员）的实例化：

public class Skiller extends Employee {
  private String skill;
 
  public String getSkill() {
     return skill;
  }
 
  public void setSkill(String skill) {
     this.skill = skill;
  }
}
 

Sales（销售员）的实例化：

public class Sales extends Employee {
    private int  sell;
 
    public int getSell() {
       return sell;
    }
 
    public void setSell(int sell) {
       this.sell = sell;
    }
}
注：继承映射的四种方式，其实就是在父类（Employee）映射文件的不同。

 

       方式一：整个的继承层次的多个类的信息存放到一张表里。但是需要在表中添加一个特定的字段（鉴别器），用这个字段的值区分哪些记录属于哪个类。

       映射文件的编写：

              <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.hbsi.domain">
    <class name="Employee" table="employee" discriminator-value="0">
       <id name="id">
           <generator class="native" />
       </id>
       <discriminator column="type" type="int" />
       <!--
           鉴别器的设置,要放置在所有属性之前
       -->
       <property name="name" /><!-- 映射普通属性 -->
       <many-to-one name="depart" column="depart_id" />
       <!-- 用subclasss映射子类，并且指定鉴别字段  为 1 -->
       <subclass name="Skiller" discriminator-value="1">
           <!-- 映射子文本属性 -->
           <property name="skill" />
       </subclass>
       <!-- 用subclasss映射子类，并且指定鉴别字段  为 2 -->
       <subclass name="Sales" discriminator-value="2">
           <!-- 映射子文本属性 -->
           <property name="sell" />
       </subclass>
    </class>
</hibernate-mapping>
方式二：每个子类一张表，存放子类所有的属性。也就是说把对象模型上的继承关系表示为关系模型的外键关联，继承结构中的每个类和子类都有一张对应的表。

对应的映射文件的编写：

       <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.hbsi.domain">
    <class name="Employee" table="employee" discriminator-value="0">
       <id name="id">
           <generator class="native" />
       </id>
       <discriminator column="type" type="int" />
       <property name="name" /> <!--映射普通属性-->
       <many-to-one name="depart" column="depart_id" />
       <!--用joined-subclass元素给每个子类映射到一张表-->
       <joined-subclass name="Skiller" table="skiller">
           <!--用key元素来指定子类和父类之间是通过哪个字段来关联的-->
           <key column="employee_id" />
           <!--映射子文本属性-->
           <properties name="skill" />
       </joined-subclass>
       <!--用joined-subclass元素给每个子类映射到一张表-->
       <joined-subclass name="Sales" table="sales">
           <!--用key元素来指定子类和父类之间是通过哪个字段来关联的-->
           <key column="employee_id" />
           <!--映射子文本属性-->
           <properties name="sale" />
       </joined-subclass>
    </class>
</hibernate-mapping>
 

方式三：混合使用。

当一个子类特有的属性比较多，一个子类的属性比较少时，混合使用“一个类继承体系一张表”和“每个子类一张表” (映射文件)。

对应映射文件的编写：

       <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.hbsi.domain">
    <class name="Employee" table="employee">
       <id name="id">
           <generator class="native" />
       </id>
       <discriminator column="type" type="int" />
       <property name="name" column="name" />
       <many-to-one name="depart" column="depart_id" />
       <!-- 用subclasss映射子类，并且指定鉴别字段  为 1 -->
       <subclass name="Skiller" discriminator-value="1">
           <!--映射子文本属性-->
           <property name="skill" />
       </subclass>
       <!-- 用subclasss映射子类，并且指定鉴别字段  为 2 -->
       <subclass name="Sales" discriminator-value="2">
           <join table="sales">
              <!--用key元素来指定子类和父类之间是通过哪个字段来关联的-->
              <key column="employee_id" />
              <property name="sell" />
           </join>
       </subclass>
    </class>
</hibernate-mapping>
方式四：每个具体类都对应一张表，而且这个表的信息是完备的，它包含所有从父类继承下来的属性映射的字段和自己属性映射的字段和自己属性映射的字段。

      对应的映射文件：

              <?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
    "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
 
<hibernate-mapping package="com.hbsi.domain">
    <class name="Employee" table="employee">
       <!-- 映射对象标识符 -->
       <id name="id">
           <!-- 映射主键生成方式 -->
           <generator class="hilo" />
       </id>
       <!-- 映射普通属性 -->
       <property name="name" column="name" />
       <many-to-one name="depart" column="depart_id" />
       <!-- 用union-subclass元素给每个具体子类映射到一张表 -->
       <union-subclass name="Skiller" table="skiller">
           <!-- 映射子类属性 -->
           <property name="skill" />
       </union-subclass>
       <!-- 用union-subclass元素给每个具体子类映射到一张表 -->
       <union-subclass name="Sales" table="sales">
           <!-- 映射子类属性 -->
           <property name="sell" />
       </union-subclass>
    </class>
</hibernate-mapping>
测试类的编写代码：

       public class TestExtends {
    public static void main(String[] args){
       //add();
       query(32769);
    }
    //添加信息
    static void add(){
       Session session=null;
       Transaction tx=null;
       try{
           session=HibernateUtil.getSession();
           tx=session.beginTransaction();
           //添加
           Department depart=new Department();
           depart.setName("department one");
           Employee emp1=new Employee();
           emp1.setName("aaa");
           emp1.setDepart(depart);
          
           Skiller emp2 =new Skiller();
           emp2.setName("bbb");
           emp2.setDepart(depart);
           emp2.setSkill("coding");
          
           Sales emp3=new Sales();
           emp3.setName("ccc");
           emp3.setDepart(depart);
          
           session.save(depart);
           emp3.setSell(1000);
           session.save(emp1);
           session.save(emp2);
           session.save(emp3);
          
           tx.commit();
          
       }finally{
           if(session!=null){
              session.close();
           }
       }
    }
    //查询
    static void query(int empId){
       Session session=null;
       try{
           session=HibernateUtil.getSession();
           //查询的操作
           Employee emp=(Employee) session.get(Skiller.class, empId);
           System.out.println(emp.getName()+" "+emp.getClass());
           //
           if(emp instanceof Skiller){
              ((Skiller)emp).getSkill();
           }else if(emp instanceof Sales){
              ((Sales)emp).getSell();
           }
       }finally{
           if(session!=null){
              session.close();
           }
       }
    }
}