Aspect-oriented programming （AOP） is a revolutionary new way to think about software engineering.AOP was introduced to address crosscutting concerns such as security， logging， persistence， debugging， tracing， distribution， performance monitoring， and exception handling in a more effective manner. Unlike conventional development techniques， which scatter the implementation of each concern into multiple classes， aspect-oriented programming localizes them..Aspect-oriented software development （AOSD） uses this approach to create a better modularity for functional and nonfunctional requirements， platform specifics， and more， allowing you to build more understandable systems that are easier to configure and extend to meet the evolving needs of stakeholders.In this highly anticipated new book， Ivar Jacobson and Pan-Wei Ng demonstrate how to apply use cases：a mature and systematic approach to focusing on stakeholder concerns：and aspect-orientation in building robust and extensible systems. Throughout the book， the authors employ a single， real-world example of a hotel management information system to make the described theories and practices concrete and understandable.The authors show how to identify， design， implement， test， and refactor use-case modules， as well as extend them. They also demonstrate how to design use-case modules with the Unified Modeling Language （UML）：emphasizing enhancements made in UML 2.0：and how to achieve use-case modularity using aspect technologies， notably AspectJ...Key topics include·Making the case for use cases and aspects·Capturing and modeling concerns with use cases·Keeping concerns separate with use-case modules·Modeling use-cases slices and aspects using the newest extensions to the UML notation·Applying use cases and aspects in projects...Whatever your level of experience with aspect-oriented programming， Aspect-Oriented Software Development with Use Cases will teach you how to develop better software by embracing the paradigm shift to AOSD.
Preface vii Acknowledgments xxi PART I The Case for Use Cases and Aspects 1 Chapter 1 Problem to Attack 3 1.1 The Use of Components Today 3 1.1.1 Building a System with Components 4 1.1.2 Benefits of Components 6 1.2 Limitation of Components 6 1.2.1 Inability to Keep Peers Separate 8 1.2.2 Inability to Keep Extensions Separate 9 1.3 Approaching a Solution 11 1.3.1 Early Support for Extensions 12 1.3.2 Support for Extensions in UML 15 1.4 Keeping Concerns Separate 16 Chapter 2 Attacking the Problem with Aspects 17 2.1 Approaching a Solution with Aspects 17 2.2 Keeping Peers Separate with Aspects 19 2.3 Keeping Extensions Separate with Aspects 21 2.4 Need for Methodological Guidance 26 Chapter 3 Today with Use Cases 29 3.1. Use Cases in Brief 29 3.2 Use-Case-Driven Development 32 3.3 Roles and Benefits of Use Cases 34 3.4 Gaps in the Use-Case Technique 34 3.5 Bridging the Gaps with Aspects 35 Chapter 4 Tomorrow with Use-Case Modules 37 4.1 Building Systems in Overlays with Use-Case Slices 38 4.2 Keeping Peer Use Cases Separate 40 4.3 Keeping Extension Use Cases Separate 42 4.4 Developing with Use-Case Modules 45 PART II Modeling and Capturing Concerns with Use Cases 49 Chapter 5 Modeling Concerns with Use Cases 51 5.1 Use-Case Modeling 51 5.2 Use-Case Instances and Flows of Events 53 5.3 Describing Use Cases 54 5.4 Visualizing Use-Case Flows 57 5.5 Summary and Highlights 60 Chapter 6 Structuring Use Cases 61 6.1 Use-Case Relationships 61 6.2 Use-Case Extend Relationship 63 6.3 Use-Case Include Relationship 70 6.4 Use-Case Generalization 73 6.5 Utility Use Cases 77 6.6 Summary and Highlights 79 Chapter 7 Capturing Concerns with Use Cases 81 7.1 Understanding Stakeholder Concerns 81 7.1.1 Understanding the Problem Domain 82 7.1.2 Eliciting System Features 83 7.1.3 Dealing with Functional and Nonfunctional Requirements 84 7.2 Capturing Application Use Cases 86 7.2.1 Identifying Use-Case Variability 87 7.2.2 Handling Use.Case Variability 88 7.2.3 Dealing with Extension Use Cases 91 7.3 Capturing Infrastructure Use Cases 93 7.3.1 The Perform Transaction Use Case 94 7.3.2 Structuring Infrastructure Use Cases 96 7.3.3 Describing Infrastructure Use Cases 98 7.3.4 Dealing with Systemwide Concerns 100 7.4 Summary and Highlights 101 PART III Keeping Concerns Separate with Use-Case Modules 103 Chapter 8 Keeping Peer Use-Case Realizations Separate with Aspects 105 8.1 Realizing Peer Use Cases 106 8.1.1 Collaborations 106 8.1.2 Realizing a Use Case 108 8.1.3 Overlap between Peer Use-Case Realizations 110 8.2 Keeping Use-Case Specifics Separate 111 8.2.1 Composing Use-Case-Specific Classes 113 8.2.2 Composing Use-Case-Specific Class Extensions 115 8.2.3 Collaborations in Use-Case Slices 117 8.3 Dealing with Overlap 118 8.3.1 Included Use.Case Slice 119 8.3.2 Generalized Use-Case Slice 121 8.3.3 Non-Use-Case-Specific Slice 123 8.4 Summary and Highlights 125 Chapter 9 Keeping Extensions Separate with Pointcuts 127 9.1 Realizing Extension Use Cases 128 9.2 Keeping Modularity of Extension Use-Case Realizations 129 9.2.1 Operation Extensions 130 9.2.2 Pointcuts 133 9.3 Parameterizing Pointcuts 135 9.3.1 Identifying Parameters 136 9.3.2 Defining Parameters 137 9.3.3 Parameterizing Pointcuts in AOP 138 9.4 Generalizing Extension Use-Case Realizations 139 9.5 Templating Use-Case Slices 142 9.6 Summary and Highlights 144 Chapter 10 Building Systems with Use-Case Modules 145 10.1 A System Comprises Models 146 10.2 Use-Case Model 147 10.3 Analysis Model 148 10.3.1 Language of Analysis 149 10.3.2 Conducting Analysis 150 10.4 Design and Implementation Models 152 10.4.1 Language of Design and Implementation 152 10.4.2 Conducting Design and Implementation 154 10.5 Use-Case Modules Cut Across Models 154 10.5.1 Preserving the Structure of the Use-Case Model 155 10.5.2 A Use-Case Module Contains Use-Case Slices 157 10.5.3 Use-Case Module Relationships 158 10.6 Composing and Configuring Use-Case Modules 159 10.7 Summary and Highlights 161 PART IV Establishing an Architecture Based on Use Cases and Aspects 163 Chapter 11 Road to a Resilient Architecture 167 11.1 What Is Architecture? 168 11.2 What Is a Good Architecture? 168 11.3 Steps to Establish an Architecture Baseline 170 11.4 Begin with a Platform-Independent Structure 174 11.4.1 Element Structure 174 11.4.2 Use-Case Structure 177 11.5 Overlay Platform Specifics on Top 179 11.5.1 Choosing the Platform 179 11.5.2 Keeping Platform Specifics Separate 181 11.6 Summary and Highlights 184 Chapter 12 Separating Functional Requirements with Application Peer Use Cases 187 12.1 Analyzing Application UseCases 188 12.1.1 Identifying Classes 189 12.1.2 Allocating Use-Case Behavior to Classes 190 12.2 Keeping Application Use Cases Separate 195 12.2.1 Element Structure 195 12.2.2 Use-Case Structure 196 12.3 Designing Application Use Cases 199 12.3.1 Identifying Design Elements 200 12.3.2 Identifying Components and Interfaces 203 12.4 Refining Design Elements 205 12.4.1 Keeping Class Extensions Separate 205 12.4.2 Keeping Operation Extensions Separate 207 12.4.3 Keeping State Transitions Separate 209 12.5 Summary and Highlights 211. Chapter 13 Separating Functional Requirements with Application-Extension UseCases 213 13.1 Analyzing Application-Extension Use Cases 214 13.1.1 Identifying Classes 215 13.1.2 Identifying Pointcuts 216 13.1.3 Allocating Use-Case Behavior to Classes 218 13.2 Keeping Application-Extension Use Cases Separate 220 13.2.1 Structuring Alternate Flows 221 13.2.2 Keeping Alternate Flows Separate 222 13.3 Designing Application-Extension Use Cases 224 13.3.1 Designing Operation Extensions 224 13.3.2 Identifying Component Interfaces from Use-Case Extensions 225 13.3.3 Dealing with Multiple Extensions to a Use Case 226 13.3.4 Extending Multiple Use Cases 229 13.4 Dealing with Changes in the Base 230 13.4.1 Applying Reflection 232 13.4.2 Applying Design Patterns 232 13.4.3 Applying Adaptive Programming 235 13.5 Summary and Highlights 236 Chapter 14 Separating Nonfunctional Requirements with Infrastructure Use Cases 239 14.1 Analyzing an Infrastructure Use Case 240 14.1.1 Identifying Classes 241 14,1.2 Identifying Pointcuts 242 14.1.3 Allocating Use-Case Behavior to Classes 245 14.2 Keeping Infrastructure Use Cases Separate 247 14.3 Designing Infrastructure Use Cases 250 14.3.1 Applying the Infrastructure Use-Case Slice with Aspects 251 14.3.2 Applying the Infrastructure Use-Case Slice with Filters 252 14.3.3 Identifying Components in the Infrastructure Layer 255 14.4 Dealing with Multiple Infrastructure Use Cases 256 14.5 Summary and Highlights 261 Chapter 15 Separating Platform Specifics with Platform-Specific Use-Case Slices 263 15.1 Keeping Platform Specifics Separate 264 15.1.1 Three-Tier Systems 264 15.1.2 Tier Packages 266 15.1.3 Modeling Tiers with Infrastructure Use Cases 268 15.2 Overlaying User Interfaces 269 15.2.1 Minimal Use-Case Design without Presentation Specifics 270 15.2.2 A Web Presentation Mechanism in J2EE 271 15.2.3 Designing the Presentation Mechanism 273 15.2.4 Applying the Presentation Mechanism 275 15.3 Overlaying Distdbution 276 15.3.1 Minimal Use-Case Design without Distribution 277 15.3.2 An EJB Distribution Mechanism 278 15.3.3 Designing the Distribution Mechanism 281 15.3.4 Applying the Distribution Mechanism 286 15.4 Overlaying Persistency 290 15.4.1 Minimal Use-Case Design without Persistence 291 15.4.2 A Relational Persistency Mechanism in J2EE 292 15.4.3 Designing Persistency Mechanism 293 15.4.4 Applying the Persistency Mechanism 297 15.5 Preserving the Use-Case Structure 298 15.6 Summary and Highlights 299 Chapter 16 Separating Tests with Use-Case Test Slices 301 16.1 Test-First Approach 301 16.2 Identifying Test Cases from Use Cases 303 16.2.1 Identifying Test Cases from Use-Case Flows 304 16.2.2 Identifying Test Cases from Use-Case Variables 305 16.2.3 Identifying Test Cases across Multiple Application Use Cases 306 16.2.4 Identifying Test Cases for the Infrastructure and the Platform Specifics 306 16.2.5 Identifying Performance Test Cases 307 16.3 Identifying Elements to Be Tested 308 16.4 Designing and Implementing Tests 310 16.4.1 Designing a Test Infrastructure 312 16.4.2 Designing a Test Case 316 16.5 Summary and Highlights 317 Chapter 17 Evaluating the Architecture 319 17.1 Putting It Together 319 17.2 Evaluating Separation of Concerns 324 17.2.1 Evaluating Design Elements 325 17.2.2 Evaluating Design Packages 325 17.2.3 Evaluating Use-Case Structures 327 17.2.4 Automating the Evaluation 329 17.2.5 Enforcing the Separation of Concerns 330 17.3 Evaluating and Achieving Systemwide Concerns 332 17.3.1 Evaluating and Achieving Maintainability 332 17.3.2 Evaluating and Achieving Extensibility 332 17.3.3 Evaluating and Achieving Portability 333 17.3.4 Evaluating and Achieving Reusability 334 17.3.5 Evaluating and Achieving Performance and Reliability 334 17.4 Summary and Highlights 336 Chapter 18 Describing the Architecture 339 18.1 Architecture Description Comprises Architectural Views 340 18.2 Architectural View of the Use-Case Model 342 18.3 Architectural View of the Analysis Model 344 18.3.1 Architecturally Significant Analysis Elements 344 18.3.2 Architecturally Significant Use-Case Analysis Slices 346 18.4 Architectural View of the Design Model 347 18.4.1 Architecturally Significant Deployment Elements 348 18.4.2 Architecturally Significant Process Elements 348 18.4.3 Architecturally Significant Design Elements 349 18.4.4 Architecturally Significant Use-Case Design Slices 351 18.5 Summary and Highlights 352 PART V Applying Use Cases and Aspects in a Project 355 Chapter 19 Running a Project 357 19.1 Iterative Development 357 19.1.1 Phases in a Project 358 19.1.2 Activities in an Iteration 359 19.2 Estimating Development Effort 359 19.2.1 Estimation at the Beginning of a Project 360 19.2.2 Refining the Estimates 362 19.3 Planning and Controlling the Project 363 19.3.1 Estimating Project Delays 363 19.3.2 Keeping the Project on Track 364 19.4 Productivity Gains by Keeping Concerns Separate 365 19.5 Summary and Highlights 367 Chapter 20 Tailoring the Approach 369 20.1 Achieving the Right Balance 369 20.2 Selecting Disciplines to Apply 370 20.3 Adopting at Different Phases of a Project 373 20.4 Summary and Highlights 374 Chapter 21 Aspects and Beyond 375 21.1 Building a System in Extensions 375 21.2 Balancing Best Practices 376 21.3 The Road Ahead 377 Appendix A Modeling Aspects and Use-Case Slices in UML 379 Appendix B Notation Guide 387 References 395 Glossary 399 Index 407
鄂公網(wǎng)安備 42010302001612號(hào) 