整个继承树映射到一张表

转载 2012年03月30日 16:06:58

人类(Person)  , 男人(Men)继承"人"类, 女人(Women)继承"人"类,  UML如下:
















映射到如下的t_person表中, 有以下6个字段:

1 int  id                             //主键

2 varchar  name                 //父类中的姓名

3 int  age                          //父类中的年龄      

4 int/varchar   type             //区分"人","男人","女人"  的专用字段, 默认类型是varchar, 也可以指定为int类型.  叫鉴别器字段

                                                           //Person类:type值设为0, Men类:type值设为1, Women类:type值设为2


5 varchar   a                      //"男人"类专有属性   

6 varchar   b                      //"女人"类专有属性    

Person, Men, Women 三个类这里就不显示了,但简单, 想看了附件中有源码

Person.hbm.xml 如下:

Xml代码  收藏代码
  1. <?xml version="1.0"?>  
  2.  
  3. <!DOCTYPE hibernate-mapping PUBLIC   
  4.  
  5.     "-//Hibernate/Hibernate Mapping DTD 3.0//EN"  
  6.     "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">  
  7.  
  8. <hibernate-mapping   
  9.   
  10.   
  11.     package="extends_test.extends_1" auto-import="false">  
  12.   
  13.     <class name="Person" table="t_person" discriminator-value="0"><!-- "鉴别值"为0 -->  
  14.   
  15.   
  16.         <!-- 父类的属性 -->          
  17.   
  18.   
  19.         <id name="id">  
  20.   
  21.   
  22.             <generator class="native"/>  
  23.   
  24.   
  25.         </id>   
  26.   
  27.         <!-- 重点:鉴别器 -->  
  28.   
  29.   
  30.         <!-- 指定type字段,做区分父子具体类型用 ,各类还要指定"鉴别值": discriminator-value="1"-->  
  31.   
  32.   
  33.         <discriminator column="type" type="int"/>           
  34.  
  35.         <!-- 父类的属性 -->  
  36.   
  37.   
  38.         <property name="name"/>  
  39.   
  40.   
  41.         <!-- 父类的属性 -->  
  42.   
  43.   
  44.         <property name="age"/>        
  45.   
  46.         <!-- Mem子类的映射 -->  
  47.  
  48.         <subclass name="Men" discriminator-value="1"><!-- "鉴别值"为1 -->  
  49.   
  50.   
  51.             <!-- Men类专有的属性a -->  
  52.   
  53.   
  54.             <property name="a"/>  
  55.   
  56.   
  57.         </subclass>  
  58.         <!-- Women子类的映射 -->
  59.         <subclass name="Women" discriminator-value="2"><!-- "鉴别值"为2 -->  
  60.   
  61.   
  62.             <!-- Women类专有的属性b -->  
  63.   
  64.   
  65.             <property name="b"/>  
  66.   
  67.   
  68.         </subclass>  
  69.   
  70.   
  71.     </class>    
  72.   
  73.   
  74. </hibernate-mapping>

保存与查询操作:

Java代码  收藏代码
  1. package extends_test.extends_1;  
  2. import org.hibernate.Session;  
  3. import org.hibernate.Transaction;  
  4. import dao.HibernateUtil;  
  5. /** 
  6.  * 继承关系的映射(方法一) 
  7.  *  
  8.  * 总个继承树映射到一张表
  9.  * 
  10.  */
  11.   
  12. public class Test
  13. {
  14.     /** 
  15.      * @param args
  16.      */  
  17.     public static void main(final String[] args)  
  18.     {  
  19.         //add();  
  20.         query();  
  21.     }
  22.     /**
  23.      * 查询测试
  24.      */
  25.   
  26.     public static void query()  
  27.     {
  28.         Session session = null;  
  29.         try
  30.   
  31.         {
  32.             session = HibernateUtil.getSeesion();  
  33.   
  34.   
  35.             final Person p = (Person) session.get(Person.class2); //ID为2的记录是  Men类型  
  36.   
  37.   
  38.             System.out.println(p.getClass());  
  39.   
  40.   
  41.             //get()第一个参数用了 Person.class  
  42.   
  43.   
  44.             //能识别出是class extends_test.extends_1.Men类型  
  45.         }
  46.         finally  
  47.         {  
  48.             if (session != null)  

  49.             {
  50.                 session.close();
  51.             }
  52.         }
  53.     }
  54.   
  55.     /**
  56.      * 添加测试 
  57.      */
  58.     public static void add()  
  59.     {  
  60.         final Person p1 = new Person();  

  61.         p1.setName("我是Person类");  
  62.  
  63.         final Men m1 = new Men();  

  64.         m1.setName("我是男人类");  

  65.         m1.setA("a");  

  66.         final Women w1 = new Women();  
  67.         w1.setName("我是女人类");  
  68.         w1.setB("b");  
  69.         Session session = null;  
  70.         try
  71.         {  
  72.             session = HibernateUtil.getSeesion();  
  73.  
  74.             final Transaction tx = session.beginTransaction();  
  75.  
  76.             session.save(p1);  
  77.  
  78.             session.save(m1);  
  79.  
  80.             session.save(w1);  

  81.             tx.commit();  

  82.             //SQL如下 
  83.             //Hibernate: insert into t_person (name, age, type) values (?, ?, 0)  
  84.   
  85.   
  86.             //Hibernate: insert into t_person (name, age, a, type) values (?, ?, ?, 1)  
  87.   
  88.   
  89.             //Hibernate: insert into t_person (name, age, b, type) values (?, ?, ?, 2)  

  90.         }  
  91.         finally  
  92.         {  
  93.             if (session != null)  
  94.             {
  95.                 session.close();  
  96.             }  
  97.         }  
  98.     }  


相关文章推荐

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

一、实体继承关系(类继树承结映射成一张表)(1)实体类与表间的关系                    Animal                   t_animal              ...

Hibernate继承映射之每颗类继承树一张表

动物Animal为基类,Pig和Bird为子类,他们之间存在继承关系,

继承映射之每棵类继承树一张表

鉴别字段,每棵类继承树一张表的关键点就在这里.因为类继承树肯定是对应多个类,要把多个类的信息存放在一张表中,必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是,在表中添加一个字段,用这个字段的值...
  • yjsuge
  • yjsuge
  • 2011年07月27日 09:57
  • 482

hibernate映射继承关系(一):一张表对应一整棵类继承树

[翻译] hibernate映射继承关系(一):一张表对应一整棵类继承树 2人收藏此文章, 我要收藏发表于1年前(2012-05-22 16:34) , 已有482次阅读 ,共0个评论 ...

继承关系_整个继承树映射到一张表_每个类映射到一张表_鉴别器与内连接相结合(混合)_每个具体类映射一张独立表

整个继承树映射到一张表_每个类映射到一张表_鉴别器与内连接相结合(混合)_每个具体类映射一张独立表  整个继承树映射到一张表 描述: 在父类的配置文件中 1、添加鉴别器标签 column="...
  • dwt1220
  • dwt1220
  • 2012年02月09日 16:06
  • 633

SSH框架之Hibernate的继承映射的形式一(一张表)

(不推荐用)*Hibernate的继承映射形式一:所有子类映射到一张表 (数据库只有一张表*) 1、什么情况用:子类教多,且子类较为简单,即只有个别属性! 2、好处:因为使用一个映射文件, 减少了映射...

Hibernate继承映射方式之每个子类一张表

首先解释下“每个子类一张表”的含义:每个子类使用一张表只存储它特有的属性,然后与父类所对应的表以一对一主键关联的方式关联起来。 现在有四个类Company2、Employee2、SalaryEmpl...

hibernate继承关系映射方法(一)--共享一张表

对于如下关系: Person.java package com.hust.PO; public class Person { private Integer id; ...

hibernate继承关系映射关系方法(二)--每个子类一张表

TPS:所谓“每个子类一张表(Table Per Subclass)”:父类一张表,每个子类一张表,父类的表保存公共有信息,子类的表只保存自己特有的信息      这种策略是使用标签来定义子类的。父...

hibernate继承关系映射方法(三)--每个具体类一张表TPC

TPC:所谓是“每个具体类一张表(table per concrete class)”的意思是:使继承体系中每一个子类都对应数据库中的一张表。每一个子类对应的数据库表都包含了父类的信息,并且包含了自己...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:整个继承树映射到一张表
举报原因:
原因补充:

(最多只允许输入30个字)