(特价书)基于用例的面向方面软件开发（英文影印版）

.3.1 use cases in brief
3.2 use-case-driven development
3.3 roles and benefits of use cases
3.4 gaps in the use-case technique
3.5 bridging the gaps with aspects
chapter 4 tomorrow with use-case modules
4.1 building systems in overlays with use-case slices
4.2 keeping peer use cases separate
4.3 keeping extension use cases separate
4.4 developing with use-case modules
part ii modeling and capturing concerns with use
cases
chapter 5 modeling concerns with use cases
5.1 use-case modeling
5.2 use-case instances and flows of events
5.3 describing use cases
5.4 visualizing use-case flows
5.5 summary and highlights
chapter 6 structuring use cases
6.1 use-case relationships
6.2 use-case extend relationship
6.3 use-case include relationship
6.4 use-case generalization
6.5 utility use cases
6.6 summary and highlights
chapter 7 capturing concerns with use cases
7.1 understanding stakeholder concerns
7.1.1 understanding the problem domain
7.1.2 eliciting system features
7.1.3 dealing with functional and nonfunctional
requirements
7.2 capturing application use cases
7.2.1 identifying use-case variability
7.2.2 handling use-case variability
7.2.3 dealing with extension use cases
7.3 capturing infrastructure use cases
7.3.1 the perform transaction use case
7.3.2 structuring infrastructure use cases
7.3.3 describing infrastructure use cases
7.3.4 dealing with systemwide concerns
7.4 summary and highlights
part iii keeping concerns separate with use-case
modules 103
chapter 8 keeping peer use-case realizations separate with
aspects
8.1 realizing peer use cases
8.1.1 collaborations
8.1.2 realizing a use case
8.1.3 overlap between peer use-case realizations
8.2 keeping use-case specifics separate
8.2.1 composing use-case-specific classes
8.2.2 composing use-case-specific class extensions
8.2.3 collaborations in use-case slices
8.3 dealing with overlap
8.3.1 included use-case slice
8.3.2 generalized use-case slice
8.3.3 non-use-case-specific slice
8.4 summary and highlights
chapter 9 keeping extensions separate with pointcuts
9. 1 realizing extension use cases
9.2 keeping modularity of extension use-case realizations
9.2.1 operation extensions
9.2.2 pointcuts
9.3 parameterizing pointcuts
9.3.1 identifying parameters
9.3.2 defining parameters
9.3.3 parameterizing pointcuts in aop
9.4 generalizing extension use-case realizations
9.5 templating use-case slices
9.6 summary and highlights
chapter 10 building systems with use-case modules
10.1 a system comprises models
10.2 use-case model
10.3 analysis model
10.3.1 language of analysis
10.3.2 conducting analysis
10.4 design and implementation models
10.4.1 language of design and implementation
10.4.2 conducting design and implementation
10.5 use-case modules cut across models
10.5.1 preserving the structure of the use-case model
10.5.2 a use-case module contains use-case slices
10.5.3 use-case module relationships
10.6 composing and configuring use-case modules
10.7 summary and highlights
part iv establishing an architecture based on use cases and aspects
chapter 11 road to a resilient architecture
11.1 what is architecture?
11.2 what is a good architecture?
11.3 steps to establish an architecture baseline
11.4 begin with a platform-independent structure
11.4.1 element structure
11.4.2 use-case structure
11.5 overlay platform specifics on top
11.5.1 choosing the platform
11.5.2 keeping platform specifics separate.
11.6 summary and highlights
chapter 12 separating functional requirements with application peer use cases 187
12.1 analyzing application use cases
12.1.1 identifying classes
12.1.2 allocating use-case behavior to classes
12.2 keeping application use cases separate
12.2.1 element structure
12.2.2 use-case structure
12.3 designing application use cases
12.3.1 identifying design elements..
12.3.2 identifying components and interfaces
12.4 refining design elements
12.4.1 keeping class extensions separate
12.4.2 keeping operation extensions separate
12.4.3 keeping state transitions separate
12.5 summary and highlights
chapter 13 separating functional requirements with
application-extension use cases
13.1 analyzing application-extension use cases
13.1.1 identifying classes
13.1.2 identifying pointcuts
13.1.3 allocating use-case behavior to classes
13.2 keeping application-extension use cases separate
13.2.1 structuring alternate flows
13.2.2 keeping alternate flows separate
13.3 designing application-extension use cases
13.3.1 designing operation extensions
13.3.2 identifying component interfaces from use-case extensions
13.3.3 dealing with multiple extensions to a use case
13.3.4 extending multiple use cases
13.4 dealing with changes in the base
13.4.1 applying reflection
13.4.2 applying design patterns
13.4.3 applying adaptive programming
13.5 summary and highlights
chapter 14 separating nonfunctional requirements with infrastructure use cases
14.1 analyzing an infrastructure use case
14.1.1 identifying classes
14.1.2 identifying pointcuts
14.1.3 allocating use-case behavior to classes
14.2 keeping infrastructure use cases separate
14.3 designing infrastructure use cases
14.3.1 applying the infrastructure use-case slice with aspects
14.3.2 applying the infrastructure use-case slice with filters
14.3.3 identifying components in the infrastructure layer
14.4 dealing with multiple infrastructure use cases
14.5 summary and highlights
chapter 15 separating platform snecifics with platform-specific
use-case slices
15.1 keeping platform specifics separate
15.1.1 three-tier systems
15.1.2 tier packages
15.1.3 modeling tiers with infrastructure use cases
15.2 overlaying user interfaces
15.2.1 minimal use-case design without presentation specifics
15.2.2 a web presentation mechanism in j2ee
15.2.3 designing the presentation mechanism
15.2.4 applying the presentation mechanism
15.3 overlaying distribution
15.3.1 minimal use-case design without distribution
15.3.2 an ejb distribution mechanism
15.3.3 designing the distribution mechanism
15.3.4 applying the distribution mechanism
15.4 overlaying persistency
15.4.1 minimal use-case design without persistence
15.4.2 a relational persistency mechanism in j2ee
15.4.3 designing persistency mechanism
15.4.4 applying the persistency mechanism
15.5 preserving the use-case structure
15.6 summary and highlights
chapter 16 separating tests with use-case test slices
16.1 test-first approach
16.2 identifying test cases from use cases
16.2.1 identifying test cases from use-case flows
16.2.2 identifying test cases from use-case variables
16.2.3 identifying test cases across multiple application use cases
16.2.4 identifying test cases for the infrastructure and the platform specifics
16.2.5 identifying performance test cases
16.3 identifying elements to be tested
16.4 designing and implementing tests
16.4.1 designing a test infrastructure
16.4.2 designing a test case
16.5 summary and highlights
chapter 17 evaluating the architecture
17.1 putting it together
17.2 evaluating separation of concerns
17.2.1 evaluating design elements
17.2.2 evaluating design packages
17.2.3 evaluating use-case structures
17.2.4 automating the evaluation
17.2.5 enforcing the separation of concerns
17.3 evaluating and achieving systemwide concerns
17.3.1 evaluating and achieving maintainability
17.3.2 evaluating and achieving extensibility
17.3.3 evaluating and achieving portability
17.3.4 evaluating and achieving reusability
17.3.5 evaluating and achieving performance and reliability
17.4 summary and highlights
chapter 18 describing the architecture
18.1 architecture description comprises architectural views
18.2 architectural view of the use-case model
18.3 architectural view of the analysis model
18.3.1 architecturally significant analysis elements
18.3.2 architecturally significant use-case analysis slices
18.4 architectural view of the design model
18.4.1 architecturally significant deployment elements
18.4.2 architecturally significant process elements
18.4.3 architecturally significant design elements
18.4.4 architecturally significant use-case design slices
18.5 summary and highlights
part v applying use cases and aspects in a project
chapter 19 running a project
19.1 iterative development
19.1.1 phases in a project
19.1.2 activities in an iteration
19.2 estimating development effort
19.2.1 estimation at the beginning of a project
19.2.2 refining the estimates
19.3 planning and controlling the project
19.3.1 estimating project delays
19.3.2 keeping the project on track
19.4 productivity gains by keeping concerns separate
19.5 summary and highlights
chapter 20 tailoring the approach
20.1 achieving the right balance
20.2 selecting disciplines to apply
20.3 adopting at different phases of a project
20.4 summary and highlights
chapter 21 aspects and beyond
21.1 building a sys/tem in extensions
21.2 balancing best practices
21.3 the road ahead
appendix a modeling aspects and use-case slices in uml
appendix b notation guide
references...
glossary
index