- 浏览: 1237415 次
- 性别:
- 来自: 杭州
文章分类
- 全部博客 (193)
- ant/maven (6)
- algorithm (5)
- tomcat/weblogic/jboss (6)
- javascript/jquery (13)
- java (33)
- flex/flash (0)
- JPA/Hibernate/myBatis (18)
- java concurrent (7)
- test (2)
- windows/linux (6)
- java collection (7)
- design pattern (2)
- life/health (3)
- database (12)
- IDE (4)
- spring/ejb (20)
- html/css/ckeditor (7)
- jsp/servlet (3)
- java io (13)
- java security (4)
- jni (0)
- svn/git (2)
- english (2)
- java jmx (1)
- xml (1)
- struts/springmvc (9)
- middleware (2)
- cache (1)
- cglib (3)
最新评论
-
jlotusYo:
博主,真感谢。
Java 密码扩展无限制权限策略文件 -
senninha:
这个。。是api说明吧。。
ScheduledExecutorService 源码分析 -
zoutao2008:
请问大文件如何处理?按你这种方式的话,文件超过200M时就会报 ...
hessian系列之二:上传文件 -
lwj1113:
lwj1113 写道谢谢博主这么细致的demo;在系列五中通过 ...
myBatis系列之五:与Spring3集成 -
lwj1113:
谢谢博主这么细致的demo;在系列五中通过testng测试类跑 ...
myBatis系列之五:与Spring3集成
以Department和Employee实体为例。Developer和Tester都继承Employee。
Department类和Employee类和映射的声明:
Hibernate 多对一关联配置
Developer类:
Tester类:
1. 整个继承关系映射到一张表(single-table-per-hierarchy)
优点:不管是查询父类还是子类,只需要查询一张表,性能比较好。
缺点:扩展性不好,当需要增加子类或者属性,我们需要往表中增加字段,很多字段都空置,不符合面向对象编程的思想。
修改Employee.hbm.xml
2. 每个类映射到一个表(joined-subclass)
每个子类实例的数据会放在两张表里:父类表(基本属性)和子类表(子类特有的属性)
优点:父类表中没有空置的字段。
缺点:查询子类数据需要连表查询(父类表和子类表),效率不高。
适合:子类较少,每个子类的属性都各不相同。
修改Employee.hbm.xml:
3. 鉴别器和内联器结合
充分利用1和2的优点
Employee.hbm.xml:
4. 每个具体类映射一张独立表(union-subclass)
和2不同,这里子类的所有属性(包括从父类继承的)会保存到一张独立的表中。
Employee.hbm.xml:
这里的id生成器用的是hilo(或uuid)。
native(mysql里是自动增长)方式不可以:
id值会重复。
如Employee, Developer和Tester三张独立的表,每张表的id都是从1开始自增长的。
当查询id为1的Employee的时候,会查询到3个对象。
Department类和Employee类和映射的声明:
Hibernate 多对一关联配置
Developer类:
public class Developer extends Employee { private String develop; public Developer() { } public Developer(String name) { super(name); } // Getters and setters are omitted
Tester类:
public class Tester extends Employee { private String test; public Tester(){ } public Tester(String name) { super(name); } // Getters and setters are omitted }
1. 整个继承关系映射到一张表(single-table-per-hierarchy)
优点:不管是查询父类还是子类,只需要查询一张表,性能比较好。
缺点:扩展性不好,当需要增加子类或者属性,我们需要往表中增加字段,很多字段都空置,不符合面向对象编程的思想。
修改Employee.hbm.xml
<class name="Employee" discriminator-value="0"> <id name="id"> <generator class="native"/> </id> <!-- 增加一个字段,以区别对应的是哪个实体 --> <discriminator column="type" type="string"/> <property name="name" length="20" not-null="true"/> <many-to-one name="department" column="depart_id" cascade="save-update" fetch="join" lazy="no-proxy" /> <!-- Inheritance - Single-Table-Per-Hierarchy --> <subclass name="Developer" discriminator-value="3"> <property name="develop" length="40"/> </subclass> <subclass name="Tester" discriminator-value="4"> <property name="test" length="40"/> </subclass> </class>
Session s = null; Transaction tx = null; Department depart = new Department("FCI"); Employee em1 = new Employee("John"); em1.setDepartment(depart); Developer em2 = new Developer("Lucy"); em2.setDepartment(depart); em2.setDevelop("Java"); Tester em3 = new Tester("Lily"); em3.setDepartment(depart); em3.setTest("Load runner"); try { s = HibernateUtil.getSession(); tx = s.beginTransaction(); s.save(em1); s.save(em2); s.save(em3); tx.commit(); } catch (HibernateException e) { tx.rollback(); e.printStackTrace(); } finally { s.close(); }
2. 每个类映射到一个表(joined-subclass)
每个子类实例的数据会放在两张表里:父类表(基本属性)和子类表(子类特有的属性)
优点:父类表中没有空置的字段。
缺点:查询子类数据需要连表查询(父类表和子类表),效率不高。
适合:子类较少,每个子类的属性都各不相同。
修改Employee.hbm.xml:
<class name="Employee"> <id name="id"> <generator class="native"/> </id> <property name="name" length="20" not-null="true"/> <many-to-one name="department" column="depart_id" cascade="save-update" fetch="join" lazy="no-proxy" /> <!-- Inheritance --> <joined-subclass name="Developer"> <key column="develop_id" foreign-key="id"/> <property name="develop" length="40"/> </joined-subclass> <joined-subclass name="Tester"> <key column="test_id" foreign-key="id"/> <property name="test" length="40"/> </joined-subclass> </class> </hibernate-mapping>
3. 鉴别器和内联器结合
充分利用1和2的优点
Employee.hbm.xml:
<hibernate-mapping package="com.john.myhibernate.domain"> <class name="Employee" discriminator-value="0"> <id name="id"> <generator class="native"/> </id> <discriminator column="type" type="string"/> <property name="name" length="20" not-null="true"/> <many-to-one name="department" column="depart_id" cascade="save-update" fetch="join" lazy="no-proxy" /> <!-- Inheritance --> <subclass name="Developer" discriminator-value="3"> <property name="develop" length="40"/> </subclass> <subclass name="Tester" discriminator-value="4"> <join table="my_tester"> <key column="test_id" foreign-key="id"/> <property name="test" length="40"/> </join> </subclass> </class> </hibernate-mapping>
4. 每个具体类映射一张独立表(union-subclass)
和2不同,这里子类的所有属性(包括从父类继承的)会保存到一张独立的表中。
Employee.hbm.xml:
<class name="Employee"> <id name="id"> <generator class="hilo"/> </id> <property name="name" length="20" not-null="true"/> <many-to-one name="department" column="depart_id" cascade="save-update" fetch="join" lazy="no-proxy" /> <!-- Inheritance --> <union-subclass name="Developer" table="developer"> <property name="develop" length="40"/> </union-subclass> <union-subclass name="Tester" table="tester"> <property name="test" length="40"/> </union-subclass> </class> </hibernate-mapping>
这里的id生成器用的是hilo(或uuid)。
native(mysql里是自动增长)方式不可以:
id值会重复。
如Employee, Developer和Tester三张独立的表,每张表的id都是从1开始自增长的。
当查询id为1的Employee的时候,会查询到3个对象。
发表评论
-
myBatis系列之七:事务管理
2014-04-01 15:36 103944myBatis系列之一:搭建开发环境 myBatis系列之二: ... -
myBatis系列之八:分页查询
2014-01-13 22:07 0分页查询:物理分页,不是内存分页: 1. 在sql语句中指定 ... -
myBatis系列之六:与SpringMVC集成
2013-12-26 13:33 5899myBatis系列之一:搭建开发环境 myBatis系列之二: ... -
myBatis系列之五:与Spring3集成
2013-12-09 14:31 4992myBatis系列之一:搭建开 ... -
myBatis系列之四:关联数据的查询
2013-12-08 13:36 9713myBatis系列之一:搭建开发环境 myBatis系列之二: ... -
myBatis系列之三:增删改查
2013-12-01 22:36 5038myBatis系列之一:搭建开发环境 myBatis系列之二: ... -
myBatis系列之二:以接口方式交互数据
2013-11-25 22:46 12364myBatis系列之一:搭建开发环境 myBatis系列之三: ... -
myBatis系列之一:搭建开发环境
2013-11-18 22:00 8542myBatis系列之二:以接口方式交互数据 myBatis系列 ... -
JPA 一对一关联
2012-08-18 17:12 3240在一对一关联中,JPA没有规定谁为关系的维护方,OneToOn ... -
Hibernate 集合类型使用
2012-08-11 18:31 1339为了映射实体中的集合 ... -
Hibernate 组件关联关系
2012-08-11 15:10 1247实体关联的属性是个复杂类型的持久化类,但不是实体:数据库中没有 ... -
Hibernate 一对多关联配置
2012-08-09 22:13 1850以Department和Employee为例。 Depart ... -
Hibernate 多对一关联配置
2012-08-08 21:51 28298实体是Employee和Department,它们之间是多对一 ... -
Hibernate 查询分析
2012-08-08 19:15 0private void fireLoad(LoadEv ... -
Hibernate 配置文件
2012-07-25 20:17 0<properties> < ... -
jdbc 批处理操作
2012-05-15 15:43 1412jdbc的批处理操作是指把一组SQL语句(增删改操作)一次性提 ... -
jdbc调用postgreSQL数据库内置函数
2012-05-08 16:02 31221. current_timestamp 返回的是当前的 ... -
构建Hibernate项目
2012-04-25 20:35 01. 新建一个Java Project 2. 添加hiber ... -
乐观锁与悲观锁
2012-04-24 22:50 2765悲观锁: 读取数据的时候对记录加锁,直到提交数据更新后解锁 ... -
Hibernate映射文件的配置
2012-04-20 22:21 01. type值不是指java类型或者数据库的类型,而是Hib ...
相关推荐
NULL 博文链接:https://prowl.iteye.com/blog/519618
Hibernate_映射配置文件详解,个人觉的比较不错的关于hibernate讲解的ppt,对于xml配置,继承关系,多对多等关系映射讲的很详细!
Hibernate一对一数据关联 Hibernate下的多对多关系 Hibernate关系映射 Hibernate继承关系映射 Hibernate映射类型-主键生成器-核心API Hibernate3 插件Eclipse配置
这是第二篇, 内容如下:Hibernate配置文件;jdbc.fetch_size;jdbc.batch_size; POJO 类和数据库的映射文件*.hbm.xml;主键生成策略generator;映射集合属性;延迟加载策略;映射组件属性;关联关系映射:双向 1-N;继承...
Hibernate配置 1.2.4. 用Ant构建 1.2.5. 启动和辅助类 1.2.6. 加载并存储对象 1.3. 第二部分 - 关联映射 1.3.1. 映射Person类 1.3.2. 单向Set-based的关联 1.3.3. 使关联工作 1.3.4. 值类型的集合 1.3.5...
01 01Hibernate_Handwork : 手工配置使用Hibernate,其中详细标了Hibernate进行持久化的一些过程,因为是Hibernate的入门实例,所以注释很详细,其中有session的关闭后重建问题。 02 02Hibernate_UseMyEclipse: 利用...
HIBERNATE - 符合Java习惯的关系数据库持久化 Hibernate参考文档 3.2 -------------------------------------------------------------------------------- 目录 前言 1. 翻译说明 2. 版权声明 1. Hibernate...
Hibernate倡导低侵入式的设计,完全采用普通的java对象(POJO)编程,不要求PO继承Hibernate的某个超类或实现Hibernate的某个接口。Hibernate充当了面向对象的程序设计语言和关系数据库之间的桥梁,Hibernate允许程序...
Company与Employee类之间为一对多多态关联关系,如果继承关系树的根类对应一个表,或者每个类对应一个表,那么就能映射Company类的employees集合。本节介绍如何映射多对一多态关联。如图14-11所示,ClassD与ClassA为...
2.2.4. 映射继承关系 2.2.4.1. 每个类一张表 2.2.4.2. 每个类层次结构一张表 2.2.4.3. 连接的子类 2.2.4.4. 从父类继承的属性 2.2.5. 映射实体Bean的关联关系 2.2.5.1. 一对一(One-to-one) 2.2.5.2. 多对一...
1.2.3. Hibernate配置 1.2.4. 用Ant构建 1.2.5. 启动和辅助类 1.2.6. 加载并存储对象 1.3. 第二部分 - 关联映射 1.3.1. 映射Person类 1.3.2. 单向Set-based的关联 1.3.3. 使关联工作 1.3.4. 值类型的集合 ...
N关系时保存技巧、Hibernate缓存机制、Hibernate批量处理数据、Hibernate三种继承映射策略、hibernate映射体系、Hibernate主键生成策略、持久层DAO设计建议、基于xml文件的bean、使用HibernateAPI在Spring中、事务...
12.1 继承关系树的每个具体类对应一个表 12.1.1 创建映射文件 12.1.2 操纵持久化对象 12.2 继承关系树的根类对应一个表 12.2.1 创建映射文件 12.2.2 操纵持久化对象 12.3 继承关系树的每个类对应一个...
2.2.4. 映射继承关系 2.2.4.1. 每个类一张表 2.2.4.2. 每个类层次结构一张表 2.2.4.3. 连接的子类 2.2.4.4. 从父类继承的属性 2.2.5. 映射实体Bean的关联关系 2.2.5.1. 一对一(One-to-one) 2.2.5.2. 多对一(Many-to-...
HIBERNATE - 符合Java习惯的关系数据库持久化 Hibernate参考文档 3.2 -------------------------------------------------------------------------------- 目录 前言 1. 翻译说明 2. 版权声明 1. Hibernate...
HIBERNATE - 符合Java习惯的关系数据库持久化 Hibernate参考文档 3.2 -------------------------------------------------------------------------------- 目录 前言 1. 翻译说明 2. 版权声明 1. Hibernate...
开始Hibernate之旅 1.2. 第一个可持久化类 1.3. 映射cat 1.4. 与猫同乐 1.5. 结语 2. 体系结构 2.1. 总览 2.2. JMX集成 2.3. JCA支持 3. SessionFactory配置 3.1. 可编程配置方式...
2.1.3 Hibernate配置和启动 2.1.4 运行和测试应用程序 2.2 启动Java Persistence项目 2.2.1 使用Hibernate Annotations 2.2.2 使用Hibernate EntityManager 2.2.3 引入EJB组件 2.2.4 切换...
1.2.3. Hibernate配置 1.2.4. 用Ant构建 1.2.5. 启动和辅助类 1.2.6. 加载并存储对象 1.3. 第二部分 - 关联映射 1.3.1. 映射Person类 1.3.2. 单向Set-based的关联 1.3.3. 使关联工作 1.3.4. 值类型的集合 ...