Hibernate深入学习(三)：继承与多态查询，joined-subclass与union-subclass

在上一篇中，我们对hibernate中3种继承有了初步了解，并对subclass进行了测试，以及知道了它的诸多缺点，这些缺点导致subclass在开发中并不常用，接下来我们看看剩下的两种继承方式：joined-subclass与union-subclass

本文中使用的实体类与测试代码同前篇，不再赘述

首先我们看看joined-class的实体映射文件：主要看元素

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.sina.join.subclass" auto-import="false">
    <class name="Person" table="joined_person">
        <id name="id" column="pid" length="10" type="java.lang.Integer">
            <generator class="increment"></generator>
        </id>
        <property name="name" type="java.lang.String" length="32" not-null="true"></property>
        <property name="age" type="java.lang.Integer" length="5" not-null="true"></property>

        <joined-subclass name="Worker" table="joined_worker">
            <key column="person_id"></key>
            <property name="job" type="java.lang.String" length="32"></property>
            <property name="unit" type="java.lang.String" length="32"></property>
        </joined-subclass>
    </class>
</hibernate-mapping>

我们已经知道joined-subclass是会产生两张表的，中的table用于指定子类表名，并且使用person_id来与父类表建立关联

测试代码见前篇，插入的测试结果如下：

Hibernate: 
    select
        max(pid) 
    from
        joined_person
Hibernate: 
    insert 
    into
        joined_person
        (name, age, pid) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        joined_person
        (name, age, pid) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        joined_worker
        (job, unit, person_id) 
    values
        (?, ?, ?)

可以看到发出了4条sql语句，除了第一句省略，其它共3条insert语句
因为joined-subclass采用的是父类表存储父类字段，子类表存储子类字段，用外键关联，
因此第一条insert语句对应的是session.save(person);
第二天insert语句是在 session.save(worker)时，将worker继承自父类的字段插入，
最后一条insert语句是插入将worker插入到子类表中，它直插入子类独有的字段

在做查询时，请使用类全名的形式，例如：

session.createQuery("from cn.sina.join.subclass.Person").list();

查询的结果如下：

Hibernate: 
    select
        person0_.pid as pid1_,
        person0_.name as name1_,
        person0_.age as age1_,
        person0_1_.job as job2_,
        person0_1_.unit as unit2_,
        case 
            when person0_1_.person_id is not null then 1 
            when person0_.pid is not null then 0 
        end as clazz_ 
    from
        joined_person person0_ 
    left outer join
        joined_worker person0_1_ 
            on person0_.pid=person0_1_.person_id
Hibernate: 
    select
        worker0_.person_id as pid1_,
        worker0_1_.name as name1_,
        worker0_1_.age as age1_,
        worker0_.job as job2_,
        worker0_.unit as unit2_ 
    from
        joined_worker worker0_ 
    inner join
        joined_person worker0_1_ 
            on worker0_.person_id=worker0_1_.pid
[Person [id=1, name=tom, age=10], Worker [job=washer, unit=bj], Person [id=3, name=tom, age=10], Worker [job=washer, unit=bj]]
[Worker [job=washer, unit=bj], Worker [job=washer, unit=bj]]

可以看出查询父类使用的是一个左外连接查询，同时查询出了子类，而查询子类使用的是一个内连接查询

---

最后一个是union-subclass，它和joined-subclass类似，它将父类对应一张表，子类对应一张表，此时的子类表包括了从父类中继承的字段，它的实体映射文件如下：注意看

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="cn.sina.union.subclass" auto-import="false">
    <class name="Person" table="union_person">
        <id name="id" column="pid" length="10" type="java.lang.Integer">
            <generator class="increment"></generator>
        </id>
        <property name="name" type="java.lang.String" length="32" not-null="true"></property>
        <property name="age" type="java.lang.Integer" length="5" not-null="true"></property>

        <union-subclass name="Worker" table="union_worker">
            <property name="job" type="java.lang.String" length="32"></property>
            <property name="unit" type="java.lang.String" length="32"></property>
        </union-subclass>
    </class>
</hibernate-mapping>

可以看出union-subclass只需要指定一个表名即可

插入测试结果很简单，就是发出两条inert语句，插入到对应的表中即可

Hibernate: 
    select
        max(ids_.pid) 
    from
        ( select
            pid 
        from
            union_person 
        union
        select
            pid 
        from
            union_worker 
    ) ids_
Hibernate: 
    insert 
    into
        union_person
        (name, age, pid) 
    values
        (?, ?, ?)
Hibernate: 
    insert 
    into
        union_worker
        (name, age, job, unit, pid) 
    values
        (?, ?, ?, ?, ?)

查询结果如下(hql也要使用类全名)

Hibernate: 
    select
        person0_.pid as pid3_,
        person0_.name as name3_,
        person0_.age as age3_,
        person0_.job as job4_,
        person0_.unit as unit4_,
        person0_.clazz_ as clazz_ 
    from
        ( select
            pid,
            name,
            age,
            null as job,
            null as unit,
            0 as clazz_ 
        from
            union_person 
        union
        select
            pid,
            name,
            age,
            job,
            unit,
            1 as clazz_ 
        from
            union_worker 
    ) person0_
Hibernate: 
    select
        worker0_.pid as pid3_,
        worker0_.name as name3_,
        worker0_.age as age3_,
        worker0_.job as job4_,
        worker0_.unit as unit4_ 
    from
        union_worker worker0_
[Person [id=1, name=tom, age=10], Worker [job=washer, unit=bj]]
[Worker [job=washer, unit=bj]]

我们着重看一下父类的查询sql，比较有意思，它也将子类查询出来了，它先通过union将两张表联合查询，再从联合查询的结果中获取结果。

最后分析下二者的缺点：
1.插入与查询的效率都低下
2.union-subclass在更新父类表时效率低下