Hibernate之 继承映射

Hibernate的继承映射可分为四种：
1、普通的继承映射
需求:现在有动物(Animal这个类) 还有Dog这个类 和 Cat这个类 要求使用继承映射来完成这个关联关系的配置
Animal.java

public class Animal {
    //private int aid;
    private String color;
    private String name;
    /*public int getAid() {
        return aid;
    }
    public void setAid(int aid) {
        this.aid = aid;
    }*/
    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

Cat.java

public class Cat extends Animal{
    private int cId;
    private String tail;
    public int getcId() {
        return cId;
    }
    public void setcId(int cId) {
        this.cId = cId;
    }
    public String getTail() {
        return tail;
    }
    public void setTail(String tail) {
        this.tail = tail;
    }
}

Dog.java

public class Dog extends Animal{
    private int dId;
    private String foot;

    public String getFoot() {
        return foot;
    }

    public void setFoot(String foot) {
        this.foot = foot;
    }

    public int getdId() {
        return dId;
    }

    public void setdId(int dId) {
        this.dId = dId;
    }


}

映射文件：Cat.hbm.xml

<?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">

 <!--package是否可以省略?
            可以
            省略之后类的名字 编写全路径就OK了       
 -->       
 <hibernate-mapping  package="com.wc.entity"  default-lazy="false"> 
    <!--一个class就相当于对应了一张表
         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的
         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名
         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题
         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)
         abstract="true" lazy="true"
         table:是否可以省略?
                        可以的
                        省略之后默认的表明就是实体的名字
    -->

    <class name="Cat" table="a_cat">
       <!--配置的主键
          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性 
          column:这个是用来定义这个列的列名的
          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型
          column:可以省略 默认的字段就是属性的名字  
          type:也可以省略:默认的类型和实体的数据类型是一样的
        -->
        <id name="cId">
            <generator class="native"></generator>
        </id>
        <!--配置的是普通的列
            property:设置的是普通的列  
            column:列名(当前对象的属性在数据库中对应的列名)  可以省略
            lazy:是否支持懒惰性的加载  :也默认值
            not-null:是否可以为null
            unique:是否这个列的值是唯一的
            type:可以省略 默认数据类型和实体中的属性的类型一直
            length:设置的是长度(有点必须的)


        -->
        <property name="color"></property>
        <property name="name"></property>
        <property name="tail"></property>
    </class>
</hibernate-mapping>

2、所有子类存在一张表
Animal.java与Cat.java同上
映射文件：Animal.hbm.xml

<?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">

 <!--package是否可以省略?
            可以
            省略之后类的名字 编写全路径就OK了       
 -->       
 <hibernate-mapping  package="com.wc.entity"  default-lazy="false"> 
    <!--一个class就相当于对应了一张表
         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的
         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名
         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题
         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)
         abstract="true" lazy="true"
         table:是否可以省略?
                        可以的
                        省略之后默认的表明就是实体的名字
    -->

    <class name="Animal" table="a_animal">
       <!--配置的主键
          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性 
          column:这个是用来定义这个列的列名的
          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型
          column:可以省略 默认的字段就是属性的名字  
          type:也可以省略:默认的类型和实体的数据类型是一样的
        -->
        <id name="id">
            <generator class="native"></generator>
        </id>
        <!--配置的是普通的列
            property:设置的是普通的列  
            column:列名(当前对象的属性在数据库中对应的列名)  可以省略
            lazy:是否支持懒惰性的加载  :也默认值
            not-null:是否可以为null
            unique:是否这个列的值是唯一的
            type:可以省略 默认数据类型和实体中的属性的类型一直
            length:设置的是长度(有点必须的)
        -->
         <!--整个分类
                               下面这个就是分类的这个列
        -->
        <discriminator  column="a_type" type="string" length="20"></discriminator>
         <!--配置的是普通的列-->
        <property name="color"></property>
        <property name="name"></property>
        <!--分别来配置我们的子类-->
        <subclass name="Cat" discriminator-value="a_cat">
            <property name="tail" type="string"></property>
        </subclass> 
            <subclass name="Dog" discriminator-value="a_dog">
            <property name="foot" type="string"></property>
        </subclass> 
    </class>
</hibernate-mapping>

3、所有类都对应一张表
java文件同上
映射文件：Animal.hbm.xml

<?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">

 <!--package是否可以省略?
            可以
            省略之后类的名字 编写全路径就OK了       
 -->       
 <hibernate-mapping  package="com.wc.entity"  default-lazy="false"> 
    <!--一个class就相当于对应了一张表
         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的
         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名
         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题
         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)
         abstract="true" lazy="true"
         table:是否可以省略?
                        可以的
                        省略之后默认的表明就是实体的名字
    -->

    <class name="Animal" table="a_animal">
       <!--配置的主键
          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性 
          column:这个是用来定义这个列的列名的
          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型
          column:可以省略 默认的字段就是属性的名字  
          type:也可以省略:默认的类型和实体的数据类型是一样的
        -->
        <id name="id">
            <generator class="native"></generator>
        </id>
        <!--配置的是普通的列
            property:设置的是普通的列  
            column:列名(当前对象的属性在数据库中对应的列名)  可以省略
            lazy:是否支持懒惰性的加载  :也默认值
            not-null:是否可以为null
            unique:是否这个列的值是唯一的
            type:可以省略 默认数据类型和实体中的属性的类型一直
            length:设置的是长度(有点必须的)
        -->
         <!--整个分类
                               下面这个就是分类的这个列
        -->
         <!--配置的是普通的列-->
        <property name="color"></property>
        <property name="name"></property>
        <!--分别来配置我们的子类-->
        <joined-subclass name="Dog" table="d_dog">
            <key column="id"></key>
            <property name="foot"></property>
        </joined-subclass>
            <joined-subclass name="Cat" table="c_cat">
            <key column="id"></key>
            <property name="tail"></property>
        </joined-subclass>
    </class>
</hibernate-mapping>

4、子类按种类分表（父类没有表）：
java文件同上
映射文件：Animal.hbm.xml

<?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">

 <!--package是否可以省略?
            可以
            省略之后类的名字 编写全路径就OK了       
 -->       
 <hibernate-mapping  package="com.wc.entity"  default-lazy="false"> 
    <!--一个class就相当于对应了一张表
         name:表示的是我们对应数据库表的那个对象的名字  这个名字如果上面没有配置package的话那么是需要全路径的
         table:这个标签是我们的JAVA对象  在数据库表中对应的这个表名
         abstract:这个用在继承映射的时候 这个类是否在数据库对应表的问题
         lazy:是否这个对象支持懒惰形加载 (我们只有在使用这个数据的时候那么 才加载这个数据  如果我们不需要使用这个数据的话 那么就不会加载)
         abstract="true" lazy="true"
         table:是否可以省略?
                        可以的
                        省略之后默认的表明就是实体的名字
    -->

    <class name="Animal" abstract="true">
       <!--配置的主键
          id：是用来配置这个主键的(每一个表都有主键) 值直接写我们实体里面的主键属性 
          column:这个是用来定义这个列的列名的
          type:表示的是当前的这个类中的属性的数据格式是什么  这里可以写java里面的类型的全路径 也可以写hibernate中支持的数据类型
          column:可以省略 默认的字段就是属性的名字  
          type:也可以省略:默认的类型和实体的数据类型是一样的
        -->
        <id name="id">
            <generator class="assigned"></generator>
        </id>
        <!--配置的是普通的列
            property:设置的是普通的列  
            column:列名(当前对象的属性在数据库中对应的列名)  可以省略
            lazy:是否支持懒惰性的加载  :也默认值
            not-null:是否可以为null
            unique:是否这个列的值是唯一的
            type:可以省略 默认数据类型和实体中的属性的类型一直
            length:设置的是长度(有点必须的)
        -->
         <!--整个分类
                               下面这个就是分类的这个列
        -->
         <!--配置的是普通的列-->
        <property name="color"></property>
        <property name="name"></property>
          <!--接下来就是配置加表的问题-->
        <union-subclass name="Dog" table="d_dog">
           <property name="foot"></property>
        </union-subclass>


       <union-subclass name="Cat" table="c_cat">
            <property name="tail"></property>
        </union-subclass>
    </class>
</hibernate-mapping>

注议事项：
第4中的id 要用手动输入的方式，否则会报错。

<generator class="assigned"></generator>