Enterprise Java with UML中文版：第2版

第1章  用UML对Java建模        1
1.1  什么是建模        2
1.1.1  简化        2
1.1.2  不同的视角        2
1.1.3  通用符号        3
1.2  UML        3
1.3  用UML对软件系统建模        10
1.3.1  客户的角度        10
1.3.2  开发者的角度        10
1.4  建模过程        11
1.4.1  需求收集        11
1.4.2  分析        11
1.4.3  技术选择        11
1.4.4  架构        11
1.4.5  设计和实现        12
1.5  网站上的内容        12
1.6  下一步        12
第2章  利用UML收集需求        13
2.1  准备好了吗        13
2.2  什么是好的需求        14
2.2.1  寻找合适的人        14
2.2.2  倾听相关人员的需求        15
2.2.3  开发一个可理解的需求        15
2.2.4  详细和完整地描述需求        18
2.2.5  重构用例模型        20
2.3  收集用户需求的准则        26
2.3.1  集中在问题上        26
2.3.2  不要放弃        26
2.3.3  不要走得太远        26
2.3.4  对过程要有信心        27
2.4  如何检测不好的需求        28
2.4.1  问题1：进度压力太大        28
2.4.2  问题2：愿景不明朗        29
2.4.3  问题3：过早的架构和设计        30
2.5  下一步        30
第3章  为考勤卡应用程序收集需求        31
3.1  听相关人员说        31
3.2  构建用例图        32
3.2.1  寻找参与者        33
3.2.2  寻找用例        34
3.2.3  确定参与者和用例之间的关系        35
3.3  描述细节        36
3.4  收集更多的需求        43
3.5  修订用例模型        45
3.5.1  修订用例图        45
3.5.2  修订用例文档        47
3.6  下一步        55
第4章  用UML进行面向对象分析简介        57
4.1  准备好了吗        57
4.1.1  可靠的需求        57
4.1.2  用例分级        58
4.2  什么是面向对象分析        59
4.2.1  分析模型        59
4.2.2  与用例模型的关系        59
4.2.3  面向对象分析的步骤        60
4.3  寻找候选对象        60
4.3.1  寻找对象的准则        60
4.3.2  寻找对象的步骤        62
4.4  描述行为        66
4.4.1  寻找行为的准则        67
4.4.2  描述行为的步骤        68
4.5  描述类        70
4.5.1  描述类的准则        71
4.5.2  描述类的步骤        72
4.6  下一步        75
第5章  考勤卡应用程序分析模型        77
5.1  用例分级        77
5.1.1  分级系统        77
5.1.2  评估“Extract Time Entries”用例        80
5.1.3  评估“Create Charge Code”用例        80
5.1.4  评估“Change Password”用例        81
5.1.5  评估“Login”用例        81
5.1.6  评估“Record Time”用例        82
5.1.7  评估“Create Employee”用例        82
5.1.8  选择第一次迭代的用例        83
5.2  寻找候选对象        83
5.2.1  寻找实体对象        84
5.2.2  寻找边界对象        87
5.2.3  寻找控制类        87
5.2.4  寻找生命周期类        88
5.3  描述对象交互        88
5.3.1  为“Login”添加假设的行为        88
5.3.2  为“Login”构建顺序图        89
5.3.3  验证“Login”序列        91
5.3.4  其他用例的顺序图和类图        92
5.4  描述类        94
5.4.1  寻找“Login”中的关系        95
5.4.2  寻找“Extract Time Entries”中的关系        96
5.4.3  寻找“Record Time”中的关系        96
5.5  下一步        97
第6章  从选择技术的角度描述系统        99
6.1  准备好了吗        99
6.2  将分析类分组        100
6.2.1  边界类:用户界面        100
6.2.2  边界类:系统接口        101
6.2.3  控制类、实体类和生命周期类        101
6.3  描述每一个组        101
6.3.1  用户界面复杂度        102
6.3.2  用户界面的部署约束        103
6.3.3  用户的数量和类型        104
6.3.4  可用带宽        105
6.3.5  系统接口的类型        106
6.3.6  性能和可伸缩性        107
6.4  考勤卡应用程序的技术需求        108
6.4.1  寻找分析类的分组        108
6.4.2  用户界面复杂度        108
6.4.3  用户界面的部署约束        109
6.4.4  用户的数量和类型        110
6.4.5  可用带宽        110
6.4.6  系统接口的类型        111
6.4.7  性能和可伸缩性        111
6.5  下一步        113
第7章  为共享服务评估候选技术        115
7.1  技术模板        115
7.2  Java日志类库        116
7.2.1  惊人的细节        116
7.2.2  优势        125
7.2.3  不足        126
7.2.4  兼容技术        126
7.2.5  采用成本        126
7.3  应用程序异常处理        126
7.3.1  异常处理的简要回顾        126
7.3.2  应用程序异常处理的目标        130
7.3.3  优势        133
7.3.4  不足        133
7.3.5  兼容技术        133
7.3.6  采用成本        133
7.4  使用JCE保护数据        134
7.4.1  术语        134
7.4.2  惊人的细节：用对称加密算法保护数据        135
7.4.3  用非对称加密算法进行数据和密钥交换        139
7.4.4  密钥管理        145
7.4.5  优势        146
7.4.6  不足        146
7.4.7  兼容技术        146
7.4.8  采用成本        146
7.5  使用JSSE进行安全通信        146
7.5.1  惊人的细节        147
7.5.2  优势        152
7.5.3  不足        153
7.5.4  兼容技术        153
7.5.5  采用成本        153
7.6  Java管理扩展API——JMX 1.2        153
7.6.1  JMX整体架构        153
7.6.2  JMX术语        154
7.6.3  惊人的细节        155
7.6.4  优势        176
7.6.5  不足        176
7.6.6  兼容技术        176
7.6.7  采用成本        176
7.6.8  适用性        177
7.7  结论        177
7.8  下一步        177
第8章  HTML产生框架        179
8.1  设计目标        179
8.1.1  目标1：支持视图的模块结构        180
8.1.2  目标2：简化HTML的生成        180
8.1.3  目标3：可扩展性和独立性        181
8.2  按目标进行设计        182
8.2.1  按目标1进行设计：支持视图的模块结构        182
8.2.2  按目标2进行设计：简化HTML的生成        185
8.2.3  按目标3进行设计：可扩展性和独立性        186
8.2.4  HTML产生框架的设计        187
8.2.5  Core包        187
8.2.6  内容基元包        188
8.2.7  表单基元包        188
8.2.8  布局基元包        189
8.3  实现        190
8.3.1  Core包        191
8.3.2  ContentElements包        193
8.3.3  FormPrimitives包        199
8.3.4  Layout包        205
8.3.5  单元测试HTML基元        212
8.3.6  一个特定应用的HTML产生器        214
8.4  优势        219
8.5  不足        219
8.6  兼容技术        219
8.7  采用成本        219
8.7.1  UI设计人员        219
8.7.2  Java开发者        219
8.8  适用性        220
8.9  下一步        220
第9章  为用户界面类评估候选技术        221
9.1  Swing        221
9.1.1  惊人的细节        222
9.1.2  优势        230
9.1.3  不足        230
9.1.4  兼容技术        230
9.1.5  采用成本        230
9.1.6  适用性        231
9.2  Java  servlet        232
9.2.1  惊人的细节        234
9.2.2  示例：网上调查系统        238
9.2.3  优势        250
9.2.4  不足        250
9.2.5  兼容技术        251
9.2.6  采用成本        251
9.2.7  适用性        252
9.3  JSP        253
9.3.1  惊人的细节        253
9.3.2  优势        256
9.3.3  不足        256
9.3.4  兼容技术        256
9.3.5  采用成本        256
9.3.6  适用性        257
9.4  JSP和servlet        257
9.5  为考勤系统选择技术        259
9.6  结论        260
9.7  下一步        260
第10章  为系统接口评估候选技术        261
10.1  XML        261
10.1.1  惊人的细节        262
10.1.2  优势        263
10.1.3  不足        264
10.1.4  兼容技术        264
10.1.5  采用成本        264
10.1.6  适用性        264
10.2  SAX        265
10.2.1  惊人的细节        265
10.2.2  优势        274
10.2.3  不足        274
10.2.4  兼容技术        274
10.2.5  采用成本        274
10.3  DOM        274
10.3.1  惊人的细节        275
10.3.2  优势        281
10.3.3  不足        281
10.3.4  兼容技术        281
10.3.5  采用成本        281
10.4  JMS        282
10.4.1  术语        283
10.4.2  惊人的细节        284
10.4.3  优势        302
10.4.4  不足        302
10.4.5  兼容技术        302
10.4.6  采用成本        302
10.5  结论        303
10.6  下一步        303
第11章  为系统接口评估Web服务技术        305
11.1  揭开Web服务的神秘面纱        305
11.1.1  SOAP协议        309
11.1.2  UDDI        313
11.1.3  WSDL        315
11.2  Java中的Web服务        319
11.2.1  JAXP        319
11.2.2  JAXR        323
11.2.3  JAX-RPC        333
11.3  结论        340
11.4  下一步        340
第12章  为控制类和实体类评估候选技术        341
12.1  RMI        341
12.1.1  惊人的细节        341
12.1.2  RMI的一般用法        344
12.1.3  优势        347
12.1.4  不足        347
12.1.5  兼容技术        347
12.1.6  采用成本        348
12.2  JDBC        348
12.2.1  惊人的细节        349
12.2.2  优势        353
12.2.3  不足        353
12.2.4  兼容技术        354
12.2.5  采用成本        354
12.2.6  RMI和JDBC的适用性        354
12.3  EJB 2.0        355
12.3.1  惊人的细节        358
12.3.2  优势        362
12.3.3  不足        363
12.3.4  兼容技术        363
12.3.5  采用成本        363
12.3.6  适用性        364
12.4  技术选择范例        364
12.5  结论        365
12.6  下一步        366
第13章  软件架构        367
13.1  准备好了吗        367
13.1.1  清晰准确地理解所面对的问题        367
13.1.2  清晰准确地理解候选技术        368
13.2  软件架构的目标        368
13.2.1  可扩展性        368
13.2.2  可维护性        369
13.2.3  可靠性        369
13.2.4  可伸缩性        369
13.3  UML和架构        369
13.3.1  包        370
13.3.2  包依赖关系        371
13.3.3  子系统        373
13.4  软件架构的准则        375
13.4.1  内聚性        375
13.4.2  耦合性        375
13.5  建立软件架构        375
13.5.1  架构师        376
13.5.2  架构建立过程        376
13.6  考勤系统的样本架构        378
13.6.1  确立目标        378
13.6.2  将类分组并评估各个类        378
13.6.3  展示技术        383
13.6.4  针对准则和目标对架构进行评估        383
13.7  下一步        384
第14章  设计入门        385
14.1  什么是设计        385
14.2  准备好了吗        385
14.3  设计的必要性        385
14.3.1  生产力和士气        386
14.3.2  一种具有适应能力的交流工具        386
14.3.3  进度安排和工作分配        387
14.4  设计模式        387
14.4.1  益处        387
14.4.2  使用        388
14.5  规划设计工作        388
14.5.1  为整个设计建立目标        389
14.5.2  建立设计准则        390
14.5.3  寻找独立的设计工作        391
14.6  设计包或者子系统        391
14.7  考勤系统的设计工作        392
14.8  下一步        392
第15章  设计TimecardDomain包和TimecardWorkflow包        393
15.1  确定工作目标        393
15.1.1  性能和可靠性        393
15.1.2  重用        394
15.1.3  可扩展性        394
15.2  对前一步工作进行评审        394
15.2.1  评审分析模型        394
15.2.2  评审架构约束        400
15.3  针对目标进行设计        401
15.4  将设计应用于用例        402
15.4.1  “Login”用例的设计        402
15.4.2  “Record  Time”用例的设计        405
15.4.3  “Extract  Time  Entries”用例的设计        407
15.5  设计方案评估        412
15.6  实现        413
15.6.1  EJB实现策略        414
15.6.2  User实体bean        414
15.6.3  Timecard实体bean        419
15.6.4  TimeEntry实体bean        424
15.6.5  LoginWorkflow无状态会话bean        425
15.6.6  RecordTimeWorkflow有状态会话bean        429
15.6.7  支持类        429
15.6.8  用JUnit进行单元测试        434
15.7  下一步        437
第16章  设计TimecardUI包        439
16.1  确定设计目标        439
16.1.1  可扩展性        439
16.1.2  可测试性        439
16.2  对前一步工作进行评审        440
16.2.1  评审架构约束        440
16.2.2  评审分析模型        441
16.3  针对目标进行设计        444
16.4  每个用例的设计        445
16.4.1  “Login”用例的设计        445
16.4.2  “Record Time”用例的设计        448
16.5  实现        451
16.6  下一步        460
第17章  BillingSystemInterface的设计        461
17.1  认清目标        461
17.1.1  清晰度        461
17.1.2  性能和可靠性        461
17.1.3  可扩展性        461
17.1.4  可重用性        462
17.2  分析模型的评审        462
17.3  架构的评审        462
17.4  设计        463
17.4.1  “Extract Time Entry”的SOAP/XML请求        463
17.4.2  “Extract Time Entry”的SOAP/XML响应        465
17.4.3  “Extract Time Entries”用例的设计        468
17.4.4  实现        470
17.5  结论        493
附录A  配套网站上的内容        495
附录B  额外资源        497