标题：UML和模式应用：面向对象分析和设计及统一过程导论
基本信息
原书名： Applying UML and Patterns: An Introduction to Object-Oriented Analysis and Design and the Unified Process  原出版社： Pearson
作者： （美）Carig Larman,Philippe Kruchten [作译者介绍]
丛书名： 原版风暴系列
出版社：中国电力出版社
ISBN：7508322045
上架时间：2004-5-17
出版日期：2004 年5月
开本：16开
页码：656
版次：1-1
内容简介
本书是当今最畅销的介绍面向对象的分析/设计、迭代开发和UML的书籍。本书的目的是帮助开发人员或学生掌握关于面向对象的分析和设计的核心原理和最佳实践，并将它们真正应用到软件设计中去。本书的作者是颇有声望的对象技术和迭代方法的领军人物。本书在第一版的基础上做了全面的修订，增加了新的案例研究，更新了关于模式、用况、统一过程、架构分析等的探讨。
作者简介
Craig Larman是Valtech公司的首席科学家，该公司在技术咨询领域居领先地位；在国际软件开发社区中，他是对象技术、模式、UML、建模和迭代开发方面广为人知的专家。Larman从20世纪80年代就开始帮助人们学习对象和迭代开发，他亲自指导过的开发人员已达数千人 此外，他还是《Java 2 Performance and ldiom Guide》一书的作者之一，并拥有计算机科学学士和硕士学位、Larman的最新作品《Agile&Iterative Development：a Manager's Guide》(《敏捷迭代开发》)即将由中国电力出版社出版。
目录
目录回到顶部foreword xv 
preface xvii 
part i introduction 
1 object-oriented analysis and design 3 
applying uml and patterns in ooa/d 3 
assigning responsibilities 6 
what is analysis and design? 6 
what is object-oriented analysis and design? 7 
an example 7 
the uml 10 
further readings 11 
2 iterative development and the unified process 13 
the most important up idea: iterative development 14 
additional up best practices and concepts 18 
the up phases and schedule-oriented terms 19 
the up disciplines (was workfiows) 20 
process customization and the development case 23 
the agile up 24 
the sequential "waterfall" lifecycle 25 
you know you didn't understand the up when... 26 
.further readings 26 
3 case study: the nextgen pos system 29 
the nextgen pos system 29 
architectural layers and case study emphasis 30 
the book's strategy: iterative learning and development 31 
part ii inception 
4 inception 35 
inception: an analogy 36 
inception may be very brief 36 
what artifacts may start in inception? 37 
you know you didn't understand inception when... 38 
5 understanding requirements 41 
types of requirements 42 
further readings 43 
6 use-case model: writing requirements in context 45 
goals and stories 46 
background 46 
use cases and adding value 47 
use cases and functional requirements 48 
use case types and formats 49 
fully dressed example: process sale 50 
explaining the sections 54 
goals and scope of a use case 59 
finding primary actors, goals, and use cases 63 
congratulations: use cases have been written, and are imperfect 67 
write use cases in an essential ui-free style 68 
actors 70 
use case diagrams 71 
requirements in context and low-level feature lists 73 
use cases are not object-oriented 75 
use cases within the up 75 
case study: use cases in the nextgen inception phase 79 
further readings 79 
up artifacts and process context 81 
7 identifying other requirements 83 
nextgen pos examples 84 
nextgen example: (partial) supplementary specification 84 
commentary: supplementary specification 88 
nextgen example: (partial) vision 91 
commentary: vision 93 
nextgen example: a (partial) glossary 98 
commentary: glossary (data dictionary) 99 
reliable specifications: an oxymoron? 100 
online artifacts at the project website 101 
not much uml during inception? 101 
other requirement artifacts within the up 101 
further readings 104 
up artifacts and process context 105 
8 from inception to elaboration 107 
checkpoint: what happened in inception? 108 
on to elaboration 109 
planning the next iteration 110 
iteration 1 requirements and emphasis: fundamental ooa/i) skills 112 
what artifacts may start in elaboration? 113 
you know you didn't understand elaboration when... 114 
part iii elaboration iteration 1 
9 use-case model: drawing system sequence diagrams 117 
system behavior 118 
system sequence diagrams 118 
example of an ssd 119 
inter-system ssds 120 
ssds and use cases 120 
system events and the system boundary 120 
naming system events and operations 121 
showing use case text 122 
ssds and the glossary 122 
ssds within the up 123 
further readings 124 
up artifacts 125 
10 domain model: visualizing concepts 127 
domain models 128 
conceptual class identification 132 
candidate conceptual classes for the sales domain 136 
domain modeling guidelines 137 
resolving similar conceptual classes--register vs. "post" 139 
modeling the unreal world 140 
specification or description conceptual classes 140 
uml notation, models, and methods: multiple perspectives 144 
lowering the representational gap 146 
example: the nextgen pos domain model 148 
domain models within the up 148 
further readings 150 
up artifacts 151 
11 domain model: adding associations 153 
associations 153 
the uml association notation 154 
finding associations-common associations list 155 
association guidelines 157 
roles 157 
how detailed should associations be? 159 
naming associations 160 
multiple associations between two types 161 
associations and implementation 161 
nextgen pos domain model associations 162 
nextgen pos domain model 163 
12 domain model: adding attributes 167 
attributes 167 
uml attribute notation 168 
valid attribute types 168 
non-primitive data type classes 170 
design creep: no attributes as foreign keys 172 
modeling attribute quantities and unite 173 
attributes in the nextgen domain model 174 
multiplicity from saleslineitem to item 175 
domain model conclusion 175 
13 use-case model: adding detail with operation contracts 177 
contracts 177 
example contract: enteritem 178 
contract sections 179 
postconditions 179 
discussion---enterltem postconditions 182 
writing contracts leads to domain model updates 183 
when are contracts useful? contracts vs. use cases? 183 
guidelines: contracts 184 
nextgen pos example: contracts 185 
changes to the domain model 186 
contracts, operations, and the uml 186 
operation contracts within the up 188 
further readings 191 
14 from requirements to design in this iteration 193 
iteratively do the right thing, do the thing right 193 
didn't that take weeks to do? no, not exactly. 194 
on to object design 194 
15 interaction diagram notation 197 
sequence and collaboration diagrams 198 
example collaboration diagram: makepayment 199 
example sequence diagram: makepayment 200 
interaction diagrams are valuable 200 
common interaction diagram notation 201 
basic collaboration diagram notation 202 
basic sequence diagram notation 208 
16 grasp: designing objects with responsibilities 215 
responsibilities and methods 216 
responsibilities and interaction diagrams 217 
patterns 218 
grasp: patterns of general principles in assigning responsibilities 219 
the uml class diagram notation 220 
information export (or expert) 221 
creator 226 
low coupling 229 
high cohesion 232 
controller 237 
object design and crc cards 245 
further readings 246 
17 design model: use-case realizations with grasp patterns 247 
use-case realizations 248 
artifact comments 249 
use-case realizations for the nextgen iteration 252 
object design: makenewsale 253 
object design: enteritem 255 
object design: endsale 260 
object design: makepayment 264 
object design: startup 269 
connecting the ui layer to the domain layer 273 
use-case realizations within the up 276 
summary 278 
18 design model: determining visibility 279 
visibility between objects 279 
visibility 280 
illustrating visibility in the uml 284 
19 design model: creating design class diagrams 285 
when to create dcds 285 
example dcd 286 
dcd and up terminology 286 
domain model vs. design model classes 287 
creating a nextgen pos dcd 287 
notation for member details 296 
dcds, drawing, and case tools 298 
dcds within the up 298 
up artifacts 299 
20 implementation model: mapping designs to code 301 
programming and the development process 302 
mapping designs to code 304 
creating class definitions from dcds 304 
creating methods from interaction diagrams 307 
container/collection classes in code 309 
exceptions and error handling 309 
defining the sale--makelineltem method 310 
order of implementation 311 
test-first programming 311 
summary of mapping designs to code 313 
introduction to the program solution 313 
part iv elaboration iteration 2 
21 iteration 2 and its requirements 319 
iteration 2 emphasis: object design and patterns 319 
from iteration i to 2 319 
iteration 2 requirements 321 
refinement of analysis-oriented artifacts in this iteration 322 
22 grasp: more patterns for assigning responsibilities 325 
polymorphism 326 
pure fabrication 329 
indirection 332 
protected variations 334 
23 designing use-case realizations with gof design patterns 341 
adapter (gof) 342 
"analysis" discoveries during design: domain model 345 
factory (gof) 346 
singleton (gof) 348 
conclusion of the external services with varying interfaces problem 352 
strategy (gof) 353 
composite (gof) and other design principles 358 
facade (gof) 368 
observer/publish-subscribe/delegation event model (gof) 372 
conclusion 380 
further readings 380 
part v elaboration iteration 3 
24 iteration 3 and its requirements 383 
iteration 3 requirements 383 
iteration 3 emphasis 383 
25 relating use cases 385 
the include relationship 386 
terminology: concrete, abstract, base, and addition use cases 388 
the extend relationship 389 
the generalize relationship 390 
use case diagrams 391 
26 modeling generalization 393 
new concepts for the domain model 393 
generalization 396 
defining conceptual superclasses and subclasses 397 
when to define a conceptual subclass 400 
when to define a conceptual superclass 403 
nextgen pos conceptual class hierarchies 403 
abstract conceptual classes 406 
modeling changing states 408 
class hierarchies and inheritance in software 409 
27 refining the domain model 411 
association classes 411 
aggregation and composition 414 
time intervals and product prices--fixing an iteration 1 "error" 418 
association role names 419 
roles as concepts vs. roles in associations 420 
derived elements 421 
qualified associations 422 
reflexive associations 423 
ordered elements 423 
using packages to organize the domain model 423 
28 adding new ssds and contracts 431 
new system sequence diagrams 431 
new system operations 433 
new system operation contracts 434 
29 modeling behavior in statechart diagrams 437 
events, states, and transitions 437 
statechart diagrams 438 
statechart diagrams in the up?. 439 
use case statechart diagrams 439 
use case statechart diagrams for the pos application 441 
classes that benefit from statechart diagrams 441 
illustrating external and interval events 443 
additional statechart diagram notation 444 
further readings 446 
30 designing the logical architecture with patterns 447 
software architecture 448 
architectural pattern: layers 450 
the model-view separation principle 471 
further readings 474 
31 organizing the design and implementation model packages 475 
package organization guidelines 476 
more uml package notation 482 
further readings 483 
32 introduction to architectural analysis and the sad 485 
architectural analysis 486 
types and views of architecture 488 
the science: identification and analysis of architectural factors 488 
example: partial nextgen pos architectural factor table 491 
the art: resolution of architectural factors 493 
summary of themes in architectural analysis 499 
architectural analysis within the up 500 
further readings 505 
33 designing more use-case realizations with objects and patterns 507 
failover to local services; performance with local caching 507 
handling failure 512 
failover to local services with a proxy (gof) 519 
designing for non-functional or quality requirements 523 
accessing external physical devices with adapters; buy vs. build 523 
abstract factory (gof) for families of related objects 525 
handling payments with polymorphism and do it myself 528 
conclusion 535 
34 designing a persistence framework with patterns 537 
the problem: persistent objects 538 
the solution: a persistence service from a persistence framework 538 
frameworks 539 
requirements for the persistence service and framework 540 
key ideas 540 
pattern: representing objects as tables 541 
uml data modeling profile 541 
pattern: object identifier 542 
accessing a persistence service with a facade 543 
mapping objects: database mapper or database broker pattern 543 
framework design with the template method pattern 546 
materialization with the template method pattern 546 
configuring mappers with a mapperfactory 552 
pattern: cache management 552 
consolidating and hiding sql statements in one class 553 
transactional states and the state pattern 554 
designing a transaction with the command pattern 556 
lazy materialization with a virtual proxy 559 
how to represent relationships in tables 562 
persistentobject superclass and separation of concerns 563 
unresolved issues 564 
part vi special topics 
35 on drawing and tools 567 
on speculative design and visual thinking 567 
suggestions for uml drawing within the development process 568 
tools and sample features 571 
example two 573 
36 introduction to iterative planning and project issues 575 
ranking requirements 576 
ranking project risks 579 
adaptive vs. predictive planning 579 
phase and iteration plans 581 
iteration plan: what to do in the next iteration? 582 
requirements tracking across iterations 583 
the (in)validity of early estimates 585 
organizing project artifacts 585 
some team iteration scheduling issues 586 
you know you didn't understand planning in the up when... 588 
further readings 588 
37 comments on iterative development and the up 589 
additional up best practices and concepts 589 
the construction and transition phases 591 
other interesting practices 592 
motivations for timeboxing an iteration 593 
the sequential "waterfall" lifecycle 593 
usability engineering and user interface design 599 
the up analysis model 599 
the rup product 600 
the challenge and myths of reuse 601 
38 more uml notation 603 
general notation 603 
implementation diagrams 604 
template (parameterized, generic) class 606 
activity diagrams 607 
bibliography 609 
glossary 615 
index 621