十二、实体继承关系（类继树承结映射成一张表）

最新推荐文章于 2019-10-29 21:17:35 发布

原创最新推荐文章于 2019-10-29 21:17:35 发布 · 855 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#pig #session #exception #hibernate #null #class

本文介绍了如何将实体类的继承关系映射到数据库的一张表中，使用Hibernate进行配置，包括创建表、实体类及映射文件，并通过测试案例展示了如何进行多态查询。在Hibernate中，通过discriminator字段区分不同类的记录，get和load方法在特定条件下支持多态查询。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

一、实体继承关系（类继树承结映射成一张表）

（1）实体类与表间的关系

Animal t_animal

id:int id:int

name:String name:varchar

sex:boolean sex:big

Ping Bird weight:varchar

weight:int height:int height:varchar

type::varchar

（2）、创建表语句

CREATE TABLE `t_animal` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`name` varchar(45) NOT NULL,
`sex` bit NOT NULL,
`weight` varchar(45) NOT NULL DEFAULT '无',
`height` varchar(45) NOT NULL DEFAULT '无',
`type` varchar(45) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;

INSERT INTO `t_animal` (`id`,`name`,`sex`,`weight`,`height`,`type`) VALUES
(1,'猪猪 ','1','100 ','无','P'),
(2,'鸟鸟 ','0','无','50','B');

（3）、创建实体类与映射文件

Animal.java

public class Animal {
    private int id;

    private String name;

    private boolean sex;

    public Animal(){

}

//省略set、get方法

}

Bird.java

public class Bird extends Animal {
    private int height;

    public Bird(){

    }

//省略set、get方法

}

Pig.java

public class Pig extends Animal1 {

    private int weight;

    public Pig1(){

    }

//省略set、get方法

}

extends1.hbm.xml

<hibernate-mapping package="com.keli.pojo">
    <class name="Animal" table="t_animal" lazy="true">
        <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>

（4）、测试

public class ExtendsTest1 extends TestCase {
    public void testSave1() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Pig1 pig = new Pig1();
            pig.setName("猪猪");
            pig.setSex(true);
            pig.setWeight(100);
            session.save(pig);

            Bird1 bird = new Bird1();
            bird.setName("鸟鸟");
            bird.setSex(false);
            bird.setHeight(50);
            session.save(bird);
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
    * 采用load，通过Pig查询
    */
    public void testLoad1() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Pig1 pig = (Pig1) session.load(Pig1.class, 1);
            System.out.println(pig.getName());
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
    * 采用load，通过Animal查询
    */
    public void testLoad2() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Animal1 animal = (Animal1) session.load(Animal1.class, 1);
            System.out.println(animal.getName());
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
    * 采用load，通过Animal查询
    */
    public void testLoad3() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Animal1 animal = (Animal1) session.load(Animal1.class, 1);
            // 因为load默认值是lazy，因为我们看到的Animal的代理对象
            // 所以通过instanceof是反应不出真实的对象类型的
            // 因此load在默认情况下是不支持多态查询的
            if (animal instanceof Pig1) {
                System.out.println(animal.getName());
            } else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
    * 采用load，通过Animal查询,将<class>标签上的lazy=false
    */
    public void testLoad4() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Animal1 animal = (Animal1) session.load(Animal1.class, 1);
            // 可以正确的判断出Pig的类型，因为lazy=false，返回的是具体的Pig类型
            // 此时load支持多态查询
            if (animal instanceof Pig1) {
                System.out.println(animal.getName());
            } else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
    * 采用get，通过Animal查询
    */
    public void testLoad5() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();

            Animal1 animal = (Animal1) session.get(Animal1.class, 1);
            // 可以正确的判断出Pig的类型，因为返回的是具体的Pig类型
            // get支持多态查询
            if (animal instanceof Pig1) {
                System.out.println(animal.getName());
            } else {
                System.out.println("不是猪");
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }

    /**
    * 采用get，通过Animal查询
    */
    public void testLoad6() {
        Session session = null;
        try {
            session = HibernateInitialize.getSession();
            session.beginTransaction();
            // List animalList = session.createQuery("from Animal1").list();
            // for(Iterator iter = animalList.iterator();iter.hasNext();){
            // Animal1 a =(Animal1)iter.next();
            // //能够正确的鉴别出真实的类型，hql是支持多态查询的
            // if(a instanceof Pig1){
            // System.out.println("是Pig");
            // }else if(a instanceof Bird1){
            // 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 Pig1) {
                    System.out.println("是Pig");
                } else if (o instanceof Bird1) {
                    System.out.println("是Bird");
                }
            }
            session.getTransaction().commit();
        } catch (Exception e) {
            e.printStackTrace();
            session.getTransaction().rollback();
        } finally {
            HibernateInitialize.closeSession();
        }
    }
}

说明：

每棵继承树映射成一张表

1、理解如何映射
        因为类继承树肯定是对应多个类，要把多个类的信息存放在一张表中，必须有某种机制来区分哪些记录是属于哪个类的。
    这种机制就是，在表中添加一个字段，用这个字段的值来进行区分。用hibernate实现这种策略的时候，有如下步骤：
    父类用普通的<class>标签定义
    在父类中定义一个discriminator，即指定这个区分的字段的名称和类型
    如：<discriminator column=”XXX” type=”string”/>
    子类使用<subclass>标签定义，在定义subclass的时候，需要注意如下几点：
    Subclass标签的name属性是子类的全路径名
    在Subclass标签中，用discriminator-value属性来标明本子类的discriminator字段（用来区分不同类的字段）
    的值Subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），也可以与class标
    签平行。当subclass标签的定义与class标签平行的时候，需要在subclass标签中，添加extends属性，里面的值
    是父类的全路径名称。子类的其它属性，像普通类一样，定义在subclass标签的内部。

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

多态查询：在hibernate加载数据的时候能鉴别出正真的类型（instanceOf）

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