Hibernate学习（七）---【继承映射--每棵继承树映射成一张表】

每棵继承树映射成一张表

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支持多态查询

package com.bjsxt.hibernate;

public class Animal {

    private int id;

    private String name;

    private boolean sex;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public boolean isSex() {
        return sex;
    }

    public void setSex(boolean sex) {
        this.sex = sex;
    }
}

package com.bjsxt.hibernate;

public class Bird extends Animal {

    private int height;

    public int getHeight() {
        return height;
    }

    public void setHeight(int height) {
        this.height = height;
    }
}

package com.bjsxt.hibernate;

public class Pig extends Animal {

    private int weight;

    public int getWeight() {
        return weight;
    }

    public void setWeight(int weight) {
        this.weight = weight;
    }
}

<?xml version="1.0"?>

<!DOCTYPE hibernate-mapping PUBLIC

"-//Hibernate/Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.bjsxt.hibernate">

</id>

</subclass>

</subclass>

</class>

</hibernate-mapping>

package com.bjsxt.hibernate;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Session;

import junit.framework.TestCase;

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);
        }
    }

}

posted on 2009-11-01 18:45 生命的绽放阅读(318) 评论(0) 编辑收藏所属分类: Hibernate

新用户注册刷新评论列表


只有注册用户登录后才能发表评论。




网站导航: 博客园 IT新闻知识库 C++博客博问管理
相关文章: Hibernate Annotation -- (JPA) Hibernate学习（七）---【继承映射--每棵继承树映射成一张表】 Hibernate学习（六）---【一对多双项】 Hibernate学习（五）---【一对多单项】 Hibernate学习（四）---【一对一唯一外键双向关联】 Hibernate学习（二）---【一对一唯一外键单向关联】 Hibernate学习（三）---【一对一主键双向关联】 Hibernate学习（一）---【多对一】 Hibernate 高级查询技巧——集合过滤与子查询(转) Hibernate学习（九）---【继承关系】

想飞就别怕摔

Hibernate学习（七）---【继承映射--每棵继承树映射成一张表】

导航

统计

常用链接

留言簿(5)

随笔分类(94)

随笔档案(93)

文章分类(5)

文章档案(5)

相册

JAVA之桥

SQL之音

兄弟之窗

常用工具下载

积分与排名

最新评论

阅读排行榜