Object oriented analysis and

design
Module 12: Identify Design Mechanisms
 Objectives: Identify Design
Mechanisms
• Define the purpose of the Identify Design
Mechanisms activity and explain when in
the lifecycle it is performed
• Explain what design and implementation
mechanisms are and how they map from
Analysis mechanisms
• Describe some key mechanisms that will
be utilized in the case study
Identify Design Mechanisms in Context
[Early
Elaboration [Inception
Iteration] Iteration (Optional)]

Define a Candidate Perform

Architecture Architectural
Synthesis

Analyze Behavior

Identify Design (Optional)

Mechanisms Architect Refine the
Architecture

Design Design the

Components Database
Identify Design Mechanisms Overview

Supplementary Software
Specifications Architecture
Document

Identify
Design
Mechanisms
Design Model

Analysis Class
 Identify Design Mechanisms:
Steps
• Categorize clients of analysis mechanisms
• Document architectural mechanisms
Identify Design Mechanisms: Steps

Categorize clients of analysis mechanisms

Documenting architectural mechanisms
 Review: Patterns and
Frameworks
• Pattern
– Provides a common solution to a common
problem in a context
• Analysis/Design Pattern
– Provides a solution to a narrowly scoped
technical problem
– Provides a fragment of a solution, or a piece of
the puzzle
• Framework
– Defines the general approach to solving the
problem
– Provides a skeletal solution, whose details may
be analysis/design patterns
 What Is a Design Pattern?
• A design pattern provides a scheme for
refining the subsystems or components of
a software system, or the relationships
between them. It describes a commonly-
recurring structure of communicating
components that solves a general design
problem within a particular context.
Erich Gamma et al. 1994. Design Patterns—Elements of
Reusable Object-Oriented Software
Template
Parameters

Pattern Name
 Examples of Pattern Usage
Pattern Example
Command Issue a request to an object without knowing anything about
(behavioral pattern) the operation requested or the receiver of the request: for
example, the response to a menu item, an undo request, the
processing of a time-out
Abstract factory Create GUI objects (buttons, scrollbars, windows, etc.)
(creational pattern) independent of the underlying OS: the application can be
easily ported to different environments

Proxy Handle distributed objects in a way that is transparent to the

(structural pattern) client objects (remote proxy)
Load a large graphical object or any entity object “costly” to
create/initialize only when needed (on demand) and in a
transparent way (virtual proxy)
Observer When the state of an object changes, the dependent objects
(behavioral pattern) are notified. The changed object is independent of the
observers.
Note: The MVC architectural pattern is an extension of the
Observer design pattern
Detailing the Command Pattern
Application

+menu 1
0..*
MenuItem 1 Command
Menu - label : String
+items +cmd + Process()
+ Clicked()

cmd.Process();
Detailing the Command Pattern
(continued)

Application OpenCommand
AskUser();
DoOpen(); + Process()

+cmd
+menu 1
0..*
MenuItem 1 Command
Menu - label : String
+items + Process()
+ Clicked()

cmd.Process();
Detailing the Command Pattern
(continued)
1. OpenCommand( )
myapp ocmd : Initialization
OpenCommand

2. AddItem("Open...",ocmd)

3. MenuItem("Open...", ocmd)
menu aNewItem :
MenuItem

3. AskUser( )
4. DoOpen( )

The user selects the 1. Clicked( ) 2. Process( )

theMenuIte
Open… menu item m
cmd :
Command
A user
Detailing the Command Pattern
(continued)
OpenCommand

Application + Process()
+ OpenCommand()
AskUser(); - AskUser()
DoOpen(); - DoOpen()

+menu 1
MenuItem
Menu 0..* - label : String

+ AddItem(s : String, c : Command) +items + Clicked()

+ MenuItem(s : String, c : Command)

Clicked(): MenuItem():
cmd.Process(); cmd = c;
label = s;

+cmd
1

Command

+ Process()
Detailing the Command Pattern
(continued)
app

Application CloseCommand

OpenCommand

gui

Menu MenuItem

com

Command
 Representing Design Patterns
in UML
• A design pattern is a parameterized
collaboration: The parameters (stereotype <<role>>)
of the collaboration

Client
Invoker <<role>>
ConcreteCommand Client

Command <<role>>
ConcreteCommand

+ Process()

<<role>>
Invoker

Command

+ Process()
 Describing Analysis Mechanisms

• Collect all analysis mechanisms in a list

• Draw a map of the client classes to the
analysis mechanisms
Analysis Class Analysis Mechanism(s)

Student Persistence, Security

Schedule Persistence, Security
CourseOffering Persistence, Legacy Interface
Course Persistence, Legacy Interface
RegistrationController Distribution
• Identify characteristics of the Analysis
mechanisms
 Categorize Analysis
Mechanisms
• Purpose
– To refine the information gathered on the
analysis mechanisms
• Steps
– Identify the clients of each analysis
mechanism
– Identify characteristic profiles for each
analysis mechanism
– Group clients according to their use of
characteristic profiles
– Proceed bottom up and make an inventory of
the implementation mechanisms that you
have at your disposal
Identify Design Mechanisms: Steps

Categorize clients of analysis mechanisms

Documenting architectural mechanisms
 Design and Implementation
Mechanisms
Analysis Design Implementation
Mechanism Mechanism Mechanism
(Conceptual) (Concrete) (Actual)
Legacy Data

Persistency RDBMS JDBC

New Data

Persistency OODBMS ObjectStore

Distribution Remote Method Java 1.2 from Sun

Invocation (RMI)
 Review: Documenting
Architectural Mechanisms
• Architectural mechanisms can be treated
as patterns (i.e., parameterized
collaboration)
Template
Parameters

Pattern Name

Structural Aspect Behavioral Aspect

Documented in Design Guidelines

Review: Course Registration
Analysis Mechanisms

Persistence Distribution

Security Legacy Interface

 Mechanism: Persistency:
RDBMS: JDBC
• Persistence characteristics:
– Granularity
– Volume
– Duration
– Access mechanism
– Access frequency
(creation/deletion, update,
read)
– Reliability

Note: JDBC is the standard Java API for talking to a SQL database.
 Example: Persistency: RDBMS:
JDBC
<<role>> Roles to be filled by the <<role>>
PersistencyClient PersistentClassList
(from SamplePersistency Client)
designer applying the (from SamplePersistentClass)
mechanism
new()
add(c: PersistentClass)

<<role>> 1
DBClass 0..*0..*
<<role>>
create() : PersistentClass PersistentClass
read(searchCriteria : String) : PersistentClassList (from SamplePersistentClass)
update(c : PersistentClass)
delete(c : PersistentClass)
getData()
setData()
1
command()
new()

DriverManager
(from java.sql)

1 getConnection(url, user, pass) : Connection

ResultSet Statement
Connection
(from java.sql)
(from java.sql) (from java.sql)

executeQuery(sql : String) : ResultSet

getString() : String createStatement() : Statement
executeUpdate(sql : String) : int
Example: Persistency: RDBMS:
JDBC: Initialize

: DBClass : DriverManager

1. getConnection(url, user, pass)

Example: Persistency: RDBMS:
JDBC: Create
: PersistencyClient : DBClass : PersistentClass : Connection : Statement

1. create( )
1.1. New()

1.2. getData( )

1.3. createStatement( )

1.4. executeUpdate(String)
 What Is a Combined Fragment?

A construct within an interaction that
comprises an operator keyword and one or
more interaction operands, each of which is a
fragment of an interaction.
 It is shown as a nested region within a sequence diagram.
Client Object Supplier Object

:Client :Supplier

interaction operand
 What is an Interaction
Operand?

Each fragment comprises one or more
interaction operands, each a subfragment of
the interaction.
 The number of operands depends on the type of
combined fragment.
• For example, a loop has one operand (the loop body)
and a conditional has one or more operands (the
branches of the conditional).
 An operand is a nested fragment of an interaction.
• Each operand covers the lifelines covered by the
combined fragment or a subset of them.
 What is an Interaction
Expression?

A specification of the range of number of
iterations of a loop.
 Range can be specified with minimum and maximum
values
 A guard condition, enclosed in square brackets, can be
included on a lifeline.
Client Object Supplier Object

Interaction
:Client :Supplier
Expression

loop (range)

[guard exp]
1: PerformResponsibility
 Example : Persistency: RDBMS:
JDBC: Read
: PersistencyClient : DBClass : Connection : Statement : ResultSet : PersistentClassList : PersistentClass

1. read(string) Returns a The SQL statement

Statement built by the DBClass
1.1. createStatement( ) using the given
criteria is passed to
The criteria used executeQuery()
1.2. executeQuery(string)
to access data for 1.3 // executeQuery()
the persistent
class 1.4. new( )

loop Create a list to hold all

retrieved data
[for each class from execute query]
1.5. new()

loop
[for each attribute in class] 1.6. getString( )
1.7. setData( )

1.8. add(PersistentClass)
Example: Persistency: RDBMS:
JDBC: Update
: PersistencyClient : DBClass : PersistentClass : Connection : Statement

1. update(PersistentClass)

1.1. getData( )

1.2. createStatement( )

1.3. executeUpdate(string)

execute SQL
statement
Example: Persistency: RDBMS:
JDBC: Delete
: PersistencyClient : DBClass : Connection : Statement

1. delete(PersistentClass)

1.1. createStatement( )
execute SQL
statement

1.2. executeUpdate(string)
 Incorporating JDBC: Steps
1. Provide access to the class libraries needed to
implement JDBC
– Provide java.sql package
2. Create the necessary DBClasses
– Assign one DBClass per persistent class
3. Incorporate DBClasses into the design
– Allocate to package/layer
– Add relationships from persistency clients Deferred

4. Create/Update interaction diagrams that describe:

– Database initialization
– Persistent class access: Create, Read, Update,
Delete
Example: Incorporating JDBC

Sample
Persistency
Client Package

java.sql

DriverManager Connection
(from java.sql) (from java.sql)

Statement ResultSet
(from java.sql) (from java.sql)
 Review: Identify Design
Mechanisms
• What does an analysis mechanism do?
• What is a pattern? What makes a
framework different from a pattern?
• Why should you categorize analysis
mechanisms? Identify the steps.