每棵继承树映射成一张表
1、理解如何映射
因为类继承树肯定是对应多个类,要把多个类的信息存放在一张表中,必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是,在表中添加一个字段,用这个字段的值来进行区分。用hibernate实现这种策略的时候,有如下步骤:1)父类用普通的<class>标签定义、2) 在父类中定义一个discriminator,即指定这个区分的字段的名称和类型,如:<discriminator column=”XXX” type=”string”/>、3)子类使用<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支持多态查询
每个子类映射成一张表
1、理解如何映射
这种策略是使用joined-subclass标签来定义子类的。父类、子类,每个类都对应一张数据库表。在父类对应的数据库表中,实际上会存储所有的记录,包括父类和子类的记录;在子类对应的数据库表中,这个表只定义了子类中所特有的属性映射的字段。子类与父类,通过相同的主键值来关联。实现这种策略的时候,有如下步骤:1)父类用普通的<class>标签定义即可、2)父类不再需要定义discriminator字段、3)子类用<joined-subclass>标签定义,在定义joined-subclass的时候,需要注意如下几点:Joined-subclass标签的name属性是子类的全路径名、Joined-subclass标签需要包含一个key标签,这个标签指定了子类和父类之间是通过哪个字段来关联的。如:<key column=”PARENT_KEY_ID”/>,这里的column,实际上就是父类的主键对应的映射字段名称。Joined-subclass标签,既可以被class标签所包含(这种包含关系正是表明了类之间的继承关系),也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候,需要在Joined-subclass标签中,添加extends属性,里面的值是父类的全路径名称。子类的其它属性,像普通类一样,定义在joined-subclass标签的内部。
每个具体类映射成一张表
1、理解如何映射
这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表,而且这个表的信息是完备的,即包含了所有从父类继承下来的属性映射的字段(这就是它跟joined-subclass的不同之处,joined-subclass定义的子类的表,只包含子类特有属性映射的字段)。实现这种策略的时候,有如下步骤:1)父类用普通<class>标签定义即可、2)子类用<union-subclass>标签定义,在定义union-subclass的时候,需要注意如下几点:Union-subclass标签不再需要包含key标签(与joined-subclass不同)、Union-subclass标签,既可以被class标签所包含(这种包含关系正是表明了类之间的继承关系),也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候,需要在Union-subclass、标签中,添加extends属性,里面的值是父类的全路径名称。子类的其它属性,像普通类一样,定义在Union-subclass标签的内部。这个时候,虽然在union-subclass里面定义的只有子类的属性,但是因为它继承了父类,所以,不需要定义其它的属性,在映射到数据库表的时候,依然包含了父类的所有属性的映射字段。
注意:在保存对象的时候id是不能重复的(不能使用自增生成主键)
1、理解如何映射
因为类继承树肯定是对应多个类,要把多个类的信息存放在一张表中,必须有某种机制来区分哪些记录是属于哪个类的。这种机制就是,在表中添加一个字段,用这个字段的值来进行区分。用hibernate实现这种策略的时候,有如下步骤:1)父类用普通的<class>标签定义、2) 在父类中定义一个discriminator,即指定这个区分的字段的名称和类型,如:<discriminator column=”XXX” type=”string”/>、3)子类使用<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支持多态查询
//extends.hbm.xml <hibernate-mapping package="com.bjsxt.hibernate"> <class name="Animal" table="t_animal" lazy="false"> <id name="id"> <generator class="native"/> </id> <!-- 鉴别器,用于区别子类类型 --> <discriminator column="type" type="string" length = "2"/> <property name="name" length = "10"/> <property name="sex"/> <!-- 子类subclass,name指定子类 ,discriminator-value鉴别值指定子类--> <subclass name="Pig" discriminator-value="P"> <property name="weight"/> </subclass> <subclass name="Bird" discriminator-value="B"> <property name="height"/> </subclass> </class> </hibernate-mapping>
每个子类映射成一张表
1、理解如何映射
这种策略是使用joined-subclass标签来定义子类的。父类、子类,每个类都对应一张数据库表。在父类对应的数据库表中,实际上会存储所有的记录,包括父类和子类的记录;在子类对应的数据库表中,这个表只定义了子类中所特有的属性映射的字段。子类与父类,通过相同的主键值来关联。实现这种策略的时候,有如下步骤:1)父类用普通的<class>标签定义即可、2)父类不再需要定义discriminator字段、3)子类用<joined-subclass>标签定义,在定义joined-subclass的时候,需要注意如下几点:Joined-subclass标签的name属性是子类的全路径名、Joined-subclass标签需要包含一个key标签,这个标签指定了子类和父类之间是通过哪个字段来关联的。如:<key column=”PARENT_KEY_ID”/>,这里的column,实际上就是父类的主键对应的映射字段名称。Joined-subclass标签,既可以被class标签所包含(这种包含关系正是表明了类之间的继承关系),也可以与class标签平行。 当Joined-subclass标签的定义与class标签平行的时候,需要在Joined-subclass标签中,添加extends属性,里面的值是父类的全路径名称。子类的其它属性,像普通类一样,定义在joined-subclass标签的内部。
//extends.hbm.xml <hibernate-mapping package="com.bjsxt.hibernate"> <class name="Animal" table="t_animal"> <id name="id"> <generator class="native"/> </id> <property name="name" length = "10"/> <property name="sex"/> <!-- joined-subclass,name指定具体子类,table生成表名 --> <joined-subclass name="Pig" table="t_pig"> <key column="pid"/> <!-- 加一外键指向t_animal --> <property name="weight"/> </joined-subclass> <joined-subclass name="Bird" table="t_bird"> <key column="bid"/> <property name="height"/> </joined-subclass> </class> </hibernate-mapping>
每个具体类映射成一张表
1、理解如何映射
这种策略是使用union-subclass标签来定义子类的。每个子类对应一张表,而且这个表的信息是完备的,即包含了所有从父类继承下来的属性映射的字段(这就是它跟joined-subclass的不同之处,joined-subclass定义的子类的表,只包含子类特有属性映射的字段)。实现这种策略的时候,有如下步骤:1)父类用普通<class>标签定义即可、2)子类用<union-subclass>标签定义,在定义union-subclass的时候,需要注意如下几点:Union-subclass标签不再需要包含key标签(与joined-subclass不同)、Union-subclass标签,既可以被class标签所包含(这种包含关系正是表明了类之间的继承关系),也可以与class标签平行。 当Union-subclass标签的定义与class标签平行的时候,需要在Union-subclass、标签中,添加extends属性,里面的值是父类的全路径名称。子类的其它属性,像普通类一样,定义在Union-subclass标签的内部。这个时候,虽然在union-subclass里面定义的只有子类的属性,但是因为它继承了父类,所以,不需要定义其它的属性,在映射到数据库表的时候,依然包含了父类的所有属性的映射字段。
注意:在保存对象的时候id是不能重复的(不能使用自增生成主键)
//extends.hbm.xml <hibernate-mapping package="com.bjsxt.hibernate"> <class name="Animal" table="t_animal" abstract = "true"> <id name="id"><!-- abstract = "true" 不会生成animal表 --> <generator class="native"/> </id> <property name="name" length = "10"/> <property name="sex"/> <!-- union-subclass,name指定具体子类 --> <union-subclass name="Pig" table="t_pig"> <property name="weight"/> </union-subclass> <union-subclass name="Bird" table="t_bird"> <property name="height"/> </union-subclass> </class> </hibernate-mapping>
//model 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; } } public class Bird extends Animal { private int height; public int getHeight() { return height; } public void setHeight(int height) { this.height = height; } } public class Pig extends Animal { private int weight; public int getWeight() { return weight; } public void setWeight(int weight) { this.weight = weight; } }
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 = (Pig)session.load(Pig.class, 1); /* *Hibernate: select pig0_.id as id0_0_, pig0_.name as name0_0_, * pig0_.sex as sex0_0_,pig0_.weight as weight0_0_ from t_animal pig0_ * where pig0_.id=? and pig0_.type='P' * 通过鉴别值P鉴别类型 */ 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 = (Animal)session.load(Animal.class, 1); /* * Hibernate: select animal0_.id as id0_0_, animal0_.name as name0_0_, * animal0_.sex as sex0_0_, animal0_.weight as weight0_0_, * animal0_.height as height0_0_, animal0_.type as type0_0_ from * t_animal animal0_ where animal0_.id=? */ 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在默认情况下是不支持多态查询的 //多态查询:在hibernate加载数据的时候能鉴别出正真的类型(instanceOf) //不会发出SQL语句 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) { /* * Hibernate: select animal0_.id as id0_0_, animal0_.name as name0_0_, * animal0_.sex as sex0_0_, animal0_.weight as weight0_0_, * animal0_.height as height0_0_, animal0_.type as type0_0_ from * t_animal animal0_ where animal0_.id=? */ 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()); /* * Hibernate: select animal0_.id as id0_0_, animal0_.name as name0_0_, * animal0_.sex as sex0_0_, animal0_.weight as weight0_0_, * animal0_.height as height0_0_, animal0_.type as type0_0_ from * t_animal animal0_ where animal0_.id=? */ }else { System.out.println("不是猪"); } session.getTransaction().commit(); }catch(Exception e) { e.printStackTrace(); session.getTransaction().rollback(); }finally { HibernateUtils.closeSession(session); } } /** * 采用hql */ @SuppressWarnings("unchecked") public void testLoad6() { Session session = null; try { session = HibernateUtils.getSession(); session.beginTransaction(); /* * Hibernate: select animal0_.id as id0_, animal0_.name as name0_, * animal0_.sex as sex0_, animal0_.weight as weight0_, * animal0_.height as height0_, animal0_.type as type0_ from * t_animal animal0_ */ /*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(); /* * Hibernate: select animal0_.id as id0_, animal0_.name as name0_, * animal0_.sex as sex0_, animal0_.weight as weight0_, * animal0_.height as height0_, animal0_.type as type0_ from t_animal animal0_ */ 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); } } }
发表评论
-
JAVA手动连接数据库
2011-04-17 10:02 868// jsp <%@ page language=&q ... -
hibernate CoreAPI
2011-04-14 09:22 662// model import java.util.Date ... -
抓取策略
2011-03-31 09:41 6641、hibernate抓取策略(单端代理的批量抓取)(抓取当前 ... -
缓存(查询优化)
2011-03-31 08:57 6361)hibernate一级缓存:一级缓存很短和session的 ... -
hibernate查询语言(hql)
2011-03-30 08:57 636在hql中关键字不区分大 ... -
读取文件夹生成目录树
2011-03-30 08:18 1382// model import java.util.Set; ... -
悲观锁、乐观锁
2011-03-28 09:05 6361、悲观锁(处理并行问题):悲观锁的实现,通常依赖于数据库机制 ... -
component、composite、collection映射
2011-03-28 08:55 7011、component(组件)映射:在hibernate中,c ... -
lazy策略
2011-03-27 13:56 564hibernate lazy策略可以使用在: ... -
多对多关联映射
2011-03-26 11:05 596hibernate多对多关联映射(单向User----> ... -
一对多关联映射
2011-03-26 10:55 703hihernate一对多关联映射(单向Classes----- ... -
session_flush
2011-03-26 10:46 705session flush测试: session flush ... -
一对一唯一外键关联映射
2011-03-26 10:37 645hibernate一对一唯一外键关联映射(单向关联Person ... -
一对一主键关联映射
2011-03-26 10:02 572hibernate一对一主键关联映射(单向关联Person-- ... -
多对一关联映射
2011-03-26 09:31 621hibernate多对一关联映射 关联映射的本质: * 将 ... -
基本映射
2011-03-26 09:14 594hibernate基本映射 实体类---表 实体类中的普通属 ... -
Hibernate基础
2011-03-24 08:34 784import org.hibernate.cfg.Config ... -
get、load加载
2011-03-24 08:30 458junit简介: ... -
HQL(对象查询语言) 和 SQL(结构化查询语言)
2011-02-18 08:44 11271. 查询整个映射对象所有字段 //返回Student对象的 ... -
java基础
2011-02-17 09:09 445使用equals函数 str.e ...
相关推荐
继承映射详细,非常实用的学习资料继承映射详细,非常实用的学习资料
继承映射
Hibernate继承映射+C3P0代码
Hibernate案例与专题-继承映射策略。详细介绍了Hibernate继承映射策略。
针对hibernate的继承映射部分做了几个测试的例子,更加直观的阐述了继承映射的几种方式以及对应的表结构方式,文件被分割成3部分 http://download.csdn.net/source/259075 http://download.csdn.net/source/259072 ...
针对hibernate的继承映射部分做了几个测试的例子,更加直观的阐述了继承映射的几种方式以及对应的表结构方式,文件被分割成3部分 http://download.csdn.net/source/259075 http://download.csdn.net/source/259072 ...
博文链接:https://shaqiang32.iteye.com/blog/201319
T21.6_继承映射 java 经典教程 经典教材
hibernate的继承映射(InheritanceMapping)[文].pdf
Hibernate的继承映射 --每个继承层次一张表 -- 每个具体类一张表 -- 每个类一张表
Hibernate中的映射可以将类与表对应,并利用类的继承特性,这里我们就来看一下Java的Hibernate框架中的继承映射学习教程
http://blog.csdn.net/e421083458/article/details/8794127 该源码为Hibernate教程配套源码
从多种情况介绍Hibernate的继承多态映射关系
用Hibernate映射继承关系
使用jpa映射关联和继承
简单的使用了hibernate的继承,用idea搭建,适合刚刚开始学习hibernate的初学者参考
NULL 博文链接:https://wintys.iteye.com/blog/426031
NULL 博文链接:https://cdxs2.iteye.com/blog/1934884