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

John Hunt (Autor)

eBook Download: PDF

2006 | 2. Auflage
423 Seiten
Springer London (Verlag)
978-1-85233-856-5 (ISBN)

Infos

The UML, or Unified Modeling Language, is the de facto standard adopted by the Object Management Group (OMG) and by almost all vendors of object modeling tools. The Unified Process is explicitly designed to work with the UML and is a whole design method covering the majority of the life cycle of a software product. John Hunt's book guides you through the use of the UML and the Unified Process and their application to Java systems. Key Topics Focusing explicitly on applying the notation and the method to Java, the book is clearly written to appeal to practitioners. This second edition is considerably revised and extended and includes examples taken from the latest version of Rational Rose and Together. All the UML references are updated to the latest version and the Patterns chapter has been expanded to include J2EE examples. New chapters are included showing how the Unified Process can be used in real world projects and project management, and there is comprehensive coverage of Agile Modeling.

- A truly practical introduction to object oriented analysis and design using the Unified Process. Where necessary the UML is introduced, to support the Unified Process steps.
- Good coverage of Design Patterns and how they integrate into Java development
- Focuses on the real world use of UML and the Unified Process via a detailed case study that follows the whole design process through from the initial setting up, to implementation in Java and Agile Modeling
- Features and Benefits
- How to use the Unified Process in real world projects
- Covers the Unified Process and UML in one book
- A concise and accessible step-by-step guide to applying the Unified Process and UML in Java
- Explains Design Patterns and discusses how Agile Modeling fits with the Unified Process John Hunt is Technical Director at JayDee Technology Ltd. He runs industrial courses, including server-side Java technologies. He also leads development projects for government and blue chip organizations using Java, J2EE, XML and C#. He is the author of nine other books on Java, XML and object orientation.

Written for:
Software developers, software engineers project managers, programmers, final year undergraduates

Keywords:
J2EE
Java
UML
Unified Modeling Language
Unified Process 

---

1.1 Introduction This book introduces and guides the you through the use of the Unified Modeling Language (UML) and the Unified Process (both originally devised by Grady Booch,James Rumbaugh and Ivar Jacobson) and their application to Java systems.This means that the book will present you, thereader,withthenotationusedintheUMLandthestepsdescribedbytheUnifiedProcesswith particular reference to the Java environment (including the classes and the syntax). The book itself is structured in three parts. Part 1 introduces object-oriented analysis and design and the Unified Process. The UML is introduced, as necessary, to support the Unified Process steps.Part 2 discusses the topic of design patterns,while Part 3 looks at the UnifiedProcessandUMLintherealworld. The first part of the book is structured in the following manner: Chapter 2: Object -Oriented Analysis and Design This chapter surveys the most significant object-oriented design and analysis methods to emerge since the late 1980s. Chapter 3: An Introduction to the UML and the Unified Process This chapter provides the background to the UML and the Unified Process. It also presents a summary of both. Chapter 4: Software Architecture and Object-Oriented Design This chapter explains and justifies why an architecture is essential to the successful design and implementation of a large object-oriented system. Chapter 5: Requirements Discipline: Use Case Analysis Thischapterintroducestherequirementsdiscipline(whichmayalsobeknownasUseCaseAna- sis).Thisdisciplineattemptstoidentifywhatthefunctionalityofthesystemwillbe.Theseusecases will be essential as the backbone to the whole design process.

Inhalt

Contents 7
Part 1 The Unified Process 19
1 Introduction 20
1.1 Introduction 20
1.2 Why UML and the Unified Process? 22
1.3 Why This Book? 23
1.4 Where to Get More Information 23
1.5 Where to Go Online 24
2 Object-Oriented Analysis and Design 25
2.1 Introduction 25
2.2 Object-Oriented Design Methods 25
2.3 Object-Oriented Analysis 26
2.4 The Booch Method 28
2.5 The Object Modeling Technique 29
2.6 The Objectory Method 31
2.7 The Fusion Method 32
2.8 The Unified Modeling Language 33
2.9 Summary 34
2.10 References 34
3 An Introduction to the UML and the Unified Process 36
3.1 Introduction 36
3.2 Unified Modeling Language 36
3.3 Analysis of the UML 41
3.4 The Unified Process 41
3.5 The Rational Unified Process 51
3.6 Summary 52
3.7 References 52
3.8 Online References 52
4 Software Architecture and Object-Oriented Design 53
4.1 Software Architecture – the Very Idea 53
4.2 Software Patterns 63
4.3 Constructing the Architecture 64
4.4 Find Architecturally Significant Use Cases 65
4.5 Identify Key Classes 65
4.6 Breaking the System into Subsystems 66
4.7 Identifying Concurrency and Active Classes 69
4.8 Managing Data Stores 72
4.9 Additional Architectural Concerns 73
4.10 Plan Incremental Build of Software 75
4.11 The Online ATM Architecture Design 75
4.12 References 79
5 Requirements Discipline:Use Case Analysis 81
5.1 Introduction 81
5.2 Requirements Discipline 81
5.3 Use Case Analysis 82
5.4 The Use Case Model 82
5.5 Use Case Diagrams 83
5.6 Actors 84
5.7 Use Cases 86
5.8 Refining Use Case Models 89
5.9 Additional Documents 90
5.10 Interface Descriptions 90
5.11 Online ATM Use Case Analysis 90
5.12 Structuring the Use Case Model 95
5.13 Are Use Case Diagrams Useful? 96
5.14 Further Reading 99
5.15 References 99
6 The Analysis Discipline: Finding the Entities 100
6.1 Introduction 100
6.2 Analysis Discipline Activities 102
6.3 The Analysis Model 102
6.4 Generating Analysis Classes 107
6.5 Generating Use Case Realizations 113
6.6 Identifying Attributes 113
6.7 Preparing a Data Dictionary 116
6.8 Identifying Associations 116
6.9 Identifying Inheritance 119
6.10 Grouping Analysis Classes into Packages 122
6.11 Iterating and Refining the Model 125
6.12 Identify Common Special Requirements 126
7 The Design Discipline: System and Class Design 127
7.1 Introduction 127
7.2 Design Discipline Activities 127
7.3 Class Design Stage 129
7.4 The Design Model 129
7.5 Design Classes 131
7.6 Identifying and Refining Design Classes 135
7.7 Identifying Operations for the Online ATM System 141
7.8 Analyzing Use Cases 143
7.9 Identifying Dynamic Behaviour 144
7.10 Statechart Diagrams 151
7.11 Associations 158
7.12 Identifying Interfaces 162
7.13 Identifying Inheritance 163
7.14 Remaining Steps 163
7.15 Applying the Remaining Steps to OBA 165
7.16 Iterating and Refining the Model 165
7.17 References 166
8 Implementation Phase 167
8.1 Introduction 167
8.2 Implementation Discipline Artefacts 167
8.3 Implementation Discipline Activities 168
9 The Test Discipline: How It Relates to Use Cases 174
9.1 Introduction 174
9.2 The Purpose of the Discipline 174
9.3 Aims of Discipline 174
9.4 Test Discipline Activities 175
9.5 Summary 177
9.6 Reference 177
10 The Four Phases 178
10.1 Introduction 178
10.2 The Unified Process Structure 178
10.3 Relationship Between Phases and Iterations 179
10.4 Effort Versus Phases 182
10.5 Phases and Iterations 183
10.6 Phases and Cycles 184
11 The JDSync Case Study 185
11.1 Introduction 185
11.2 Problem Statement 185
11.3 The Requirements Discipline: Use Case Analysis 185
11.4 The Analysis Discipline 191
11.5 The Design Discipline 198
11.6 The ImplementationWorkflow 211
11.7 Summary 216
Part 2 Design Patterns 217
12 Software Patterns 218
12.1 Introduction 218
12.2 The Motivation Behind Patterns 219
12.3 Documenting Patterns 220
12.4 When to Use Patterns 221
12.5 Strengths and Limitations of Design Patterns 221
12.6 An Example Pattern: Mediator 222
12.7 Summary 227
12.8 Further Reading 227
12.9 References 227
13 Patterns Catalogs 229
13.1 Introduction 229
13.2 GoF Patterns 229
13.3 Creational Patterns 230
13.4 Structural Patterns 233
13.5 Behavioural Patterns 236
13.6 Summary 240
13.7 References 241
14 Applying the Model–View–Controller Pattern 242
14.1 Introduction 242
14.2 What Is the Model–View–Controller Architecture? 242
14.3 What Java Facilities Support the MVC 243
14.4 The MVC in Java 245
14.5 A Simple Calculator Application 247
14.6 Discussion 250
14.7 References 251
14.8 Listings 251
15 The Hierarchical MVC 260
15.1 Introduction 260
15.2 Why Isn’t This Enough? 260
15.3 The h-MVC 261
15.4 The h-MVC Details 261
15.5 Layered Application 261
15.6 Initialization 264
15.7 Hierarchical Behaviour 266
15.8 The Advantages of the h-MVC 267
15.9 The Disadvantages of the h-MVC 267
15.10 Summary 268
16 The Visitor Framework 269
16.1 Background 269
16.2 The Visitor Pattern 270
16.3 The Visitor Framework 272
16.4 Using the Visitor Framework 272
16.5 A Simple Application 275
16.6 Summary 277
16.7 References 277
16.8 Listings 278
17 The EventManager 286
17.1 Introduction 286
17.2 The Use of Patterns 286
17.3 The Mediator Pattern 288
17.4 The Singleton Pattern 288
17.5 The Design of the EventManager 288
17.6 Using the EventManager 291
17.7 The EventManager in a Graphical Client 291
17.8 Reference 291
17.9 Listings 291
18 J2EE Patterns 297
18.1 Introduction 297
18.2 What Are J2EE Design Patterns? 297
18.3 A Catalog of J2EE Patterns 298
18.4 The FrontController Pattern 299
18.5 The Request–Event–Dispatcher Pattern 302
18.6 J2EE-based Model–View–Controller 307
18.7 Summary 311
18.8 Further Reading 311
18.9 References 311
19 The Fault Tracker J2EE Case Study 313
19.1 Introduction 313
19.2 The Fault Tracker Application 313
19.3 Using the Fault Tracker 317
19.4 The Design of the Fault Tracker 321
19.5 Summary and Conclusions 328
Part 3 The Unified Process in the RealWorld 330
20 Are UML Designs Language-Independent? 331
20.1 Introduction 331
20.2 OOD Is Language-Independent – Right? 331
20.3 Making UMLWork for You 332
20.4 Questions to Consider 333
20.5 The Java Platform 333
20.6 Classes in the UML 334
20.7 Fields in the UML 334
20.8 Operations in the UML 335
20.9 Constructors 335
20.10 Packages in the UML 336
20.11 UML Interfaces 338
20.12 Templates 338
20.13 Associations 339
20.14 Multiplicity in the UML 341
20.15 Aggregation and Composition 341
20.16 Singleton Objects 342
20.17 Synchronous and Asynchronous Messages 342
20.18 From Code to the UML 343
20.19 Conclusions 344
21 Customizing the Unified Process for Short Time-Scale Projects 345
21.1 Introduction 345
21.2 Particular Problems of Small Projects 346
21.3 The Unified Process as a Framework 347
21.4 Adapting the Unified Process for a Small Project 353
21.5 The Modified Unified Process 354
21.6 Summary 356
21.7 Reference 356
22 Augmenting the Unified Process with Additional Techniques 357
22.1 Introduction 357
22.2 The Unified Process as a Framework 357
22.3 Class Identification 359
22.4 CRC: Class–Responsibility–Collaboration 360
22.5 What Is CRC? 361
22.6 Summary 363
22.7 References 363
23 Inheritance Considered Harmful! 364
23.1 Introduction 364
23.2 Inheritance 365
23.3 Drawbacks of Inheritance 367
23.4 Balancing Inheritance and Reuse 375
23.5 Compositional Reuse 377
23.6 Promoting Reuse in Object-Oriented Systems 378
23.7 Tool Support 380
23.8 Conclusions 381
23.9 References 381
24 Incremental Software 383
24.1 The Incremental Software Development Process 383
24.2 Incremental Software Development 384
24.3 Feature-Centric Development 386
24.4 Timeboxing Iterations 387
24.5 Being Adaptive but Managed 387
24.6 Architecture-Centric 390
24.7 Performance Measurements and Reporting 392
24.8 References 394
25 Agile Modeling 395
25.1 Introduction 395
25.2 ModellingMisconceptions 396
25.3 TheManifesto for Agile Modeling 399
25.4 Agile Modeling 401
25.5 Agile Modeling and the Unified Process 406
25.6 Agile Modelling and Documentation 408
25.7 ToolMisconceptions 409
25.8 Summary 410
25.9 References 410
25.10 Online References 410
Appendix A UML Notation 411
A.1 The UML Notation 411
A.2 Use Case Diagrams 412
A.3 Collaboration Diagrams 412
A.4 Class Diagrams 412
A.5 Activity Diagrams 415
A.6 Sequence Diagrams 416
A.7 Statechart Diagrams 416
A.8 Component and Deployment Diagrams 417
A.9 Reference 417
Index 418
More eBooks at www.ciando.com 0

Produkt-Details

• Erscheint lt. Verlag: 18.4.2006
• Sprache: englisch
• Themenwelt: Informatik ► Programmiersprachen / -werkzeuge ► Java
• Themenwelt: Informatik ► Software Entwicklung ► Objektorientierung
• Themenwelt: Informatik ► Theorie / Studium ► Compilerbau
• Themenwelt: Mathematik / Informatik ► Informatik ► Web / Internet
• ISBN-10: 1-85233-856-3 / 1852338563
• ISBN-13: 978-1-85233-856-5 / 9781852338565