Transcript Arquitectura de software dirigida por modelos

Patrones de Diseño
en MDA
Patrones de Diseño
“descripciones de objetos que se comunican y
clases que son personalizadas para resolver
un problema de diseño general en un
contexto particular” (Gamma y otros, 1995)
Patrones de Diseño

Los patrones de diseño describen soluciones a
problemas de diseño recurrentes.

Un patrón de diseño nombra, abstrae e
identifica los aspectos claves de una estructura
de diseño común que lo hacen útil para crear un
diseño orientado a objetos reusable.

Un patrón de diseño identifica las clases que
participan y las instancias, sus roles y
colaboraciones, y la distribución de
responsabilidades.
Metamodelos de Patrones de Diseño
El metamodelo de un patrón de diseño dado,
describe la familia de modelos que forman el
espacio de soluciones de ese patrón.
Metamodelos de Patrones de Diseño en MDA
Metamodelos en tres niveles:

PIM: metamodelos de patrones definidos de
manera independiente de cualquier plataforma
o tecnología específicas.

PSM: metamodelos de patrones definidos
teniendo en cuenta una plataforma específica.
Por ejemplo JAVA, EIFFEL.

ISM: metamodelos de patrones que
corresponden a un lenguaje de programación
específico.
Metamodelos de Patrones de Diseño en MDA
Los Metamodelos de Patrones a nivel PIM son
especificados teniendo en cuenta:



La estructura
Los participantes
Colaboraciones
Metamodelos de Patrones de Diseño en MDA
Metamodelos de Patrones a nivel PSM son
especificados teniendo en cuenta:


El metamodelo a nivel PIM del patrón
Las características de la plataforma. Por ejemplo
un metamodelo para la plataforma Java
restringe la herencia, ya que Java no permite
herencia múltiple, mientras que un
metamodelo para la plataforma EIFFEL no
tendrá esta restricción.
Metamodelos de Patrones de Diseño en MDA
Metamodelos de Patrones a nivel ISM son
especificados teniendo en cuenta:
 La
gramática del lenguaje de programación
específico
Especificación de los Metamodelos de
Patrones de Diseño

La especificación del espacio de soluciones de
un patrón de diseño se logra a través de la
especialización del metamodelo UML y la
especificación de un conjunto de restricciones
escritas en OCL.
Notación de los Metamodelos de
Patrones de Diseño
Para la especificación de los metamodelos de los patrones
se usa la notación de la especificación de UML de
manera semi-formal usando la combinación de
notación gráfica, lenguaje natural y lenguaje formal:

Sintaxis abstracta: diagrama de clases UML
(metaclases que definen las construcciones y sus
relaciones) junto con una descripción en lenguaje
natural.

Restricciones: son provistas usando el lenguaje OCL y
un lenguaje natural.

Semántica: el significado de las construcciones es
definido usando lenguaje natural.
Relaciones entre Modelos y Metamodelos
PIM
UML/OCL PIM
Metamodel
PSM
UML/OCL
PSM-J2EE
UML/OCL
PSM-EIFFEL
UML/OCL
PSM-.NET
Model Transformation
Instance of
ISM
JAVA
EIFFEL
C++
Metamodel Relation
Metamodel
PIM
UML/OCL
PIM
PSM
PSM-J2EE
PSM-EIFFEL
PSM-.NET
ISM
JAVA-CODE
… EIFFEL-CODE
…
C# -CODE
C++-CODE
Model
…
Ejemplo:
Patrón de Diseño Observer
Patrón de Diseño Observer
El patrón de diseño Observer “define una
dependencia uno a muchos entre objetos de
manera tal que cuando un objeto cambia de
estado, todos sus dependientes son notificados
y actualizados automáticamente” (Gamma y
otros, 1995).
Patrón Observer : Diagramas de Clases y de Secuencia UML
Subject
observers
attach(Observer) 1..*
detach(Observer)
notify()
Observer
0..* update()
post: observers -> forAll
(o:Observer | o->update())
ConcreteSubject
subjectState
0..* ConcreteObserver
observerState
subject
1..*
getState()
setState()
result=
subjectState
update()
observerState=
subject->getState()
a. Class Diagram
aConcreteSubject :
ConcreteSubject
aConcreteObserver :
ConcreteObserver
anotherConcreteObserver :
ConcreteObserver
setState( )
notify( )
update( )
getState( )
update( )
getState( )
b. Sequence Diagram
Metamodelo del
Patrón de Diseño Observer
a nivel PIM
Patrón Observer- Metamodelo PIM : Diagrama de Clases
DirectedRelationship
Property
+association
{redefines association}
1
AssocEndSubject
{subsets memberEnd}
SubjectObserver
1
+association
{redefines association}
1
1
AssocEndObservers
{subsets memberEnd}
0..1
0..1
Association
1 +participant
Subject
{redefines
target}
1
1
+participant 1
Observer
Classifier
{redefines
class}
1
1
- - - - - - - - - - - - - - - - - {redefines class}
- - - - - - - - - - - - - - - - - - - - - - - - - - -{subset ownedOperation}
1..*
1..*
1..*
Attach
RelationshipSubject
Detach
1..*
Notify
Update
1
1 {redefines
target}
{subsets
ownedOperation}
RelationshipObserver
1
+getState
{subsets member}
{subsets
ownedElement}
1..*
1
{redefines
source}
GetState
+setState
{subsets member}
1
1
{redefines source}
1
Property
1
ConcreteObserver
Class
+state
{subsets member}
1..*
1
{subsets
ownedElement}
SetState
1..*
ConcreteSubject
1 +participant
Operation
Association
1
+participant 1
1
AssocEndConcreteSubject
{subsets memberEnd}
1
1
+association
{redefines association}
ObserverSubject
1
{subsets memberEnd}
+association
1
{redefines association}
AssocEndConcreteObserver
Patrón de Diseño Observer
Metamodelo PIM: Restricciones
Metaclase Subject
Un sujeto, instancia de la metaclase Subject puede
ser una clase o una interfaz.
(self.oclIsTypeOf(Class) or self.oclIsTypeOf(Interface)
Patrón de Diseño Observer
Metamodelo PIM : Restricciones
Metaclase Attach
[1] Esta operación cambia el estado del sujeto.
not self.isQuery
[2] Esta operación tiene un conjunto no vacío de parámetros
y uno de ellos debe ser de entrada (direction= #in) y del
tipo Observer.
self.parameter->notEmpty( ) and
self.parameter->select ( param | param.direction= #in and
param.type= oclIsKindOf(Observer)) -> size( ) = 1
Patrón de Diseño Observer
Metamodelo PIM : Restriciones
Metaclase RelationshipSubject
Una instancia de esta relación está restringida a ser una generalización o una realización
de interfaz.
self.oclIsTypeOf( Generalization) or (self.oclIsTypeOf(InterfaceRealization))
and
self.oclIsTypeOf(Generalization) implies (
self.general.oclIsKindOf(Class)
and self.general.oclIsTypeOf(Subject)
and self.specific.oclIsTypeOf(ConcreteSubject) )
and
self.oclIsTypeOf(InterfaceRealization) implies (
self.contract.oclIsKindOf(Interface) and
self.contract.oclIsTypeOf(Subject)
and self.implementingClassifier.oclIsTypeOf(ConcreteSubject))
Metamodelo del
Patrón de Diseño Observer
a nivel PSM Eiffel
El Metamodelo del patrón Observer a nivel
PSM Eiffel es una especialización del
Metamodelo PSM EIFFEL
Metamodelo PSM Eiffel: EiffelClass
Classifier
(from Template)
+class
Class
(fromKernel)
+ownedOperation
*
0..1
+class
Operation
(from Kernel)
Property
(from Kernel)
+ownedAttribute
0..1
*
EiffelClass
isDeferred {redefines is Abstract}
isExpanded : Boolean
+class
{redefines class}
0..1
*
{subsets ownedAttribute}
AssociationEnd
Attribute
+class
{redefines class}
1
+class
1
{redefines class}
*
{subsets ownedAttribute}
Routine
+ownedRoutine *
{redefines ownedOperation}
+class
{redefines namespace}
0..1
isFrozen {redefines isLeaf}
isDeferred {redefines isAbstract}
isFrozen {redefines isLeaf}
+invariant
*
{redefines ownedRule}
+/parents {redefines supperclass}
*
+parent
{redefines general}
+heir
{redefines specific}
1
1
*
Generalization
(from Kernel)
Constraint
Metamodelo PSM Eiffel: Routine
Operation (from Kernel)
+operation
0..1
isQuery : Boolean = False
+redefined
Operation
+ownedParam eter
*
+precondition
+preContext
0..1
+postContext
+postcondition
0..1
+bodyContext
+bodyCondition
0..1
*
Parameter
*
Constraint
*
0..1
+type
0..1
+raisedException
Routine
+signature
isDeferred {redefines isAbstract}
isFrozen {redefines isLeaf}
1
+invokedRoutine
*
+body
Type
*
Implementation
0..1 procedure
: Expression
1
1
Procedure
Function
+referencedAttribute
*
Attribute
isConstructor : Boolean
isFrozen {redefines isLeaf}
+returnType 1
Type
{redefines type}
Patrón Observer - Metamodelo PSM-Eiffel: Diagrama de Clases
Generalization
AssociationEnd
AssocEndSubject
1
+association
{redefines association}
1
1
{subsets memberEnd}
+association
1
{redefines association}
1
{subset m em berEnd}
SubjectObserver
AssocEndObserver
1
Association
1
+participant
Subject
+parent
{redefines
general}
1
+participant
{subset
ownedRoutine}
- - - - - - - - - - - - - - - - - - - - - - - - {redefines class}
1..*
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {subsets ownedRoutine}
1..*
1..*
Detach
Notify
Relationship Subject
1
{subsets
generalization}
{subsets
member}
1
{subsets
ownedRoutine}
GetState
1..*
{subsets
member}
1..*
+state
{subsets
member}
1
1
{subsets
generalization}
Attribute
{redefines
specific}
Association
1
1
+association
{redefines association}
{subset m em berEnd}
+association
{redefines association}
ObserverSubject
1
1
AssociationEnd
1 +heir
EffectiveObserver
EiffelClass
+participant
AssocEndEffectiveSubject
Update
Routine
+heir
{redefines
specific}
EffectiveSubject
1..*
+parent
1
{redefines
general}
Relationship Observer
SetState
1..*
1
Observer
EiffelClass
Attach
1
{subsets memberEnd}
+participant 1
1
1
AssocEndEffectiveObserver
Patrón de Diseño Observer
Metamodelo PSM Eiffel : Restriciones
AssocEndObserver
[1]Este extremo de asociación tiene una multiplicidad cuyo rango será
un subconjunto (posiblemente infinito) de los enteros no negativos.
multiplicity.lower >= 0 and
(self.multiplicity.upper > 0 or self.multiplicity.upper = #unlimited)
[2]Deberá ser navegable.
self.isNavigable( )
Operaciones Adicionales
La rutina observadora isNavigable indica si este extremo de asociación
es navegable.
isNavigable = not class ->isEmpty()
Especificando Refinamientos en OCL:
de PIM-UML a PSM-EIFFEL
Reglas de Transformación

La especificación de los metamodelos en los tres
niveles, permite construir la definición de
transformación de modelo a modelo.

Las reglas de transformación que constituyen
una definición de transformación describen
como puede transformarse un modelo en un
lenguaje origen en un modelo en un lenguaje
destino.
Reglas de transformación
En el caso del patrón de diseño observer, las reglas usan los
metamodelos definidos en los distintos niveles para definir las
transformaciones.
 Transformación PIM-PSM:


Metamodelo Origen: “UML especializado del patrón Observer”

Metamodelo Destino: “UML especializado del patrón Observer
en una plataforma específica”.
Transformación PSM-ISM:

Metamodelo Origen: “UML especializado del patrón Observer
en una plataforma específica”.

Metamodelo Destino: “UML especializado del patrón Observer
en un lenguaje de programación específico”
Transformación de PIM-UML A PSM-EIFFEL
Transformation PIM-UML TO PSM-EIFFEL {
parameters
sourceModel: Design Pattern Metamodel :: Package
targetModel: Design Pattern Metamodel-EIFFEL :: Project
pre:
-- El paquete SourceModel no importa otros paquetes.
sourceModel.importedElement  isEmpty
post:
-- el número de clases del modelo target es igual al número de clases más el número de
interfaces del modelo source.
sourceModel.ownedMember select(oclIsTypeOf(Class)) size() +
sourceModel.ownedElement select(oclIsTypeOf(Interface)) size()=
targetModel.ownedElement  select(oclIsTypeOf(EiffelClass)) size()
Transformación de PIM-UML A PSM-EIFFEL
post:
-- Para cada clase en sourceModel existe una clase Eiffel en targetModel tal que:
sourceModel.ownedElement  select(oclIsTypeOf(Class))
forAll ( sourceClass | targetModel.ownedElement 
select(oclIsTypeOf(EiffelClass)) exists ( targetClass |
-- sourceClass y targetClass tienen el mismo nombre y
sourceClass.name = targetClass.name and
-- tienen el mismo conjunto de operaciones y
sourceClass.member  select (oclIsTypeOf(Operation)) =
targetClass.member  select (oclIsKindOf(Routine)) and
-- tienen las mismas clases padres y las mismas clases hijas,
…
Transformación de PIM-UML A PSM-EIFFEL
post:
-- Para cada interface en sourceModel existe una clase Eiffel en targetModel tal que:
sourceModel.ownedElement  select(oclIsTypeOf(Interface))
forAll ( sourceInterface /targetModel.ownedElement 
select(oclIsTypeOf(EiffelClass)) exists ( targetClass /
-- sourceInterface y targetClass tienen el mismo nombre y
sourceInterface.name = targetClass.name and
-- tienen el mismo conjunto de operaciones y
sourceInterface.member  select (oclIsTypeOf(Operation)) =
targetClass.member  select (oclIsKindOf(Routine)) and
-- tienen las mismas clases padres y las mismas clases hijas,
...
))
Metamodelo del
Patrón de Diseño Observer
a nivel PSM JAVA
Metamodelo PSM Java: JavaClass
Classifier
(from Template)
Class
(from Kernel)
+class
+ownedOperation
0..1
*
+class
+ownedAttribute
0..1
*
JavaClass
1
isFinal {redefines is Leaf}
+class
{redefines class}
0..1
+/superClass
{redefines
superClass}
0..1
*
Property
(from Kernel)
1
Type
{redefines
type}
AssociationEnd
{subsets
ownedAttribute}
+class
{redefines class}
0..1
Field
*
{subsets
ownedAttribute}
isFinal : Boolean {redefines isLeaf}
isVolatile : Boolean
*
+nestedClass
{subsets
nestedClassifier}
Operation
(from Kernel)
JavaOperation
+class
{redefines class}
0..1
{redefines ownedOperation}
*
+javaExceptions
{redefines raisedException}
*
*
Metamodelo PSM Java: JavaInterface
Interface
(from Interfaces)
+class
+ownedOperation
*
0..1
+class
JavaInterface
1
+/superInterface
{redefines
general}
+interface
{redefines interface}
0..1
Property
(from Kernel)
+ownedAttribute
0..1
*
*
JavaOperation
AssociationEnd
{subsets
ownedAttribute}
+interface
{redefines interface}
0..1
Operation
(from Interface)
Field
*
{subsets ownedAttribute}
isFinal : Boolean {redefines isLeaf}
isVolatile : Boolean
0..1
*
+nestedInterface
{subsets
nestedClassifier}
Method
+interface
{redefines interface}
0..1
isAbstract : Boolean
isSynchronized : Boolean
* isFinal {redefines isLeaf}
{redefines ownedOperation}
Metamodelo PSM Java: JavaOperation
Operation (from Kernel)
isQuery : Boolean = False
+operation
+ownedParameter
*
0..1
+preContext
0..1
+postContext
+precondition
+bodyContext
Constraint
*
+postcondition
0..1
+redefinedOperation
Parameter
+bodyCondition
0..1
*
0..1
+/type
0..1
*
Type
+raisedException
*
JavaOperation
+signature
+body
Implementation
0..1 procedure
1
: Expression
1
*
Constructor
Method
isAbstract : Boolean
isSynchronized : Boolean
isFinal {redefines isLeaf}
1
+invokedMethod
+referencedField
*
Field
isFinal : Boolean {redefines isLeaf}
isVolatile : Boolean
Patrón Observer - Metamodelo Java: Diagrama de Clases
DirectedRelationship
AssociationEnd
+associati on
{redefi nes associ ation}
1
{subsets memberEnd}
1
AssocEndSubject
SubjectObserver
+associati on
1
{redefi nes associ ation}
1
{subset m emberEnd}
AssocEndObserver
1
1
+participant
1
Association
Subject
{redefi nes
contract}
1
Classifier
1
Observ er
{redefi nes 1
contract}
- - - - - - - - - - - - - - - - - {redefines class}
1..*
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - {subsets ownedOperati on}
1..*
1..*
1..*
Attach
Notify
Detach
+participant
{subsets
ownedOperation}
Update
Relationship Observer
Relationship Subject
1
1
1..*
{subsets
interfaceRealization}
{redefi nes
im pl em enti ng
Classifier}
ConcreteSubject
1
{subsets
member}
1..*
{subsets
member}
{redefi nes
im pl em enti ng
Classifier}
Field
1
ConcreteObserver
JavaClass
+participant 1
Association
+participant
1
AssocEndConcreteSubject
1
GetState
+state 1..*
{subsets
member}
1
{subsets
interfaceRealization}
Method
SetState
1
+associati on
{redefi nes associ ation}
{subset m emberEnd}
ObserverSubject
1
+associati on
{redefi nes associ ation}
1
AssociationEnd
1
{subsets memberEnd}
1
AssocEndConcreteObserver
Patrón Observer – Metamodelo PSM-Java:
Restricciones
Metaclase Subject
Un sujeto, instancia de la metaclase Subject puede
ser una clase Java o una interfaz Java.
(self.oclIsTypeOf(JavaClass) or
self.oclIsTypeOf(JavaInterface)
Metamodelos de patrones de diseño:
Ventajas

Un metamodelo UML para un patrón de diseño
permite detectar la presencia de un patrón en un
modelo.

La especificación de los metamodelos en los tres
niveles, permite construir la definición de
transformaciones de modelo a modelo, logrando una
generación de código más completa.
Bibliografía

Arnout, Karine (2004). “From Patterns to Components”. Ph. D. Thesis, Swiss
Institute of Technology (ETH Zurich)
http://se.inf.ethz.ch/people/arnout/publications/arnout_phd_thesis.pdf

Gamma y Otros (1996). Gamma E., Richard H., Ralph J. y Vlissides J.
“Design Patterns. Elements of reusable Object-Oriented Software”.
Addisson-Wesley.

MDA (2006). The Model Driven Architecture. www.omg.org/mda

Meyer (1997). Meyer, Bertrand. “Object-Oriented Software Construction”.
Prentice Hall PTR, 1997.

OCL (2006). Object Constraint Language. Version 2.0. OMG Available
Specification: formal/06-05-01. www.omg.org

UML (2006). Unified Modeling Language: Superstructure. Version 2.0. OMG
Specification: formal/05-07-04 www.omg.org