Hibernate实战_笔记4(ORM概念)

      现在我们来简单地看看可以由Java应用程序实现持久层的各种方法。别着急,我们很快就要讲到ORM和Hibernate了。通过看看其他方法,可以学到很多东西。

用SQL/JDBC手工编写持久层

      对于应用程序员来说,处理Java持久化最常用的方法是直接使用SQL和JDBC。毕竟,开发人员熟悉关系数据库管理系统,他们理解SQL,并且知道如何使用表和外键。此外,他们始终可以使用众所周知且被广泛使用的DAO模式,来隐藏业务逻辑中复杂的JDBC代码和不可移植的SQL。
DAO是个很好的模式——因此我们甚至经常推荐把它与ORM一起使用。然而,给每个领域类手工编写持久化代码涉及的工作量相当大,特别当支持多个SQL方言的时候。这项工作通常消耗很大一部分开发精力。甚至,当需求改变时,手工编写的解决方案总是需要更多的注意力和维护精力。

为什么不实现一个简单的映射框架来适应项目的特殊需求呢?这种努力的结果甚至可以在未来的项目中重用。许多开发人员已经采用了这种方法 ;如今许多自制的对象/关系持久层应用于产品系统中。但是我们不推荐这种方法。优秀的解决方案已经存在:不仅有商业供应商销售的工具(非常昂贵),也有免许可的开源项目。我们确信你肯定能够找到一种满足你需求的解决方案,包括业务需要和技术需求。这种解决方案可能比你在有限的时间内能够创建的解决方案完成更多的工作,并且做得更好。

面向对象的数据库系统

      由于我们是在Java中使用对象,所以如果有一种方法 能把那些对象存储到数据库中,又根本不必扭曲对象模型就好了。在20世纪90年代中期,面向对象的数据库系统备受关注。它们以一个网络数据模型为基础,在关系型数据模型出现之前的十几年前,这种方法很普遍。基本的思想是存储一个对象网络,包括它所有的指针和节点,并随后重新创建相同的内存图。这可以用各种元数据和配置设置进行优化。
      与其说是像外部数据仓库,面向对象的数据库管理系统(OODBMS)则更像是应用程序环境的一个扩展。
我们不想深入研究为什么面向对象的数据库技术还没有流行起来;我们将发现对象数据库还没有被广泛采用,可能近期内也不会。考虑到当前的政治现实(预先确定的部署环境)和数据独立的普遍需求,我们相信压倒多数的开发人员会有更多的机会使用关系技术。

什么是ORM

简而言之,ORM就是利用描述对象和数据库之间映射的元数据,自动(且透明)地把Java应用程序中的对象持久化到关系数据库中的表。
ORM解决方案包含下面的4个部分:
1、在持久化类的对象上执行基本的CRUD操作的一个API;
2、用于指定引用类或者类属性的查询的一种语言或者API;
3、用于指定映射元数据的一种工具;
4、用于实现ORM的一项技术,与事务对象交互,执行脏检查(dirty checking)、延迟关联抓取以及其他优化功能;

来看一下可以实现ORM的各种方法。Mark Fussel(Fussel,1997),ORM领域的一位开发人员,定义了下列4个ORM质量等级。
1、纯关系
      整个应用程序(包括用户界面)都围绕着关系模型和基于SQL的关系操作而设计。这种方法,除了它不足以用于大型系统之外,对于那些容许低级代码重用的简单应用程序来说,它不失为一种极好的解决方案。直接的SQL可以在各个方面调优,但是缺点(例如缺乏可移植性和可维护性)也是很显著的,尤其对长期运行而言。这类应用程序经常大量地使用存储过程,把一些工作从业务层转换到了数据库中。
2、轻量对象映射
      实体被表示为手工映射到关系表的类。使用众所周知的设计模式,把手工编码的SQL/JDBC从业务逻辑中隐藏起来。这种方法非常普遍,对于那些带有少量实体的应用程序,或者那些使用普通的元数据驱动的数据模型的应用程序来说,它是很成功的。存储过程在这种类型的应用程序中可能也有一席之地。
3、中等对象映射
      这种应用程序围绕对象模型而设计。SQL使用一个代码生成的工具在创建时产生,或者通过框架代码在运行时产生。对象之间的关联得到持久化机制的支持,并且查询可能使用一种面向对象的表达式语言来指定。对象由持久层高速缓存。ORM产品和自制的持久层都至少支持这一级别的功能。它非常适合一些复杂事务的中等规模的应用程序,特别是在不同的数据库产品之间的可移植性很重要的时候。这些应用程序通常不使用存储过程。
4、完全对象映射
      完全的对象映射支持完善的对象模型:组合、继承、多态和可达的持久化。持久层实现透明的持久化;持久化类不必继承任何特殊的基类,或者实现特殊的接口。高效的抓取策略(延迟、即时和预取)和高速缓存策略被透明地实现到应用程序。这一级别的功能无法通过自制的持久层实现——它相当于几年的开发时间。许多商业和开源的Java ORM工具已经实现了这个质量等级。

为什么选择ORM

      ORM的实现非常复杂——虽然没有应用程序服务器复杂,却比Web应用程序框架如Struts或Tapestry要复杂得多。为什么要把另一个复杂的基础元素引入到我们的系统中呢?值得这么值吗?
      ORM一个假定的益处是使开发人员避免杂乱的SQL。持这种观点的人认为不能期待面向对象的开发人员很好地理解SQL或者关系数据库,并且他们认为SQL有点讨厌。正好相反,我们认为Java开发人员必须足够熟悉并欣赏关系模型和SQL,以便用ORM进行工作。ORM是一项高级的技术,将被为其付出艰辛努力的开发人员所用。要有效地使用Hibernate,必须能够观察和解读它生成的SQL语句,并理解对于其性能的含义。
现在,来看看ORM和Hibernate的一些益处。
1、生产力
      与持久化相关的代码可能会是Java应用程序中最冗长乏味的代码。Hibernate去除了许多琐碎的工作,并让你把业务集中在业务问题上。
无论你喜欢哪种应用程序开发策略——自顶向下,从一个领域模型开始;或者自底向上,从一个现有的数据库Schema开始——Hibernate与适当的工具一起使用,将明显减少开发时间。
2、可维护性
      更少的代码行(LOC)使得系统更易于理解,因为它强调业务逻辑甚于那些费力的基础性工作。
然而,Hibernate应用程序更易维护还有其他原因。在手工编码的持久化系统中,关系表示法和对象模型实现领域之间存在着一种必然的压力。改变一个,通常都要改变另一个,并且一个表示法设计经常需要妥协以便适应另一个的存在。(在实际应用程序中,通常是领域的对象模型发生妥协。)ORM提供了两个模型之间的一个缓冲,允许面向对象在Java方面进行更优雅的利用,并且每个模型的微小变化都不会传递到另一个模型。
3、性能
      一种普通的断言是,手工编码的持久化与自动的持久化相比总是至少可以一样快,并且经常更快。这是真的,就像汇编代码总是至少可以与Java代码一样快,或者手工编写的解析器总是至少可以与由YACC或者ANTLR产生的解析器一样快,这同样是真的一样——换句话说,这有点离题了。这种断言的言下之意是,手工编码的持久化在实际应用程序中将至少完成得一样好。但是,这种含意只有当实现至少一样快的手工编码的持久化所需的努力,类似于使用自动的解决方案所付出的努力时才是对的。真正值得关注的问题是,当我们考虑到时间和预算的约束时会发生什么?

  • 1
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第一部分 从Hibernate和EJB 3.0开始  第1章 理解对象/关系持久化    1.1 什么是持久化     1.1.1 关系数据库     1.1.2 理解SQL     1.1.3 在Java中使用SQL     1.1.4 面向对象应用程序中的持久化    1.2 范式不匹配     1.2.1 粒度问题     1.2.2 子类型问题     1.2.3 同一性问题     1.2.4 与关联相关的问题     1.2.5 数据导航的问题     1.2.6 不匹配的代价    1.3 持久层和其他层 显示全部信息第一部分 从Hibernate和EJB 3.0开始  第1章 理解对象/关系持久化    1.1 什么是持久化     1.1.1 关系数据库     1.1.2 理解SQL     1.1.3 在Java中使用SQL     1.1.4 面向对象应用程序中的持久化    1.2 范式不匹配     1.2.1 粒度问题     1.2.2 子类型问题     1.2.3 同一性问题     1.2.4 与关联相关的问题     1.2.5 数据导航的问题     1.2.6 不匹配的代价    1.3 持久层和其他层     1.3.1 分层架构     1.3.2 用SQL/JDBC手工编写持久层     1.3.3 使用序列化     1.3.4 面向对象的数据库系统     1.3.5 其他选项    1.4 ORM     1.4.1 什么是ORM     1.4.2 一般的ORM问题     1.4.3 为什么选择ORM     1.4.4 Hibernate、EJB 3和JPA简介    1.5 小结   第2章 启动项目    2.1 启动Hibernate项目     2.1.1 选择开发过程     2.1.2 建立项目     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 切换到Hibernate接口    2.3 反向工程遗留数据库     2.3.1 创建数据库配置     2.3.2 定制反向工程     2.3.3 生成Java源代码    2.4 与Java EE服务整合     2.4.1 与JTA整合     2.4.2 JNDI绑定的SessionFactory     2.4.3 JMX服务部署    2.5 小结   第3章 领域模型和元数据    3.1 CaveatEmptor应用程序     3.1.1 分析业务领域     3.1.2 CaveatEmptor领域模型    3.2 实现领域模型     3.2.1 处理关注点渗漏     3.2.2 透明和自动持久化     3.2.3 编写POJO和持久化实体类     3.2.4 实现POJO关联     3.2.5 把逻辑添加到访问方法    3.3 ORM元数据     3.3.1 XML中的元数据     3.3.2 基于注解的元数据     3.3.3 使用XDoclet     3.3.4 处理全局的元数据     3.3.5 运行时操作元数据    3.4 其他实体表示法     3.4.1 创建动态的应用程序     3.4.2 表示XML中的数据    3.5 小结  第二部分 映射概念和策略  第4章 映射持久化类    4.1 理解实体和值类型     4.1.1 细粒度的领域模型     4.1.2 定义概念     4.1.3 识别实体和值类型    4.2 映射带有同一性的实体     4.2.1 理解Java同一性和等同性     4.2.2 处理数据库同一性     4.2.3 数据库主键    4.3 类映射选项     4.3.1 动态的SQL生成     4.3.2 使实体不可变     4.3.3 给查询命名实体     4.3.4 声明包名称     4.3.5 用引号把SQL标识符括起来     4.3.6 实现命名约定    4.4 细粒度的模型和映射     4.4.1 映射基础属性     4.4.2 映射组件    4.5 小结   第5章 继承和定制类型    5.1 映射类继承     5.1.1 每个带有隐式多态的具体类一张表     5.1.2 每个带有联合的具体类一张表     5.1.3 每个类层次结构一张表     5.1.4 每个子类一张表     5.1.5 混合继承策略     5.1.6 选择策略    5.2 Hibernate类型系统     5.2.1 概述实体和值类型     5.2.2 内建的映射类型     5.2.3 使用映射类型    5.3 创建定制的映射类型     5.3.1 考虑定制的映射类型     5.3.2 扩展点     5.3.3 定制映射类型的案例     5.3.4 创建UserType     5.3.5 创建CompositeUserType     5.3.6 参数化定制类型     5.3.7 映射枚举    5.4 小结   第6章 映射集合和实体关联    6.1 值类型的set、bag、list和map     6.1.1 选择集合接口     6.1.2 映射set     6.1.3 映射标识符bag     6.1.4 映射list     6.1.5 映射map     6.1.6 排序集合和有序集合  6.2 组件的集合     6.2.1 编写组件类     6.2.2 映射集合     6.2.3 启用双向导航     6.2.4 避免非空列    6.3 用注解映射集合     6.3.1 基本的集合映射     6.3.2 排序集合和有序集合     6.3.3 映射嵌入式对象的集合    6.4 映射父/子关系     6.4.1 多样性     6.4.2 最简单的可能关联     6.4.3 使关联双向     6.4.4 级联对象状态    6.5 小结   第7章 高级实体关联映射    7.1 单值的实体关联     7.1.1 共享的主键关联     7.1.2 一对一的外键关联     7.1.3 用联结表映射    7.2 多值的实体关联     7.2.1 一对多关联     7.2.2 多对多关联     7.2.3 把列添加到联结表     7.2.4 映射map    7.3 多态关联     7.3.1 多态的多对一关联     7.3.2 多态集合     7.3.3 对联合的多态关联     7.3.4 每个具体类一张多态表    7.4 小结   第8章 遗留数据库和定制SQL    8.1 整合遗留数据库     8.1.1 处理主键     8.1.2 带有公式的任意联结条件     8.1.3 联结任意的表     8.1.4 使用触发器    8.2 定制SQL     8.2.1 编写定制CRUD语句     8.2.2 整合存储过程和函数    8.3 改进Schema DDL     8.3.1 定制SQL名称和数据类型     8.3.2 确保数据一致性     8.3.3 添加领域约束和列约束     8.3.4 表级约束     8.3.5 数据库约束     8.3.6 创建索引     8.3.7 添加辅助的DDL    8.4 小结  第三部分 会话对象处理  第9章 使用对象    9.1 持久化生命周期     9.1.1 对象状态     9.1.2 持久化上下文    9.2 对象同一性和等同性     9.2.1 引入对话     9.2.2 对象同一性的范围     9.2.3 脱管对象的同一性     9.2.4 扩展持久化上下文    9.3 Hibernate接口     9.3.1 保存和加载对象     9.3.2 使用脱管对象     9.3.3 管理持久化上下文    9.4 JPA     9.4.1 保存和加载对象     9.4.2 使用脱管的实体实例    9.5 在EJB组件中使用Java Persistence     9.5.1 注入EntityManager     9.5.2 查找EntityManager     9.5.3 访问EntityManagerFactory    9.6 小结   第10章 事务和并发    10.1 事务本质     10.1.1 数据库和系统事务     10.1.2 Hibernate应用程序中的事务     10.1.3 使用Java Persistence的事务    10.2 控制并发访问     10.2.1 理解数据库级并发     10.2.2 乐观并发控制     10.2.3 获得额外的隔离性保证    10.3 非事务数据访问     10.3.1 揭开自动提交的神秘面纱     10.3.2 使用Hibernate非事务地工作     10.3.3 使用JTA的可选事务    10.4 小结   第11章 实现对话    11.1 传播Hibernate Session     11.1.1 Session传播的用例     11.1.2 通过线程局部传播     11.1.3 利用JTA传播     11.1.4 利用EJB传播    11.2 利用Hibernate的对话     11.2.1 提供对话保证     11.2.2 利用脱管对象的对话     11.2.3 给对话扩展Session    11.3 使用JPA的对话     11.3.1 Java SE中的持久化上下文传播     11.3.2 在对话中合并脱管对象     11.3.3 在Java SE中扩展持久化上下文    11.4 使用EJB 3.0的对话     11.4.1 使用EJB的上下文传播     11.4.2 利用EJB扩展持久化上下文    11.5 小结   第12章 有效修改对象    12.1 传播性持久化     12.1.1 按可到达性持久化     12.1.2 把级联应用到关联     12.1.3 使用传播性状态     12.1.4 利用JPA的传播性关联    12.2 大批量和批量操作     12.2.1 使用HQL和JPA QL的大批量语句     12.2.2 利用批量处理     12.2.3 使用无状态的会话    12.3 数据过滤和拦截     12.3.1 动态数据过滤     12.3.2 拦截Hibernate事件     12.3.3 内核事件系统     12.3.4 实体监听器和回调    12.4 小结   第13章 优化抓取和高速缓存    13.1 定义全局抓取计划     13.1.1 对象获取选项     13.1.2 延迟的默认抓取计划     13.1.3 理解代理     13.1.4 禁用代理生成     13.1.5 关联和集合的即时加载     13.1.6 通过拦截延迟加载    13.2 选择抓取策略     13.2.1 批量预抓取数据     13.2.2 通过子查询预抓取集合     13.2.3 通过联结即时抓取     13.2.4 给二级表优化抓取     13.2.5 优化指导方针    13.3 高速缓存基本原理     13.3.1 高速缓存策略和范围     13.3.2 Hibernate高速缓存架构    13.4 高速缓存实践     13.4.1 选择并发控制策略     13.4.2 理解高速缓存区域     13.4.3 设置本地的高速缓存提供程序     13.4.4 设置重复的高速缓存     13.4.5 控制二级高速缓存    13.5 小结   第14章 利用HQL和JPA QL查询    14.1 创建和运行查询     14.1.1 准备查询     14.1.2 执行查询     14.1.3 使用具名查询    14.2 基本的HQL和JPA QL查询     14.2.1 选择     14.2.2 限制     14.2.3 投影    14.3 联结、报表查询和子查询     14.3.1 联结关系和关联     14.3.2 报表查询     14.3.3 利用子查询    14.4 小结   第15章 高级查询选项    15.1 利用条件和示例查询     15.1.1 基本的条件查询     15.1.2 联结和动态抓取     15.1.3 投影和报表查询     15.1.4 按示例查询    15.2 利用原生的SQL查询     15.2.1 自动的结果集处理     15.2.2 获取标量值     15.2.3 Java Persistence中的原生SQL    15.3 过滤集合    15.4 高速缓存查询结果     15.4.1 启用查询结果高速缓存     15.4.2 理解查询高速缓存     15.4.3 什么时候使用查询高速缓存     15.4.4 自然标识符高速缓存查找    15.5 小结   第16章 创建和测试分层的应用程序    16.1 Web应用程序中的Hibernate     16.1.1 用例简介     16.1.2 编写控制器     16.1.3 OSIV模式     16.1.4 设计巧妙的领域模型    16.2 创建持久层     16.2.1 泛型的数据访问对象模式     16.2.2 实现泛型CRUD接口     16.2.3 实现实体DAO     16.2.4 利用数据访问对象    16.3 命令模式简介     16.3.1 基础接口     16.3.2 执行命令对象     16.3.3 命令模式的变形    16.4 利用EJB 3.0设计应用程序     16.4.1 利用有状态的bean实现会话     16.4.2 利用EJB编写DAO     16.4.3 利用依赖注入    16.5 测试     16.5.1 理解不同种类的测试     16.5.2 TestNG简介     16.5.3 测试持久层     16.5.4 考虑性能基准    16.6 小结   第17章 JBoss Seam简介    17.1 Java EE 5.0编程模型     17.1.1 JSF详解     17.1.2 EJB 3.0详解     17.1.3 用JSF和EJB 3.0编写Web应用程序     17.1.4 分析应用程序    17.2 用Seam改善应用程序     17.2.1 配置Seam     17.2.2 将页面绑定到有状态的Seam组件     17.2.3 分析Seam应用程序    17.3 理解上下文组件     17.3.1 编写登录页面     17.3.2 创建组件     17.3.3 给上下文变量起别名     17.3.4 完成登录/注销特性    17.4 验证用户输入     17.4.1 Hibernate Validator简介     17.4.2 创建注册页面     17.4.3 用Seam实现国际化    17.5 利用Seam简化持久化     17.5.1 实现对话     17.5.2 让Seam管理持久化上下文    17.6 小结  附录A SQL基础知识  附录B 映射快速参考
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值