精通EJB（第2版）

　　本书是关于EJB 2.0开发的经典书籍，是EJB开发者的必备参考书。全书共分为四篇，第一篇是对EJB编程的快速浏览，包括第1章到第3章，主要是针对EJB新手而介绍的基础知识，但是有一定开发经验的老手仍然会发现很多有用的东西。第二篇专门介绍EJB编程，包括第4章到第9章，本部分介绍了三种Bean：实体Bean、会话Bean和消息驱动Bean，讲述了编写每种类型的Bean所需要的基础知识，包括示例和详细的Bean的生命周期图表。第三篇是本书最令人兴奋的部分，包括第10章到第17章，主要讲述了高级EJB概念。第四篇是附录部分，包括附录A到附录E，是EJB主题的辅助部分，供读者参考。 本书非常适合于Java程序员、网站开发人员和系统分析员作为EJB开发的核心参考书。 本书前言特色及评论文章节选

　　EdRoman是世界上研究高端中间件技术的权威之一。他从一开始就积极参与SunMicrosystems公司的EnterpriseBean解决方案，设计、建立、部署过很多不同的企业级应用，包括构建和开发完整的应用服务器产品。平时他将大部分的时间用于修改和完善Sun公司的EJB规范，他是中间件邮件列表的固定投稿人，经常在与中间件有关的会议上演讲发言。

第一篇  概    述                  
 第1章  概述 3                  
 1.1  EJB的形成动机 3                  
 1.2  分而置之的极点 4                  
 1.3  组件体系结构 8                  
 1.4  Enterprise JavaBeans（EJB）简介 9                  
 1.4.1  为什么用Java 9                  
 1.4.2  作为一种商务解决方案的EJB 10                  
 1.5  EJB 社区 11                  
 1.5.1  Bean供应商 12                  
 1.5.2  应用系统组装商 12                  
 1.5.3  EJB系统部署员 13                  
 1.5.4  系统管理员 13                  
 1.5.5  容器和服务器供应商 13                  
 1.5.6  工具供应商 14                  
 1.5.7  角色小结 14                  
 1.6  Java 2平台企业版 15                  
 1.7  小结 19                  
 第2章  EJB基础 21                  
 2.1  Enterprise Bean 21                  
 2.2  分布式对象：EJB基础 23                  
 2.3  分布式对象和中间件 24                  
 2.3.1  显式的中间件 24                  
 2.3.2  隐式的中间件 25                  
 2.4  企业级Bean的组成部分 26                  
 2.4.1  Enterprise Bean类 27                  
 2.4.2  EJB对象 27                  
 2.4.3  Home对象 32                  
 2.4.4  本地接口 34                  
 2.4.5  部署描述 36                  
 2.4.6  供应商特有文件 37                  
 2.4.7  Ejb-jar文件 37                  
 2.4.8  术语小结 38                  
 2.5  小结 39                  
 第3章  编写您的第一个Bean 41                  
 3.1  怎样开发一个EJB组件 41                  
 3.2  远程接口 42                  
 3.3  本地接口 43                  
 3.4  Home接口 44                  
 3.5  本地Home接口 44                  
 3.6  Bean类 46                  
 3.7  部署描述 49                  
 3.8  与供应商相关的特定文件 50                  
 3.9  Ejb-jar文件 50                  
 3.10  部署Bean 51                  
 3.11  可选的EJB客户端的Jar文件 51                  
 3.12  理解怎样调用Bean 52                  
 3.13  运行系统 55                  
 3.13.1  服务器端输出 56                  
 3.13.2  客户端输出 56                  
 3.14   实现组件接口 56                  
 3.15  小结 58                  
 第二篇  3种Bean                  
 第4章  会话Bean介绍 61                  
 4.1  会话Bean的生命周期 61                  
 4.2  会话Bean子类型 61                  
 4.2.1  状态会话Bean 62                  
 4.2.2  无状态会话Bean 62                  
 4.3  状态会话Bean的特征 63                  
 4.3.1  对状态会话Bean实现调度池调度 63                  
 4.3.2  对话状态遵从的规则 65                  
 4.3.3  激活/钝化回调方法 66                  
 4.3.4  方法实现小结 68                  
 4.3.5  一个简单的状态会话Bean 68                  
 4.3.6  会话Bean的生命周期图表 75                  
 4.4  小结 78                  
 第5章  实体Bean介绍 79                  
 5.1  持久的概念 79                  
 5.1.1  Java对象序列化 79                  
 5.1.2  对象–关系型数据库映射 80                  
 5.1.3  对象数据库 81                  
 5.2  什么是实体Bean 82                  
 5.3  实体Bean的特征 84                  
 5.3.1  实体Bean可以幸免于故障 84                  
 5.3.2  实体Bean实例是一个对应到数据库中的视图 85                  
 5.3.3  几个实体Bean实例可能代表同一底层数据 86                  
 5.3.4  实体Bean实例可以被收集再利用 87                  
 5.3.5  保持实体Bean的两种方法 89                  
 5.3.6  实体Bean的创建和删除 89                  
 5.3.7  实体Bean可以被查找 91                  
 5.3.8  实体Bean可以不通过EJB被修改 92                  
 5.4  实体上下文 92                  
 5.4.1  getEJBLocalObject()/ getEJBObject() 93                  
 5.4.2  getPrimaryKey() 93                  
 5.5  小结 94                  
 第6章  编写Bean管理的持久实体Bean 95                  
 6.1  实体Bean编程基础 95                  
 6.2  Bean管理持久的范例：一个银行账户 100                  
 6.2.1  Account.java 101                  
 6.2.2  AccountLocal.java 102                  
 6.2.3  AccountHome.java 103                  
 6.2.4  AccountLocalHome.java 104                  
 6.2.5  AccountPK.java 105                  
 6.2.6  AccountBean.java 106                  
 6.2.7  AccountException.java 116                  
 6.2.8  Client.java 117                  
 6.2.9  部署描述 120                  
 6.2.10  特定容器的部署描述 121                  
 6.2.11  建立数据库 121                  
 6.3  运行客户端程序 121                  
 6.3.1  服务器端的输出 122                  
 6.3.2  客户端的输出 123                  
 6.4  融会贯通：遍历BMP实体生命周期 123                  
 6.5  小结 125                  
 第7章  编写容器管理的持久实体Bean 127                  
 7.1  CMP实体Bean的特性 127                  
 7.1.1  被继承的实体Bean 127                  
 7.1.2  CMP实体Bean不包含声明字段 128                  
 7.1.3  CMP 的get/set 方法在子类中的定义 129                  
 7.1.4  CMP实体Bean有一个抽象的持久化模式 131                  
 7.1.5  CMP实体Bean拥有查询语言 132                  
 7.1.6  CMP实体Bean可以包含ejbSelect()方法 133                  
 7.2  实现容器管理持久化的指导原则 134                  
 7.3  容器管理持久的范例：产品系列 137                  
 7.3.1  Product.java 137                  
 7.3.2  ProductLocal.java 138                  
 7.3.3  ProductHome.java 139                  
 7.3.4  ProductLocalHome.java 140                  
 7.3.5  ProductPK.java 141                  
 7.3.6  ProductBean.java 142                  
 7.3.7  部署描述 145                  
 7.3.8  容器相关的部署描述 148                  
 7.3.9  Client.java 149                  
 7.4  运行客户端程序 151                  
 7.5  CMP实体Bean的生命周期 152                  
 7.6  小结 153                  
 第8章  消息驱动Bean简介 155                  
 8.1  使用消息驱动Bean的动机 155                  
 8.2  Java消息服务 156                  
 8.2.1  消息机制的域 157                  
 8.2.2  Java消息服务API 158                  
 8.3  Java消息服务同EJB的集成 162                  
 8.4  开发消息驱动Bean 164                  
 8.4.1  语法 164                  
 8.4.2  一个简单示例程序 166                  
 8.5  高级概念 171                  
 8.6  消息驱动Bean的常见难点 173                  
 8.6.1  消息排序 173                  
 8.6.2  很少用到ejbRemove()调用 174                  
 8.6.3  如何将结果返回到消息发生者 176                  
 8.6.4  未来展望：异步方法调用 179                  
 8.7  小结 180                  
 第9章  给Bean增加功能 181                  
 9.1  从其他的Bean调用Bean 181                  
 9.1.1  默认的JNDI查找 181                  
 9.1.2  理解EJB引用 182                  
 9.2  资源库 184                  
 9.3  环境属性 186                  
 9.4  理解EJB的安全性 187                  
 9.4.1  安全第一步：验证 188                  
 9.4.2  安全第二步：授权 196                  
 9.4.3  安全性的传播 203                  
 9.5  理解EJB对象句柄 204                  
 9.6  小结 206                  
 第三篇  高级企业JavaBean概念                  
 第10章  事务 209                  
 10.1  事务产生的动机 209                  
 10.1.1  原子操作 209                  
 10.1.2  网络故障或机器故障 210                  
 10.1.3  多用户共享数据 211                  
 10.2  事务所带来的益处 212                  
 10.3  事务的模型 214                  
 10.3.1  平面式事务模型 214                  
 10.3.2  嵌套式事务模型 215                  
 10.3.3  其他事务模型 216                  
 10.4  事务在EJB组件中的应用 217                  
 10.4.1  后台事务系统的抽象分离 217                  
 10.4.2  声明型事务. 编程型事务和客户端初始化事务 217                  
 10.4.3  选择事务的类型 220                  
 10.5  容器管理的事务 221                  
 10.6  EJB中的编程型事务 227                  
 10.6.1  CORBA的对象事务处理服务（OTS） 227                  
 10.6.2  Java事务处理服务（JTS） 227                  
 10.6.3  Java事务处理API（JTA） 227                  
 10.6.4  声明型事务和编程型事务的应用范例比较 230                  
 10.7  如何使用客户代码控制事务 232                  
 10.8  事务的隔离 233                  
 10.8.1  并发控制的需求 233                  
 10.8.2  隔离性与EJB的理论 234                  
 10.8.3  不当读取问题 235                  
 10.8.4  不可重复读取问题 236                  
 10.8.5  幻影读取问题 237                  
 10.8.6  事务隔离性的总结 238                  
 10.8.7  隔离性与EJB 238                  
 10.8.8  限制式和开放式并发控制 239                  
 10.9  分布式事务 239                  
 10.9.1  稳定性和两阶段提交协议 240                  
 10.9.2  事务的通信协议和事务上下文 241                  
 10.10   在EJB中设计事务会话 241                  
 10.11  小结 243                  
 第11章  BMP和CMP的关联 245                  
 11.1  BMP和CMP的区别 245                  
 11.2  基数性 246                  
 11.2.1  1:1 关联 247                  
 11.2.2  1:N关联 250                  
 11.2.3  M:N 关联 254                  
 11.3  方向性 260                  
 11.3.1  使用BMP实现方向性 261                  
 11.3.2  使用CMP实现方向性 262                  
 11.3.3  方向性不可以映射到数据库模式 263                  
 11.3.4  选择双向还是单向关联 264                  
 11.4  惰性载入（Lazy Loading） 264                  
 11.5  聚合–组合和级联删除 265                  
 11.6  关联和EJB-QL 267                  
 11.7  递归关联 268                  
 11.8  循环关联 268                  
 11.9  引用完整性 269                  
 11.10  小结 272                  
 第12章  持久化最优操作 273                  
 12.1  何时使用实体Bean 273                  
 12.1.1  控制 273                  
 12.1.2  参数传递的类比 273                  
 12.1.3  过程化（Procedural）与面向对象的对比 274                  
 12.1.4  高速缓存 274                  
 12.1.5  实施模式独立性 275                  
 12.1.6  易于使用 275                  
 12.1.7  移植 275                  
 12.1.8  快速应用开发 275                  
 12.2  选择CMP或是BMP 276                  
 12.2.1  代码简化和快速应用开发 276                  
 12.2.2  性能 276                  
 12.2.3  调试 276                  
 12.2.4  控制 277                  
 12.2.5  应用程序服务器和数据库独立性 277                  
 12.2.6  关联 278                  
 12.2.7  学习曲线和代价 278                  
 12.3  为实体Bean选择正确的粒度 278                  
 12.4  持久化的提示和技巧 279                  
 12.4.1  需要注意对象关系之间的阻抗不匹配 279                  
 12.4.2  硬代码SQL和软代码SQL 280                  
 12.4.3  何时使用存储过程 280                  
 12.4.4  规范化和反规范化 282                  
 12.4.5  使用EJB对象模型来驱动数据模型 283                  
 12.4.6  采用最好的数据设计方法 283                  
 12.4.7  使用代理键 283                  
 12.4.8  理解数据库升级所带来的影响 284                  
 12.4.9  记录EJB组件的版本 284                  
 12.4.10  使用遗留数据库设计 285                  
 12.4.11  随时间改变的模式 289                  
 12.4.12  处理大结果集 290                  
 12.5  小结 291                  
 第13章  EJB最优操作和性能优化 293                  
 13.1  何时使用状态Bean和无状态Bean 293                  
 13.2  何时使用消息或者RMI-IIOP 294                  
 13.3  如何使用负载规划保证响应时间 296                  
 13.4  如何使用EJB实现单实例 297                  
 13.5  交换实体Bean和会话Bean 298                  
 13.6  性能调整实体Bean 299                  
 13.7  选择本地接口或者远程接口 300                  
 13.8  如何调试EJB 300                  
 13.9  区分资源 301                  
 13.10  装配组件 302                  
 13.11  开发可复用组件 303                  
 13.12  何时在EJB中使用XML 303                  
 13.13  同EJB进行遗留集成 304                  
 13.14  小结 306                  
 第14章  集群服务 307                  
 14.1  大规模系统概述 307                  
 14.1.1  何谓大规模系统 307                  
 14.1.2  基本术语 308                  
 14.1.3  集群的区分 309                  
 14.2  实现集群的EJB 312                  
 14.2.1  如何集群EJB组件 312                  
 14.2.2  幂等的概念 313                  
 14.2.3  无状态会话Bean的集群 313                  
 14.2.4  状态会话Bean的集群 315                  
 14.2.5  实体Bean的集群 316                  
 14.2.6  消息驱动Bean的集群 318                  
 14.3  其他EJB集群问题 319                  
 14.3.1  First Contact 319                  
 14.3.2  Initial Access Logic 320                  
 14.4  小结 320                  
 第15章  开始EJB项目 321                  
 15.1  确定商务需求 321                  
 15.2  确定J2EE是否适合您的项目 321                  
 15.3  确定EJB是否合适 322                  
 15.4  确定项目开发人员 324                  
 15.5  设计完整的对象模型 325                  
 15.6  实现单个垂直薄片（Vertical Slice） 326                  
 15.7  选择应用服务器 327                  
 15.8  划分开发小组 327                  
 15.9  投资开发工具 329                  
 15.10  投资标准建立方法 329                  
 15.11  小结 330                  
 第16章  选择EJB服务器 331                  
 16.1  J2EE 1.3 商标 331                  
 16.2  可插入式JRE 331                  
 16.3  转换工具 332                  
 16.4  复杂映射 332                  
 16.5  第三方JDBC驱动程序的支持 332                  
 16.6  惰性载入 332                  
 16.7  延迟数据库写入 332                  
 16.8  可插入式持久化供应商 333                  
 16.9  内存中数据的缓存 333                  
 16.10  集成层次的支持 333                  
 16.11  可伸缩性 333                  
 16.12  高可用性 334                  
 16.13  安全性 334                  
 16.14  IDE集成 334                  
 16.15  UML编辑器的集成 335                  
 16.16  智能负载平衡 335                  
 16.17  无状态透明的失败转发 335                  
 16.18  集群 336                  
 16.19  Java管理扩展（JMX） 336                  
 16.20  管理支持 336                  
 16.21  热部署（Hot Deployment） 336                  
 16.22  实例组合 337                  
 16.23  自动EJB生成 337                  
 16.24  合理地关机 337                  
 16.25  实时部署 337                  
 16.26  分布式事务处理 338                  
 16.27  高级消息体系结构 338                  
 16.28  可选的EJB组件 338                  
 16.29  J2EE连接器体系结构（JCA） 338                  
 16.30  Web服务 339                  
 16.31  工作流程 339                  
 16.32  开放源代码 340                  
 16.33  专业化的服务 340                  
 16.34  非技术标准 340                  
 16.35  小结 341                  
 第17章  EJB-J2EE的集成：创建一个完整的应用 343                  
 17.1  商务问题 343                  
 17.2  最终网站预览 344                  
 17.3  技术需求 346                  
 17.3.1  商务逻辑层的对象模型 346                  
 17.3.2  产品 347                  
 17.3.3  顾客 348                  
 17.3.4  购物篮 348                  
 17.3.5  购物篮条目 349                  
 17.3.6  估价器 349                  
 17.3.7  订单 349                  
 17.3.8  订单条目 350                  
 17.3.9  订单处理器 350                  
 17.4  表达层的对象模型 351                  
 17.4.1  何谓Servlet 351                  
 17.4.2  何谓JavaServer Pages 353                  
 17.4.3  如何组合Servlet. JSP和EJB组件 353                  
 17.4.4  电子商务部署中的JSP 355                  
 17.5  示例代码 356                  
 17.6  小结 361                  
 第四篇  附    录                  
 附录A  RMI-IIOP和JNDI教程 365                  
 A.1  Java RMI-IIOP 365                  
 A.1.1  远程方法调用 366                  
 A.1.2  远程接口 367                  
 A.1.3  远程对象实现 368                  
 A.1.4  根程序和程序框架 370                  
 A.2  对象序列化和参数传递 371                  
 A.2.1  值传递 371                  
 A.2.2  对象序列化 371                  
 A.2.3  序列化规则 372                  
 A.2.4  怎样标识暂态 373                  
 A.2.5  对象序列化和RMI-IIOP 373                  
 A.3  Java命名和目录接口（JNDI） 376                  
 A.3.1  命名和目录服务器 376                  
 A.3.2  命名和目录的问题 378                  
 A.3.3  进入JNDI 378                  
 A.3.4  JNDI的优点 378                  
 A.3.5  JNDI的结构体系 379                  
 A.3.6  JNDI概念 380                  
 A.3.7  命名系统. 命名空间和合成命名 381                  
 A.3.8  初始上下文生成库 382                  
 A.3.9  JNDI编程 383                  
 A.4  RMI-IIOP和JNDI的集成 384                  
 A.4.1  将RMI-IIOP服务器绑定到JNDI 385                  
 A.4.2  使用JNDI查询RMI-IIOP服务器 386                  
 A.5  小结 387                  
 附录B  CORBA协同工作 389                  
 B.1  何谓CORBA 389                  
 B.2  为何要关心CORBA 390                  
 B.3  理解CORBA是如何工作的 391                  
 B.4  OMG的接口定义语言 392                  
 B.4.1  将OMG IDL映射成具体的语言 393                  
 B.4.2  CORBA静态调用 394                  
 B.5  CORBA提供的众多服务 395                  
 B.6  对RMI-IIOP的需求 395                  
 B.6.1  RMI-CORBA协同工作的需求 395                  
 B.6.2  RMI与CORBA的结合 397                  
 B.6.3  解决RMI和CORBA之间的差别 398                  
 B.7  RMI与CORBA的协同工作综述 400                  
 B.7.1  带有CORBA对象实现的RMI-IIOP客户 400                  
 B.7.2  带有RMI-IIOP对象实现的CORBA客户 400                  
 B.7.3  RMI-IIOP和CORBA的引导程序 401                  
 B.7.4  美好的前景：CORBA与EJB的结合 401                  
 B.7.5  不能从CORBA-EJB协同工作中获得 402                  
 B.7.6  范例代码 402                  
 B.8  小结 404                  
 附录C  部署描述符参考 405                  
 C.1  如何阅读DTD 405                  
 C.2  Header和Root元素 405                  
 C.3  定义会话Bean 407                  
 C.4  定义实体Bean 408                  
 C.4.1   409                  
 C.4.2   410                  
 C.4.3   410                  
 C.4.4   410                  
 C.4.5   411                  
 C.5  定义消息驱动Bean 411                  
 C.5.1   411                  
 C.5.2   412                  
 C.6  定义环境属性 413                  
 C.7  定义EJB引用 413                  
 C.7.1   414                  
 C.7.2   415                  
 C.8  定义安全性 415                  
 C.8.1   415                  
 C.8.2   416                  
 C.8.3   416                  
 C.9  定义资源工厂 416                  
 C.9.1   417                  
 C.9.2   417                  
 C.10  定义关联 418                  
 C.10.1   419                  
 C.10.2   419                  
 C.10.3   419                  
 C.10.4   420                  
 C.10.5   420                  
 C.10.6  定义装配描述符 420                  
 C.10.7   421                  
 C.10.8   422                  
 C.10.9   422                  
 C.10.10   422                  
 C.10.11   423                  
 C.10.12   423                  
 C.10.13   423                  
 附录D  EJB查询语言 425                  
 D.1  概述 425                  
 D.1.1  一个简单示例 425                  
 D.1.2  关联的作用 427                  
 D.2  EJB-QL语法 427                  
 D.2.1  FROM语句 427                  
 D.2.2  WHERE语句 429                  
 D.2.3  执行比较操作 431                  
 D.2.4  SELECT语句 431                  
 D.2.5  真值表 434                  
 D.3  小结 435                  
 附录E  EJB快速索引向导 437                  
 E.1  EJB API 索引 447                  
 E.1.1  EJBContext 447                  
 E.1.2  EJBHome 448                  
 E.1.3  EJBLocalHome 448                  
 E.1.4  EJBLocalObject 449                  
 E.1.5  EJBMetaData 450                  
 E.1.6  EJBObject 450                  
 E.1.7  EnterpriseBean 451                  
 E.1.8  EntityBean 451                  
 E.1.9  EntityContext 454                  
 E.1.10  Handle 455                  
 E.1.11  HomeHandle 455                  
 E.1.12  MessageDrivenBean 456                  
 E.1.13  MessageDrivenContext 456                  
 E.1.14  SessionBean 456                  
 E.1.15  SessionContext 458                  
 E.1.16  SessionSynchronization 458                  
 E.2  异常索引 459                  
 E.3  事务索引 460