Applying UML and Patterns An Introduction to Object-Oriented Analysis and Design and the Unified ProPDF|Epub|txt|kindle电子书版本网盘下载

Applying UML and Patterns An Introduction to Object-Oriented Analysis and Design and the Unified ProPDF格式电子书版下载

注意：本站所有压缩包均有解压码： 点击下载压缩包解压工具

PART Ⅰ INTRODUCTION3

1 Object-Oriented Analysis and Design3

Applying UML and Patterns in OOA/D3

Assigning Responsibilities6

What Is Analysis and Design?6

What Is Object-Oriented Analysis and Design?7

An Example7

The UML10

Further Readings11

2 Iterative Development and the Unified Process13

The Most Important UP Idea: Iterative Development14

Additional UP Best Practices and Concepts18

The UP Phases and Schedule-Oriented Terms19

The UP Disciplines （was Workflows）20

Process Customization and the Development Case23

The Agile UP24

The Sequential “Waterfall” Lifecycle25

You Know You Didn’t Understand the UP When26

Further Readings26

3 Case Study: The NextGen POS System29

The NextGen POS System29

Architectural Layers and Case Study Emphasis30

The Book’s Strategy: Iterative Learning and Development31

PART Ⅱ INCEPTION36

4 Inception36

Inception: An Analogy36

Inception May Be Very Brief36

What Artifacts May Start in Inception?37

You Know You Didn’t Understand Inception When38

5 Understanding Requirements41

Types of Requirements42

Further Readings43

6 Use-Case Model: Writing Requirements in Context45

Goals and Stories46

Background46

Use Cases and Adding Value47

Use Cases and Functional Requirements48

Use Case Types and Formats49

Fully Dressed Example: Process Sale50

Explaining the Sections54

Goals and Scope of a Use Case59

Finding Primaimry Actors，Goals，and Use Cases63

Congratulations: Use Cases Have Been Written，and Are Imperfect67

Write Use Cases in an Essential UI-Free Style68

Actors70

Use Case Diagrams71

Requirements in Context and Low-Level Feature Lists73

Use Cases Are Not Object-Oriented75

Use Cases Within the UP75

Case Study: Use Cases in the NextGen Inception Phase79

Further Readings79

UP Artifacts and Process Context81

7 Identifying Other Requirements83

NextGen POS Examples84

NextGen Example: （Partial） Supplementary Specification84

Commentaty: Supplementary Specification88

NextGen Example: （Partial） Vision91

Commentary: Vision93

NextGen Example: A （Partial） Glossary98

Commentary: Glossary （Data Dictionary）99

Reliable Specifications: An Oxymoron?100

Online Artifacts at the Project Website101

Not Much UML During Inception?101

Other Requirement Artifacts Within the UP101

Further Readings104

UP Artifacts and Process Context105

8 From Inception to Elaboration107

Checkpoint: What Happened in Inception?108

On to Elaboration109

Planning the Next Iteration110

Iteration 1 Requirements and Emphasis: Fundamental OOA/D Skills112

What Artifacts May Start in Elaboration?113

You Know You Didn’t Understand Elaboration When114

PART Ⅲ ELABORATION ITERATION 1117

9 Use-Case Model: Drawing System Sequence Diagrams117

System Behavior118

System Sequence Diagrams118

Example of an SSD119

Inter-System SSDs120

SSDs and Use Cases120

System Events and the System Boundary120

Naming System Events and Operations121

Showing Use Case Text122

SSDs and the Glossary122

SSDs Within the UP123

Further Readings124

UP Artifacts125

10 Domain Model: Visualizing Concepts127

Domain Models128

Conceptual Class Identification132

Candidate Conceptual Classes for the Sales Domain136

Domain Modeling Guidelines137

Resolving Similar Conceptual Classes—Register vs. “POST”139

Modeling the Unreal World140

Specification or Description Conceptual Classes140

UML Notation，Models，and Methods: Multiple Perspectives144

Lowering the Representational Gap146

Example: The NextGen POS Domain Model148

Domain Models Within the UP148

Further Readings150

UP Artifacts151

11 Domain Model: Adding Associations153

Associations153

The UML Association Notation154

Finding Associations—Common Associations List155

Association Guidelines157

Roles157

How Detailed Should Associations Be?159

Naming Associations160

Multiple Associations Between Two Types161

Associations and Implementation161

NextGen POS Domain Model Associations162

NextGen POS Domain Model163

12 Domain Model: Adding Attributes167

Attributes167

UML Attribute Notation168

Valid Attribute Types168

Non-primitive Data Type Classes170

Design Creep: No Attributes as Foreign Keys172

Modeling Attribute Quantities and Units173

Attributes in the NextGen Domain Model174

Multiplicity From SalesLineItem to Item175

Domain Model Conclusion175

13 Use-Case Model: Adding Detail with Operation Contracts177

Contracts177

Example Contract: enterItem178

Contract Sections179

Postconditions179

Discussion—enterltem Postconditions182

Writing Contracts Leads to Domain Model Updates183

When Are Contracts Useful? Contracts vs. Use Cases?183

Guidelines: Contracts184

NextGen POS Example: Contracts185

Changes to the Domain Model186

Contracts，Operations，and the UML186

Operation Contracts Within the UP188

Further Readings191

14 From Requirements to Design in this Iteration193

Iteratively Do the Right Thing，Do the Thing Right193

Didn’t That Take Weeks To Do? No，Not Exactly194

On to Object Design194

15 Interaction Diagram Notation197

Sequence and Collaboration Diagrams198

Example Collaboration Diagram: makePayment199

Example Sequence Diagram: makePayment200

Interaction Diagrams Are Valuable200

Common Interaction Diagram Notation201

Basic Collaboration Diagram Notation202

Basic Sequence Diagram Notation208

16 GRASP: Designing Objects with Responsibilities215

Responsibilities and Methods216

Responsibilities and Interaction Diagrams217

Patterns218

GRASP: Patterns of General Principles in Assigning Responsibilities219

The UML Class Diagram Notation220

Information Expert （or Expert）221

Creator226

Low Coupling229

High Cohesion232

Controller237

Object Design and CRC Cards245

Further Readings246

17 Design Model: Use-Case Realizations with GRASP Patterns247

Use-Case Realizations248

Artifact Comments249

Use-Case Realizations for the NextGen Iteration252

Object Design: makeNewSale253

Object Design: enterItem255

Object Design: endSale260

Object Design: makePayment264

Object Design: startUp269

Connecting the UI Layer to the Domain Layer273

Use-Case Realizations Within the UP276

Summary278

18 Design Model: Determining Visibility279

Visibility Between Objects279

Visibility280

Illustrating Visibility in the UML284

19 Design Model: Creating Design Class Diagrams285

When to Create DCDs285

Example DCD286

DCD and UP Terminology286

Domain Model vs. Design Model Classes287

Creating a NextGen POS DCD287

Notation for Member Details296

DCDs，Drawing，and CASE Tools298

DCDs Within the UP298

UP Artifacts299

20 Implementation Model: Mapping Designs to Code301

Programming and the Development Process302

Mapping Designs to Code304

Creating Class Definitions from DCDs304

Creating Methods from Interaction Diagrams307

Container/Collection Classes in Code309

Exceptions and Error Handling309

Defining the Sale--makeLineItem Method310

Order of Implementation311

Test-First Programming311

Summary of Mapping Designs to Code313

Introduction to the Program Solution313

PART Ⅳ ELABORATION ITERATION 2319

21 Iteration 2 and its Requirements319

Iteration 2 Emphasis: Object Design and Patterns319

From Iteration 1 to 2319

Iteration 2 Requirements321

Refinement of Analysis-oriented Artifacts in this Iteration322

22 GRASP: More Patterns for Assigning Responsibilities325

Polymorphism326

Pure Fabrication329

Indirection332

Protected Variations334

23 Designing Use-Case Realizations with GoF Design Patterns341

Adapter （GoF）342

Analysis” Discoveries During Design: Domain Model345

Factory （GoF）346

Singleton （GoF）348

Conclusion of the External Services with Varying Interfaces Problem352

Strategy （GoF）353

Composite （GoF） and Other Design Principles358

Facade （GoF）368

Observer/Publish-Subscribe/Delegation Event Model （GoF）372

Conclusion380

Further Readings380

PART Ⅴ ELABORATION ITERATION 3383

24 Iteration 3 and Its Requirements383

Iteration 3 Requirements383

Iteration 3 Emphasis383

25 Relating Use Cases385

The include Relationship386

Terminology: Concrete，Abstract，Base，and Addition Use Cases388

The extend Relationship389

The generalize Relationship390

Use Case Diagrams391

26 Modeling Generalization393

New Concepts for the Domain Model393

Generalization396

Defing Conceptual Superclasses and Subclasses397

When to Define a Conceptual Subclass400

When to Define a Conceptual Superclass403

NextGen POS Conceptual Class Hierarchies403

Abstract Conceptual Classes406

Modeling Changing States408

Class Hierarchies and Inheritance in Software409

27 Refining the Domain Model411

Association Classes411

Aggregation and Composition414

Time Intervals and Product Prices—Fixing an Iteration 1 “Error”418

Association Role Names419

Roles as Concepts vs. Roles in Associations420

Derived Elements421

Qualified Associations422

Reflexive Associations423

Ordered Elements423

Using Packages to Organize the Domain Model423

28 Adding New SSDs and Contracts431

New System Sequence Diagrams431

New System Operations433

New System Operation Contracts434

29 Modeling Behavior in Statechart Diagrams437

Events，States，and Transitions437

Statechart Diagrams438

Statechart Diagrams in the UP?439

Use Case Statechart Diagrams439

Use Case Statechart Diagrams for the POS Application441

Classes that Benefot from Statechart Diagrams441

Illustrating External and Interval Events443

Additional Statechart Diagram Notation444

Further Readings446

30 Designing the Logical Architecture with Patterns447

Software Architecture448

Architectural Pattern: Layers450

The Model-View Separation Principle471

Further Readings474

31 Organizing the Design and Implementation Model Packages475

Package Organization Guidelines476

More UML Package Notation482

Further Readings483

32 Introduction to Architectural Analysis and the SAD485

Architectural Analysis486

Types and Views of Architecture488

The Science: Identification and Analysis of Architectural Factors488

Example: Partial NextGen POS Architectural Factor Table491

The Art: Resolution of Architectural Factors493

Summary of Themes in Architectural Analysis499

Architectural Analysis within the UP500

Further Readings505

33 Designing More Use-Case Realizations with Objects and Patterns507

Failover to Local Services; Performance with Local Caching507

Handling Failure512

Failover to Local Services with a Proxy （GoF）519

Designing for Non-Functional or Quality Requirements523

Accessing External Physical Devices with Adapters; Buy vs. Build523

Abstract Factory （GoF） for Families of Related Objects525

Handling Payments with Polymorphism and Do It Myself528

Conclusion535

34 Designing a Persistence Framework with Patterns537

The Problem: Persistent Objects538

The Solution: A Persistence Service from a Persistence Framework538

Frameworks539

Requirements for the Persistence Service and Framework540

Key Ideas540

Pattern: Representing Objects as Tables541

UML Data Modeling Profile541

Pattern: Object Identifier542

Accessing a Persistence Service with a Facade543

Mapping Objects: Database Mapper or Database Broker Pattern543

Framework Design with the Template Method Pattern546

Materialization with the Template Method Pattern546

Configuring Mappers with a MapperFactory552

Pattern: Cache Management552

Consolidating and Hiding SQL Statements in One Class553

Transactional States and the State Pattern554

Designing a Transaction with the Command Pattern556

Lazy Materialization with a Virtual Proxy559

How to Represent Relationships in Tables562

PeraistentObject Superclass and Separation of Concerns563

Unresolved Issues564

PART Ⅵ SPECIAL TOPICS567

35 On Drawing and Tools567

On Speculative Design and Visual Thinking567

Suggestions for UML Drawing Within the Development Process568

Tools and Sample Features571

Example Two573

36 Introduction to Iterative Planning and Project Issues575

Ranking Requirements576

Ranking Project Risks579

Adaptive vs. Predictive Planning579

Phase and Iteration Plans581

Iteration Plan: What to Do in the Next Iteration?582

Requirements Tracking Across Iterations583

The （In）Validity of Early Estimates585

Organizing Project Artifacts585

Some Team Iteration Scheduling Issues586

You Know You Didn’t Understand Planning in the UP When588

Further Readings588

37 Comments on Iterative Development and the UP589

Additional UP Best Practices and Concepts589

The Construction and Transition Phases591

Other Interesting Practices592

Motivations for Timeboxing an Iteration593

The Sequential “Waterfall” Lifecycle593

Usability Engineering and User Interface Design599

The UP Analysis Model599

The RUP Product600

The Challenge and Myths of Reuse601

38 More UML Notation603

General Notation603

Implementation Diagrams604

Template （Parameterized，Generic） Class606

Activity Diagrams607

Bibliography609

Glossary615

Index621