注册 | 登录读书好,好读书,读好书!
读书网-DuShu.com
当前位置: 首页出版图书科学技术计算机/网络软件与程序设计JAVA及其相关J2EE企业级应用开发

J2EE企业级应用开发

J2EE企业级应用开发

定 价:¥59.00

作 者: 刘晓华等编著
出版社: 电子工业出版社
丛编项: 开发专家之Sun ONE
标 签: J2EE

ISBN: 9787505389434 出版时间: 2003-08-01 包装: 平装
开本: 26cm 页数: 632 字数:  

内容简介

  本书属于《开发专家之Sun ONE》系列丛书,详细介绍了J2EE企业级应用开发的相关问题和建模、编程技术。全书分为四篇,共26章,全面介绍了UML技术在J2EE企业级应用开发中各个过程、各个方面的应用。包含了企业级应用开发的基础、UML技术和企业级应用开发建模、设计模式的应用、需求建模、分析建模、组件建模、部署建模、客户层实现、表示层实现、业务层实现、数据访问的实现、分布的实现和完整的开发实例。除了介绍这些开发技术外,本书着重于企业级应用开发中的建模技术,并且使用一定的方法、模式来提高应用开发的效率。附录部分介绍了光盘的使用方法和参考资料等内容。附赠光盘为本书范例源代码。本书适合于专业J2EE应用开发人员和致力于使用UML来提高J2EE应用开发技能的读者,也可作为软件工程项目管理人员的参考书籍。

作者简介

暂缺《J2EE企业级应用开发》作者简介

图书目录

第一篇  基础                  
 第1章  企业级应用的概念 3                  
 1.1  企业级应用的定义 3                  
 1.2  企业级软件的特殊问题 5                  
 1.2.1  伸缩性 5                  
 1.2.2  安全性 5                  
 1.2.3  异构和互通 6                  
 1.2.4  分布式 6                  
 1.3  企业级应用的历史. 现状                  
 和未来 6                  
 1.3.1  企业级应用结构分层                  
 发展的历史 6                  
 1.3.2  企业级应用业务范围的                  
 发展趋势 8                  
 1.4  企业级应用的实例 9                  
 1.5  小结 10                  
 第2章  深入了解企业级应用 11                  
 2.1  企业级应用的公共基础服务 11                  
 2.1.1  安全 11                  
 2.1.2  事务 11                  
 2.1.3  缓冲 12                  
 2.1.4  生存期管理 12                  
 2.2  企业级应用开发平台 12                  
 2.2.1  J2EE 12                  
 2.2.2  .NET 13                  
 2.3  企业级应用的一般结构 16                  
 2.3.1  分层 16                  
 2.3.2  分布 18                  
 2.4  组件和企业级应用 18                  
 2.4.1  组件技术 18                  
 2.4.2  流行的组件技术                  
 和平台 19                  
 2.4.3  区分组件和对象 20                  
 2.5  企业级应用的开发流程 21                  
                   
 2.5.1  建模 21                  
 2.5.2  实现 22                  
 2.5.3  部署 22                  
 2.6  小结 23                  
 第3章  J2EE和企业级应用 25                  
 3.1  J2EE 是企业级计算平台 25                  
 3.1.1  J2EE的由来 25                  
 3.1.2  J2EE的现状 26                  
 3.1.3  J2EE体系结构简介 26                  
 3.1.4  为什么使用J2EE 28                  
 3.1.5  J2EE存在哪些风险 28                  
 3.2  J2EE的基本思想 29                  
 3.2.1  基于标准协议 29                  
 3.2.2  共享公共服务 30                  
 3.2.3  软件组件化 31                  
 3.3  J2EE为企业级应用                  
 提供的支持 32                  
 3.3.1  表示逻辑 33                  
 3.3.2  业务逻辑 35                  
 3.3.3  数据访问逻辑 35                  
 3.4  J2EE其他关键技术 36                  
 3.4.1  JNDI 36                  
 3.4.2  RMI 37                  
 3.4.3  JMS 38                  
 3.4.4  J2EE连接器 38                  
 3.4.5  Java事物服务 38                  
 3.4.6  JavaMail 39                  
 3.4.7  JAAS 39                  
 3.4.8  XML 39                  
 3.4.9  JavaBean 40                  
 3.5  小结 40                  
 第4章  企业级应用建模 41                  
 4.1  为什么要建模 41                  
 4.1.1  建模的重要性 41                  
 4.1.2  建模的原理 42                  
 4.1.3  面向对象的建模技术 43                  
 4.2  统一建模语言UML 44                  
 4.2.1  UML的产生和成长 44                  
 4.2.2  什么是UML 45                  
 4.2.3  UML的目标 46                  
 4.3  建模的阶段 46                  
 4.3.1  领域建模 46                  
 4.3.2  需求建模 47                  
 4.3.3  分析建模 48                  
 4.3.4  设计建模 48                  
 4.3.5  实现建模 48                  
 4.4  建模工具 49                  
 4.4.1  工具的支持 49                  
 4.4.2  常用的建模工具简介 50                  
 4.4.3  Rational Rose 51                  
 4.5  小结 52                  
 第5章  UML建模技术 53                  
 5.1  为什么选择UML 53                  
 5.1.1  工业标准 53                  
 5.1.2  支持用例驱动 54                  
 5.1.3  帮助理解系统 54                  
 5.1.4  可视化的软件开发 54                  
 5.1.5  UML的其他                  
 几点说明 55                  
 5.2  UML事物和关系 55                  
 5.2.1  UML中的事物 55                  
 5.2.2  UML中的关系 58                  
 5.3  UML中的图 59                  
 5.2.1  用于表示静态关系                  
 建模的图 59                  
 5.2.2  用于表示动态关系                  
 建模的图 63                  
 5.4  UML的扩展机制 68                  
 5.4.1  约束 68                  
 5.4.2  版式 69                  
 5.4.3  标签值 69                  
 5.5  用UML对J2EE建模 70                  
                   
 5.5.1  为什么要用UML                  
 对J2EE建模 70                  
 5.5.2  Rose在J2EE上的                  
 特殊支持 71                  
 5.6  小结 72                  
 第6章  Java语言和UML 73                  
 6.1  面向对象的Java语言 73                  
 6.1.1  面向对象的含义 73                  
 6.1.2  面向对象的程序                  
 设计 74                  
 6.1.3  对象. 类. 接口.                   
 组件. 模板 75                  
 6.1.4  面向对象的设计                  
 和UML 77                  
 6.2  类 77                  
 6.2.1  类的组成元素 78                  
 6.2.2  类的UML表示 80                  
 6.2.3  若干特殊类 81                  
 6.3  接口 84                  
 6.3.1  接口的组成 84                  
 6.3.2  区别接口和抽象类 85                  
 6.3.3  接口的UML表示 86                  
 6.3.4  接口的实现 89                  
 6.3.5  接口的变量 90                  
 6.3.6  标识接口                  
 (Mark Interface) 91                  
 6.4  对象 91                  
 6.4.1  一切活动的元素                  
 都是对象 91                  
 6.4.2  对象的UML表示 93                  
 6.4.3  对象的关系 94                  
 6.5  包 94                  
 6.5.1  什么是包 94                  
 6.5.2  包的组成和UML                  
 表示 95                  
 6.5.3  包间的关系 96                  
 6.5.4  Java中常用的包 97                  
 6.6  类关系 97                  
                   
 6.6.1  继承 98                  
 6.6.2  关联 101                  
 6.6.3  聚合 103                  
 6.6.4  组合 104                  
 6.6.5  依赖 106                  
 6.7  小结 108                  
 第7章  功能复用 109                  
 7.1  软件复用的意义 109                  
 7.1.1  软件复用的概念 109                  
 7.1.2  加快企业软件                  
 发展速度 110                  
 7.1.3  提供企业级应用的                  
 稳定性 110                  
 7.1.4  提供企业级应用的                  
 伸缩性 110                  
 7.2  软件复用的层次 110                  
 7.2.1  源代码级的                  
 代码复用 111                  
 7.2.2  DLL层次的                  
 函数复用 111                  
 7.2.3  COM级的                  
 二进制对象复用 111                  
 7.2.4  组件级复用 112                  
 7.2.5  框架复用 112                  
 7.3  软件复用的实现 113                  
 7.3.1  继承 113                  
 7.3.2  组合 113                  
 7.3.3  继承和组合之间的                  
 选择 114                  
 7.4  Java接口和软件复用 116                  
 7.4.1  理解Java中的接口 116                  
 7.4.2  多态 118                  
 7.4.3  面向接口编程 120                  
 7.5  小结 120                  
 第二篇  建模                  
 第8章  企业级应用常用的                  
 开发方法 123                  
 8.1  理解软件开发过程 123                  
 8.1.1  理解软件过程的                  
 概念 123                  
 8.1.2  软件工程与过程.                   
 方法. 工具 124                  
 8.2  Rational统一过程 124                  
 8.2.1  通过RUP利用软件                  
 开发的六大经验 125                  
 8.2.2  阶段和迭代 125                  
 8.2.3  RUP的核心工作流 128                  
 8.2.4  制品 129                  
 8.3  其他开发方法 130                  
 8.4  小结 134                  
 第9章  需求分析建模 135                  
 9.1  企业级应用的需求分析 135                  
 9.1.1  为什么要进行                  
 需求分析 135                  
 9.1.2  需求分析的方法 136                  
 9.1.3  企业级应用需求                  
 分析 137                  
 9.1.4  用例分析技术 137                  
 9.2  参与者 138                  
 9.2.1  参与者的概念 138                  
 9.2.2  参与者的确定 138                  
 9.2.3  区别参与者和用例 139                  
 9.2.4  参与者的继承 140                  
 9.3  用例分析 140                  
 9.3.1  确定用例 140                  
 9.3.2  用例的关系 141                  
 9.3.3  用例描述 143                  
 9.3.4  场景 144                  
 9.3.5  添加通信的指向 144                  
 9.4  系统边界 145                  
 9.4.1  边界的发现 145                  
 9.4.2  潜在的边界 146                  
 9.5  用例细化 147                  
 9.5.1  确定参与者和系统                  
 交互 147                  
 9.5.2  确定工作流程 148                  
 9.6  小结 149                  
 第10章  总体设计概述 151                  
 10.1  进一步细化用例描述 151                  
 10.1.1  用例优化 151                  
 10.1.2  用例的粒度 152                  
 10.1.3  用例的子用例 153                  
 10.1.4  细化用例描述 154                  
 10.2  确定三类对象 156                  
 10.2.1  边界对象 156                  
 10.2.2  实体对象 156                  
 10.2.3  控制对象 157                  
 10.3  描述三类对象的协作                  
  关系 158                  
 10.3.1  顺序图 158                  
 10.3.2  协作图 159                  
 10.4  为用例创建类图 160                  
 10.4.1  创建分析类 160                  
 10.4.2  标识类之间的关系 163                  
 10.5  小结 164                  
 第11章  功能分派 165                  
 11.1  分派到包 165                  
 11.1.1  怎么划分包 165                  
 11.1.2  包之间的依赖关系 166                  
 11.1.3  划分包的技巧 166                  
 11.1.4  弱化包之间的                  
  耦合关系 167                  
 11.2  确定设计类 167                  
 11.2.1  设计类的特点 167                  
 11.2.2  确定设计类 168                  
 11.2.3  确定设计类的属性 168                  
 11.2.4  确定设计类的操作 169                  
 11.2.5  确定设计类的关系 169                  
 11.3  子系统 170                  
 11.3.1  划分子系统的原则 170                  
 11.3.2  设计子系统 171                  
 11.3.3  实现子系统 171                  
 11.3.4  子系统的依赖关系 172                  
 11.4  设计公共接口 172                  
                   
 11.4.1  从用例图中                  
  发现接口 172                  
 11.4.2  为子系统设计接口 174                  
 11.5  小结 175                  
 第12章  使用软件体系结构划分                  
          企业级应用 177                  
 12.1  什么是软件体系结构 177                  
 12.1.1  基本定义和内涵 177                  
 12.1.2  使用的好处 178                  
 12.2  使用框架 179                  
 12.2.1  框架的概念 179                  
 12.2.2  框架的分类 180                  
 12.2.3  应用框架 180                  
 12.2.4  框架与组件. 类库的                  
  关系 181                  
 12.2.5  框架和设计模式 181                  
 12.2.6  怎么获得 181                  
 12.3  设计模式 182                  
 12.3.1  模式的形成历史 182                  
 12.3.2  模式的含义 182                  
 12.3.3  模式的要素 183                  
 12.3.4  模式的分类 184                  
 12.3.5  常用的设计模式 184                  
 12.4  企业级应用体系结构                  
  和分层 186                  
 12.4.1  层的概念 187                  
 12.4.2  分层(Layer) 187                  
 12.5  J2EE体系结构 188                  
 12.5.1  MVC体系结构 188                  
 12.5.2  J2EE的层 189                  
 12.6  小结 192                  
 第13章  设计模式 193                  
 13.1  创建模式 193                  
 13.1.1  工厂方法模式 194                  
 13.1.2  抽象工厂模式 196                  
 13.1.3  单态模式 198                  
 13.1.4  建造模式 199                  
 13.1.5  原型模式 201                  
                   
 13.2  结构模式 202                  
 13.2.1  适配器模式                  
 (Adapter) 202                  
 13.2.2  桥接模式(Bridge) 203                  
 13.2.3  组合模式                  
 (Composite) 205                  
 13.2.4  装饰模式                  
 (Decorator) 207                  
 13.2.5  门面模式                  
 (Facade) 209                  
 13.2.6  代理模式                  
 (Proxy) 211                  
 13.2.7  享元模式                  
 (Flyweight) 212                  
 13.3  行为模式 214                  
 13.3.1  调停者模式                  
 (Mediator) 214                  
 13.3.2  策略模式                  
 (Strategy) 216                  
 13.3.3  模板方法模式                  
 (Template) 218                  
 13.3.4  观察者模式                  
  (Observer) 220                  
 13.3.5  迭代模式                  
 (Iterator) 223                  
 13.3.6  责任链模式(Chain of                  
  Responsibility) 224                  
 13.3.7  命令模式                  
 (Command) 226                  
 13.3.8  状态模式(State) 228                  
 13.3.9  访问者模式                  
 (Visitor) 231                  
 13.3.10  备忘录模式                  
 (Memento) 233                  
 13.3.11  解释器模式                  
 (Interpreter) 234                  
 13.4  小结 235                  
 第14章  J2EE核心模式实践 237                  
 14.1  J2EE模式概览 237                  
 14.2  表示层模式 239                  
 14.2.1  截取过滤器 239                  
 14.2.2  前端控制器 242                  
 14.2.3  视图助手 244                  
 14.2.4  复合视图 246                  
 14.2.5  工作者服务 249                  
 14.2.6  分发者视图 249                  
 14.3  业务层模式 250                  
 14.3.1  业务代表 250                  
 14.3.2  值对象 253                  
 14.3.3  会话外观 255                  
 14.3.4  复合实体 258                  
 14.3.5  值对象组装器 260                  
 14.3.6  值列表处理器 262                  
 14.3.7  服务定位器 264                  
 14.4  集成层模式 266                  
 14.4.1  数据访问对象(Data-                  
 AccessObject) 267                  
 14.4.2  服务激发器 269                  
 14.5  小结 270                  
 第15章  实现 271                  
 15.1  规范化编码风格 271                  
 15.1.1  命名规范 271                  
 15.1.2  排版风格 272                  
 15.1.3  注释 273                  
 15.1.4  文档规范 274                  
 15.2  J2EE应用中的角色 278                  
 15.2.1  EJB提供者 279                  
 15.2.2  应用程序组装者 283                  
 15.2.3  部署者 284                  
 15.2.4  系统管理员 285                  
 15.2.5  应用程序服务器/                  
 EJB容器厂商 285                  
 15.3  版本控制 286                  
 15.4  小结 291                  
 第16章  部署 293                  
 16.1  UML中的组件 293                  
 16.1.1  组件的种类 294                  
 16.1.2  组件和接口 294                  
 16.1.3  组件图 295                  
 16.2  J2EE组件建模 295                  
 16.2.1  Web组件 296                  
 16.2.2  EJB组件 296                  
 16.2.3  J2EE企业级应用的                  
  组件建模 297                  
 16.3  部署建模 298                  
 16.3.1  结点 298                  
 16.3.2  部署图 299                  
 16.3.3  冗余配置 300                  
 16.4  J2EE应用的部署 300                  
 16.4.1  DTD 301                  
 16.4.2  Web部署描述符 302                  
 16.4.3  EJB部署描述符 304                  
 16.4.4  Application部署                  
  描述符 305                  
 16.4.5  厂商专有的部署                  
  描述符 306                  
 16.5  小结 306                  
 第三篇  实现                  
 第17章  客户层的实现 309                  
 17.1  界面设计的一般方法 309                  
 17.1.1  确定使用者和                  
  系统的交互 309                  
 17.1.2  确定输入 310                  
 17.1.3  设置输出 310                  
 17.1.4  提供帮助信息 311                  
 17.1.5  使用界面组件 311                  
 17.1.6  对界面元素关系                  
  建模 311                  
 17.2  控制台界面 312                  
 17.2.1  确定输入流                  
  和输出流 313                  
 17.2.2  设计一个控制台                  
  界面 314                  
 17.3  GUI界面的实现 317                  
                   
 17.3.1  基于AWT组件的                  
  GUI界面 318                  
 17.3.2  基于Swing组件的                  
  GUI界面 320                  
 17.3.3  常用的Swing                  
  组件 321                  
 17.3.4  理解事件驱动 331                  
 17.4  Web界面的实现 334                  
 17.4.1  静态HTML 334                  
 17.4.2  动态HTML 336                  
 17.4.3  JSP和Servlet 339                  
 17.5  小结 339                  
 第18章  表示层实现 341                  
 18.1  JSP简介 341                  
 18.2  JSP的构成 342                  
 18.2.1  模板元素 342                  
 18.2.2  指令元素 342                  
 18.2.3  脚本元素 344                  
 18.2.4  动作元素 346                  
 18.2.5  JSP内建对象 353                  
 18.3  在JSP中使用JavaBean                  
  和标签库 356                  
 18.3.1  在JSP里                  
  使用JavaBean 357                  
 18.3.2  在JSP里使用                  
  Taglib 359                  
 18.4  Servlet技术 367                  
 18.4.1  Servlet简介 367                  
 18.4.2  一般用途 368                  
 18.4.3  生命周期 368                  
 18.4.4  处理请求 369                  
 18.4.5  响应的产生 369                  
 18.5  JSP应用的典型结构 371                  
 18.5.1  典型结构 371                  
 18.5.2  JSP+JavaBean 371                  
 18.5.3  JSP+Servlet+                  
  JavaBean 372                  
 18.6  JSP与UML建模 372                  
                   
 18.6.1  客户端关系建模 372                  
 18.6.2  服务器端关系建模 373                  
 18.7  小结 374                  
 第19章  业务逻辑的实现 375                  
 19.1  普通类的实现 375                  
 19.2  用EJB组件实现                  
  业务逻辑 376                  
 19.2.1  EJB介绍 376                  
 19.2.2  选用EJB组件的                  
  优势和不足 376                  
 19.2.3  EJB组件的类型 377                  
 19.3  事务和EJB 378                  
 19.3.1  事务的概念 378                  
 19.3.2  Bean管理事务 380                  
 19.3.3  容器管理事务 380                  
 19.3.4  事物的属性 380                  
 19.4  UML和EJB 381                  
 19.4.1  用UML表示EJB 381                  
 19.4.2  利用UML的                  
  扩展机制表示                  
  EJB的各个元素 382                  
 19.4.3  客户端视图 382                  
 19.4.4  EJB内部视图 383                  
 19.5  选择应用服务器                  
  和开发环境 384                  
 19.5.1  WebLogic Server 384                  
 19.5.2  JBoss 386                  
 19.5.3  JBoss和Rose.                   
  JCreator整合 387                  
 19.6  J2EE 1.4的新特性 389                  
 19.6.1  J2EE Connector                   
  Architecture 1.5 389                  
 19.6.2  EJB 2.1 390                  
 19.7  小结 392                  
 第20章  会话Bean 393                  
 20.1  会话Bean技术 393                  
 20.1.1  Home接口 393                  
 20.1.2  Remote接口 393                  
 20.1.3  实现类 394                  
 20.1.4  开发无状态                  
  会话Bean 394                  
 20.1.5  开发状态                  
  会话Bean 397                  
 20.2  EJB的性能 400                  
 20.2.1  把远程方法                  
  减到最少 400                  
 20.2.2  使用本地接口 401                  
 20.3  会话Bean的状态                  
  和生存周期 402                  
 20.3.1  会话Bean的状态 402                  
 20.3.2  会话Bean的                  
  生命周期 403                  
 20.3.3  会话Bean的                  
  顺序图 404                  
 20.3.4  实例钝化 406                  
 20.3.5  会话Bean的删除 407                  
 20.4  会话Bean建模 407                  
 20.4.1  接口行为建模 407                  
 20.4.2  关系建模 408                  
 20.5  在企业级应用中                  
  使用会话Bean 410                  
 20.5.1  会话Bean的                  
  使用步骤 411                  
 20.5.2  会话Bean的                  
  使用方法 412                  
 20.6  小结 413                  
 第21章  实体Bean 415                  
 21.1  实体Bean技术 415                  
 21.1.1  EJB1.1 和EJB2.0 415                  
 21.1.2  Home接口 418                  
 21.1.3  Remote接口                  
  或者本地接口 418                  
 21.1.4  主键类                  
 (PrimaryKeyClass) 418                  
 21.1.5  实现类 419                  
 21.1.6  持久性的类型 419                  
 21.2  实体Bean的开发 420                  
 21.2.1  开发CMP 420                  
 21.2.2  EJB2.0查询语言 426                  
 21.2.3  容器管理实体                  
  Bean之间的关系 428                  
 21.2.4  开发BMP 429                  
 21.3  实体Bean生命周期 431                  
 21.3.1  生命周期 431                  
 21.3.2  CMP顺序图 432                  
 21.4  实体Bean关系建模 434                  
 21.4.1  和Java类 434                  
 21.4.2  和JavaBean 435                  
 21.4.3  和会话(Session)                  
  Bean 436                  
 21.4.4  和Servlet. JSP 436                  
 21.4.5  实体Bean之间 437                  
 21.5  在企业级应用中                  
  使用实体Bean 437                  
 21.5.1  客户端使用实体                  
  Bean的过程 437                  
 21.5.2  组件的粒度 438                  
 21.6  小结 439                  
 第22章  消息驱动Bean 441                  
 22.1  消息驱动Bean技术 441                  
 22.1.1  JMS介绍 441                  
 22.1.2  消息驱动                  
  Bean技术 442                  
 22.1.3  使用消息驱动                  
  Bean的原因 442                  
 22.1.4  JMS定义了用于                  
  不同消息类型的类 443                  
 22.2  消息驱动Bean生命周期 443                  
 22.3  消息驱动Bean的开发 444                  
 22.4  消息驱动Bean视图                  
  和UML 449                  
 22.4.1  客户端视图 449                  
 22.4.2  消息建模 450                  
 22.5  在企业级应用中                  
  使用消息驱动Bean 451                  
 22.5.1  消息驱动Bean的                  
  使用顺序 451                  
 22.5.2  使用消息驱动                  
  Bean的条件 451                  
 22.6  小结 452                  
 第23章  数据库结构的实现 453                  
 23.1  选择一种数据库服务器 453                  
 23.1.1  SQL Server 453                  
 23.1.2  Oracle 455                  
 23.1.3  DB2 455                  
 23.1.4  Informix数据库                  
 管理系统 455                  
 23.2  设计数据容器 456                  
 23.2.1  表 456                  
 23.2.2  视图 460                  
 23.3  简化数据访问逻辑 462                  
 23.3.1  使用存储过程表 462                  
 23.3.2  使用视图 464                  
 23.4  小结 466                  
 第24章  数据访问层的实现 469                  
 24.1  数据访问层的设计原则 469                  
 24.1.1  一致性 469                  
 24.1.2  透明性 469                  
 24.1.3  简单性 470                  
 24.2  使用数据访问接口 470                  
 24.2.1  JDBC简介 470                  
 24.2.2  数据库驱动                  
  程序的类型 470                  
 24.2.3  JDBC URL 473                  
 24.2.4  连接池 473                  
 24.3  JDBC常用类的使用 475                  
 24.3.1  java.sql包 475                  
 24.3.2  javax.sql包 479                  
 24.4  在企业级应用开发中                  
  实现数据一致访问 481                  
 24.4.1  配置连接池 481                  
 24.4.2  事务的支持 482                  
 24.4.3  设计一致接口 484                  
 24.5  小结 489                  
 第25章  分布的实现 491                  
 25.1  分布式组件 491                  
 25.1.1  EJB组件 491                  
 25.1.2  WebService的分布 493                  
 25.1.3  .NET的远程框架 495                  
 25.2  集群 496                  
 25.2.1  集群的概念 496                  
 25.2.2  J2EE中支持集群的                  
  组件类型 498                  
 25.2.3  Servlet和JSP集群 498                  
 25.2.4  EJB和RMI                  
        对象集群 498                  
 25.2.5  JDBC集群 498                  
 25.2.6  集群的方案 499                  
 25.3  分布部署J2EE应用 500                  
 25.3.1  配置集群环境 500                  
 25.3.2  为JSP/Servlet集群 502                  
 25.3.3  为EJB集群 502                  
 25.3.4  为JDBC集群 506                  
 25.4  基于Web服务的                  
 分布式应用的实现 506                  
 25.5  小结 511                  
 第四篇  案例分析                  
 第26章  案例分析 515                  
 26.1  案例背景和问题陈述 515                  
 26.1.1  案例背景 515                  
 26.1.2  问题陈述 515                  
 26.1.3  其他的说明和约束 516                  
 26.2  要求 516                  
 26.2.1  在线购物服务 517                  
 26.2.2  在线试听服务 517                  
 26.2.3  在线交易服务 517                  
 26.2.4  查询服务 518                  
 26.2.5  客户账单的管理 518                  
 26.2.6  投诉服务 518                  
 26.2.7  管理服务 518                  
 26.3  起始阶段 519                  
 26.3.1  风险分析 519                  
 26.3.2  重现计划 519                  
 26.3.3  参与者 520                  
 26.3.4  用例 520                  
 26.3.5  用例图 523                  
 26.3.6  交互图 525                  
 26.4  加工阶段 526                  
 26.4.1  加工重现#1 527                  
 26.4.2  一些详细的顺序图 527                  
 26.4.3  类图 530                  
 26.4.4  打包图 532                  
 26.4.5  组件相关性图 533                  
 26.4.6  加工重现#2 533                  
 26.4.7  加工重现#3 534                  
 26.5  构造阶段 534                  
 26.5.1  开发计划 534                  
 26.5.2  实现模型 535                  
 26.5.3  测试模型 539                  
 26.6  构造详细代码 539                  
 26.6.1  公共使用的包 539                  
 26.6.2  业务层 547                  
 26.6.3  表示层 591                  
 26.7  迁移阶段 609                  
 附录A  术语表 611                  
 附录B  参考资料 619                  
 附录C  光盘资源 621                  
 附录D  使用JBuilder8和WebLogic7                  
 开发J2EE企业级应用 623                  
 附录E  JBoss使用说明 631                  

本目录推荐