Hibernate学习17 -- 关联映射7 -- 继承映射1 -- 一张表存储

如果许多对象有相同的属性的类，我们可以把相同的属性抽取成一个父类，不同的对象都继承父类。例如：

那我们应当如何映射和存储呢？我们根据不同的存储分为三种方法：

n 一张表存储，即一张表存储pig和Bird

n 父类存储在一张表，子类分别存储一张表，即Animal存一张表，Pig存一张表，Bird存一张表

n 子类分别存储一张表，即需Pig存一张表，Bird存一张表

1.1.1.一张表存储

即将父类属性与子类属性都存储在一张表里，那我们怎么区别不同的子类？我们可以加入字段来分辩不同的子类。例如：

我们上面就是用一个type字段来分辨不同的子类，即P：猪，B：鸟。

那我们怎么用hibernate进行映射呢？

步骤：

n         建立POJO: Animal.java、Bird.java、Pig.java

n         Bird和Pig分别继承Animal

n         写一个映射文件extends.hbm.xml。

代码实现：

Animal.java：

public class Animal {   

    private int id;  

    private String name;

    private boolean sex;

Bird.java：

public class Bird extends Animal {

    private int height;

Pig.java：

public class Pig extends Animal { 

    private int weight;

extends.hbm.xml：

<hibernate-mapping package="hibernate.po">

    <class name="Animal" table="t_animal" lazy="false">

       <id name="id">

           <generator class="native"/>

       </id>

       <discriminator column="type" type="string"/>

       <property name="name"/>

       <property name="sex"/>

       <subclass name="Pig" discriminator-value="P">

           <property name="weight"/>

       </subclass>

       <subclass name="Bird" discriminator-value="B">

           <property name="height"/>

       </subclass>

    </class>

</hibernate-mapping>

测试代码：

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，因为我们看到的是Animal的代理对象

           //所以通过instanceof是反应不出正真的对象类型的

           //因此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);

       }

    }         

   

    /**

     * 采用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);

        }

    }  

   

}

 

总结：

1、  理解如何映射

因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。

这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：

1)      父类用普通的<class>标签定义

2)      在父类中定义一个discriminator，即指定这个区分的字段的名称和类型, 如：<discriminator column=”XXX” type=”string”/>

3)      子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：Subclass标签的name属性是子类的全路径名，在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标签平行。 当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

2、  理解如何存储

存储的时候hibernate会自动将鉴别字段值插入到数据库中，在加载数据的时候，hibernate能根据这个鉴别值正确的加载对象

3、  多态查询

在hibernate加载数据的时候能鉴别出正真的类型（instanceOf），

get支持多态查询

load只有在lazy=false，才支持多态查询

hql支持多态查询