每个具体类映射成一张表

1、理解如何映射
 这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表，而且这个表的信息是完备的，
 即包含了所有从父类继承下来的属性映射的字段（这就是它跟joined-subclass的不同之处，
 joined-subclass定义的子类的表，只包含子类特有属性映射的字段）。实现这种策略的时候，有如下步骤：
 父类用普通<class>标签定义即可
 子类用<union-subclass>标签定义，在定义union-subclass的时候，需要注意如下几点：
 Union-subclass标签不再需要包含key标签（与joined-subclass不同）
 Union-subclass标签，既可以被class标签所包含（这种包含关系正是表明了类之间的继承关系），
 也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候，需要在Union-subclass
 标签中，添加extends属性，里面的值是父类的全路径名称。子类的其它属性，像普通类一样，
 定义在Union-subclass标签的内部。这个时候，虽然在union-subclass里面定义的只有子类的属性，
 但是因为它继承了父类，所以，不需要定义其它的属性，在映射到数据库表的时候，依然包含了父类的所
 有属性的映射字段。
 
注意：在保存对象的时候id是不能重复的（不能使用自增生成主键）

例子：

每个具体类映射成一张表

t_pig

id	name	sex	weight
1	猪猪	true	100

t_bird

id	name	sex	height
2	鸟鸟	false	50

extends.hbm.xml
 1<?xml version="1.0"?>
 2<!DOCTYPE hibernate-mapping PUBLIC 
 3    "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 4    "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 5<hibernate-mapping package="com.bjsxt.hibernate">
 6    <class name="Animal" abstract="true">
 7        <id name="id">
 8            <generator class="assigned"/>
 9        </id>
10        <property name="name"/>
11        <property name="sex"/>
12        <union-subclass name="Pig" table="t_pig">
13            <property name="weight"/>
14        </union-subclass>
15        <union-subclass name="Bird" table="t_bird">
16            <property name="height"/>
17        </union-subclass>
18    </class>
19</hibernate-mapping>

ExtendsTest.java
  1package com.bjsxt.hibernate;
  2
  3import java.util.Iterator;
  4import java.util.List;
  5
  6import org.hibernate.Session;
  7
  8import junit.framework.TestCase;
  9
 10public class ExtendsTest extends TestCase {
 11
 12    public void testSave1() {
 13        Session session = null;
 14        try {
 15            session = HibernateUtils.getSession();
 16            session.beginTransaction();
 17            
 18            Pig pig = new Pig();
 19            pig.setId(1);
 20            pig.setName("猪猪");
 21            pig.setSex(true);
 22            pig.setWeight(100);
 23            session.save(pig);
 24            
 25            Bird bird = new Bird();
 26            bird.setId(2);
 27            bird.setName("鸟鸟");
 28            bird.setSex(false);
 29            bird.setHeight(50);
 30            session.save(bird);
 31            
 32            session.getTransaction().commit();
 33        }catch(Exception e) {
 34            e.printStackTrace();
 35            session.getTransaction().rollback();
 36        }finally {
 37            HibernateUtils.closeSession(session);
 38        }
 39    }    
 40    
 41    /** *//**
 42     * 采用load，通过Pig查询
 43     */
 44    public void testLoad1() {
 45        Session session = null;
 46        try {
 47            session = HibernateUtils.getSession();
 48            session.beginTransaction();
 49            
 50            Pig pig = (Pig)session.load(Pig.class, 1);
 51            System.out.println(pig.getName());
 52            
 53            session.getTransaction().commit();
 54        }catch(Exception e) {
 55            e.printStackTrace();
 56            session.getTransaction().rollback();
 57        }finally {
 58            HibernateUtils.closeSession(session);
 59        }
 60    }
 61    
 62    /** *//**
 63     * 采用load，通过Animal查询
 64     */
 65    public void testLoad2() {
 66        Session session = null;
 67        try {
 68            session = HibernateUtils.getSession();
 69            session.beginTransaction();
 70            
 71            Animal animal = (Animal)session.load(Animal.class, 1);
 72            System.out.println(animal.getName());
 73            
 74            session.getTransaction().commit();
 75        }catch(Exception e) {
 76            e.printStackTrace();
 77            session.getTransaction().rollback();
 78        }finally {
 79            HibernateUtils.closeSession(session);
 80        }
 81    }            
 82    
 83    /** *//**
 84     * 采用load，通过Animal查询
 85     */
 86    public void testLoad3() {
 87        Session session = null;
 88        try {
 89            session = HibernateUtils.getSession();
 90            session.beginTransaction();
 91            
 92            Animal animal = (Animal)session.load(Animal.class, 1);
 93            
 94            //因为load默认只是lazy，因为我们看到的是Animal的代理对象
 95            //所以通过instanceof是反应不出正真的对象类型的
 96            //因此load在默认情况下是不支持多态查询的
 97            if (animal instanceof Pig) {
 98                System.out.println(animal.getName());
 99            }else {
100                System.out.println("不是猪");
101            }
102            session.getTransaction().commit();
103        }catch(Exception e) {
104            e.printStackTrace();
105            session.getTransaction().rollback();
106        }finally {
107            HibernateUtils.closeSession(session);
108        }
109    }            
110    
111    /** *//**
112     * 采用load，通过Animal查询,将<class>标签上的lazy=false
113     */
114    public void testLoad4() {
115        Session session = null;
116        try {
117            session = HibernateUtils.getSession();
118            session.beginTransaction();
119            
120            Animal animal = (Animal)session.load(Animal.class, 1);
121            //可以正确的判断出Pig的类型，因为lazy=false，返回的是具体的Pig类型
122            //此时load支持多态查询
123            if (animal instanceof Pig) {
124                System.out.println(animal.getName());
125            }else {
126                System.out.println("不是猪");
127            }
128            session.getTransaction().commit();
129        }catch(Exception e) {
130            e.printStackTrace();
131            session.getTransaction().rollback();
132        }finally {
133            HibernateUtils.closeSession(session);
134        }
135    }        
136    
137    /** *//**
138     * 采用get，通过Animal查询
139     */
140    public void testLoad5() {
141        Session session = null;
142        try {
143            session = HibernateUtils.getSession();
144            session.beginTransaction();
145            
146            //可以正确的判断出Pig的类型，因为返回的是具体的Pig类型
147            //get支持多态查询
148            Animal animal = (Animal)session.get(Animal.class, 1);
149
150            if (animal instanceof Pig) {
151                System.out.println(animal.getName());
152            }else {
153                System.out.println("不是猪");
154            }
155            session.getTransaction().commit();
156        }catch(Exception e) {
157            e.printStackTrace();
158            session.getTransaction().rollback();
159        }finally {
160            HibernateUtils.closeSession(session);
161        }
162    }    
163    
164    /** *//**
165     * 采用get，通过Animal查询
166     */
167    public void testLoad6() {
168        Session session = null;
169        try {
170            session = HibernateUtils.getSession();
171            session.beginTransaction();
172//            List animalList = session.createQuery("from Animal").list();
173//            for (Iterator iter = animalList.iterator(); iter.hasNext();) {
174//                Animal a = (Animal)iter.next();
175//                //能够正确的鉴别出正真的类型，hql是支持多态查询的
176//                if (a instanceof Pig) {
177//                    System.out.println("是Pig");
178//                }else if (a instanceof Bird) {
179//                    System.out.println("是bird");
180//                } 
181//            }
182            
183            List list = session.createQuery("from java.lang.Object").list();
184            for (Iterator iter=list.iterator(); iter.hasNext();) {
185                Object o = iter.next();
186                if (o instanceof Pig) {
187                    System.out.println("是Pig");
188                }else if (o instanceof Bird) {
189                    System.out.println("是bird");
190                } 
191            }
192            session.getTransaction().commit();
193        }catch(Exception e) {
194            e.printStackTrace();
195            session.getTransaction().rollback();
196        }finally {
197            HibernateUtils.closeSession(session);
198        }
199    }    
200    
201}
202

转载于:https://www.cnblogs.com/ksyou/archive/2009/04/02/1428112.html