Guide to the Unified Process featuring UML, Java and Design Patterns

Contents

Part 1 The Unified Process

1 Introduction

1.1 Introduction

1.2 Why UML and the Unified Process?

1.3 Why This Book?

1.4 Where to Get More Information

1.5 Where to Go Online

2 Object-Oriented Analysis and Design

2.1 Introduction

2.2 Object-Oriented Design Methods

2.3 Object-Oriented Analysis

2.4 The Booch Method

2.5 The Object Modeling Technique

2.6 The Objectory Method

2.7 The Fusion Method

2.8 The Unified Modeling Language

2.9 Summary

2.10 References

3 An Introduction to the UML and the Unified Process

3.1 Introduction

3.2 Unified Modeling Language

3.3 Analysis of the UML

3.4 The Unified Process

3.5 The Rational Unified Process

3.6 Summary

3.7 References

3.8 Online References

4 Software Architecture and Object-Oriented Design

4.1 Software Architecture – the Very Idea

4.2 Software Patterns

4.3 Constructing the Architecture

4.4 Find Architecturally Significant Use Cases

4.5 Identify Key Classes

4.6 Breaking the System into Subsystems

4.7 Identifying Concurrency and Active Classes

4.8 Managing Data Stores

4.9 Additional Architectural Concerns

4.10 Plan Incremental Build of Software

4.11 The Online ATM Architecture Design

4.12 References

5 Requirements Discipline:Use Case Analysis

5.1 Introduction

5.2 Requirements Discipline

5.3 Use Case Analysis

5.4 The Use Case Model

5.5 Use Case Diagrams

5.6 Actors

5.7 Use Cases

5.8 Refining Use Case Models

5.9 Additional Documents

5.10 Interface Descriptions

5.11 Online ATM Use Case Analysis

5.12 Structuring the Use Case Model

5.13 Are Use Case Diagrams Useful?

5.14 Further Reading

5.15 References

6 The Analysis Discipline: Finding the Entities

6.1 Introduction

6.2 Analysis Discipline Activities

6.3 The Analysis Model

6.4 Generating Analysis Classes

6.5 Generating Use Case Realizations

6.6 Identifying Attributes

6.7 Preparing a Data Dictionary

6.8 Identifying Associations

6.9 Identifying Inheritance

6.10 Grouping Analysis Classes into Packages

6.11 Iterating and Refining the Model

6.12 Identify Common Special Requirements

7 The Design Discipline: System and Class Design

7.1 Introduction

7.2 Design Discipline Activities

7.3 Class Design Stage

7.4 The Design Model

7.5 Design Classes

7.6 Identifying and Refining Design Classes

7.7 Identifying Operations for the Online ATM System

7.8 Analyzing Use Cases

7.9 Identifying Dynamic Behaviour

7.10 Statechart Diagrams

7.11 Associations

7.12 Identifying Interfaces

7.13 Identifying Inheritance

7.14 Remaining Steps

7.15 Applying the Remaining Steps to OBA

7.16 Iterating and Refining the Model

7.17 References

8 Implementation Phase

8.1 Introduction

8.2 Implementation Discipline Artefacts

8.3 Implementation Discipline Activities

9 The Test Discipline: How It Relates to Use Cases

9.1 Introduction

9.2 The Purpose of the Discipline

9.3 Aims of Discipline

9.4 Test Discipline Activities

9.5 Summary

9.6 Reference

10 The Four Phases

10.1 Introduction

10.2 The Unified Process Structure

10.3 Relationship Between Phases and Iterations

10.4 Effort Versus Phases

10.5 Phases and Iterations

10.6 Phases and Cycles

11 The JDSync Case Study

11.1 Introduction

11.2 Problem Statement

11.3 The Requirements Discipline: Use Case Analysis

11.4 The Analysis Discipline

11.5 The Design Discipline

11.6 The ImplementationWorkflow

11.7 Summary

Part 2 Design Patterns

12 Software Patterns

12.1 Introduction

12.2 The Motivation Behind Patterns

12.3 Documenting Patterns

12.4 When to Use Patterns

12.5 Strengths and Limitations of Design Patterns

12.6 An Example Pattern: Mediator

12.7 Summary

12.8 Further Reading

12.9 References

13 Patterns Catalogs

13.1 Introduction

13.2 GoF Patterns

13.3 Creational Patterns

13.4 Structural Patterns

13.5 Behavioural Patterns

13.6 Summary

13.7 References

14 Applying the Model–View–Controller Pattern

14.1 Introduction

14.2 What Is the Model–View–Controller Architecture?

14.3 What Java Facilities Support the MVC

14.4 The MVC in Java

14.5 A Simple Calculator Application

14.6 Discussion

14.7 References

14.8 Listings

15 The Hierarchical MVC

15.1 Introduction

15.2 Why Isn’t This Enough?

15.3 The h-MVC

15.4 The h-MVC Details

15.5 Layered Application

15.6 Initialization

15.7 Hierarchical Behaviour

15.8 The Advantages of the h-MVC

15.9 The Disadvantages of the h-MVC

15.10 Summary

16 The Visitor Framework

16.1 Background

16.2 The Visitor Pattern

16.3 The Visitor Framework

16.4 Using the Visitor Framework

16.5 A Simple Application

16.6 Summary

16.7 References

16.8 Listings

17 The EventManager

17.1 Introduction

17.2 The Use of Patterns

17.3 The Mediator Pattern

17.4 The Singleton Pattern

17.5 The Design of the EventManager

17.6 Using the EventManager

17.7 The EventManager in a Graphical Client

17.8 Reference

17.9 Listings

18 J2EE Patterns

18.1 Introduction

18.2 What Are J2EE Design Patterns?

18.3 A Catalog of J2EE Patterns

18.4 The FrontController Pattern

18.5 The Request–Event–Dispatcher Pattern

18.6 J2EE-based Model–View–Controller

18.7 Summary

18.8 Further Reading

18.9 References

19 The Fault Tracker J2EE Case Study

19.1 Introduction

19.2 The Fault Tracker Application

19.3 Using the Fault Tracker

19.4 The Design of the Fault Tracker

19.5 Summary and Conclusions

Part 3 The Unified Process in the RealWorld

20 Are UML Designs Language-Independent?

20.1 Introduction

20.2 OOD Is Language-Independent – Right?

20.3 Making UMLWork for You

20.4 Questions to Consider

20.5 The Java Platform

20.6 Classes in the UML

20.7 Fields in the UML

20.8 Operations in the UML

20.9 Constructors

20.10 Packages in the UML

20.11 UML Interfaces

20.12 Templates

20.13 Associations

20.14 Multiplicity in the UML

20.15 Aggregation and Composition

20.16 Singleton Objects

20.17 Synchronous and Asynchronous Messages

20.18 From Code to the UML

20.19 Conclusions

21 Customizing the Unified Process for Short Time-Scale Projects

21.1 Introduction

21.2 Particular Problems of Small Projects

21.3 The Unified Process as a Framework

21.4 Adapting the Unified Process for a Small Project

21.5 The Modified Unified Process

21.6 Summary

21.7 Reference

22 Augmenting the Unified Process with Additional Techniques

22.1 Introduction

22.2 The Unified Process as a Framework

22.3 Class Identification

22.4 CRC: Class–Responsibility–Collaboration

22.5 What Is CRC?

22.6 Summary

22.7 References

23 Inheritance Considered Harmful!

23.1 Introduction

23.2 Inheritance

23.3 Drawbacks of Inheritance

23.4 Balancing Inheritance and Reuse

23.5 Compositional Reuse

23.6 Promoting Reuse in Object-Oriented Systems

23.7 Tool Support

23.8 Conclusions

23.9 References

24 Incremental Software

24.1 The Incremental Software Development Process

24.2 Incremental Software Development

24.3 Feature-Centric Development

24.4 Timeboxing Iterations

24.5 Being Adaptive but Managed

24.6 Architecture-Centric

24.7 Performance Measurements and Reporting

24.8 References

25 Agile Modeling

25.1 Introduction

25.2 ModellingMisconceptions

25.3 TheManifesto for Agile Modeling

25.4 Agile Modeling

25.5 Agile Modeling and the Unified Process

25.6 Agile Modelling and Documentation

25.7 ToolMisconceptions

25.8 Summary

25.9 References

25.10 Online References

Appendix A UML Notation

A.1 The UML Notation

A.2 Use Case Diagrams

A.3 Collaboration Diagrams

A.4 Class Diagrams

A.5 Activity Diagrams

A.6 Sequence Diagrams

A.7 Statechart Diagrams

A.8 Component and Deployment Diagrams

A.9 Reference

Index

More eBooks at www.ciando.com