mira mezini klaus ostermann
DESCRIPTION
Untangling Crosscutting Concerns with CAESAR. Mira Mezini Klaus Ostermann. Aspect-Oriented Software Development, 2004. Outline. 1. Requirements on Language Support. 3. The Caesar Model The observer pattern in Caesar. Related work. 2. JPI: Joint Point Interception approach - PowerPoint PPT PresentationTRANSCRIPT
Mira Mezini
Klaus Ostermann
Aspect-Oriented Software Development, 2004
Outline
3. The CaesarCaesar Model- The observer pattern in Caesar.
- Related work.
1. Requirements on Language Support
2. JPI: Joint Point Interception approach
- The “observer design patternobserver design pattern”.
- JPI deficiencies.
Relevant Concepts:
• “Tyranny of the dominant decomposition”.
• Cross-cutting models/concerns.
• Code scattering and tangling.
• JPI: the Joint-Point Interception approach.
The problem – an Example
The problem – an Example
The problem – an Example
The problem – an Example
The problem – an Example
Requirements on Language Support
1. Multi-Abstraction Aspect Modules
2. Aspect Composition
3. Reuse of Aspect Implementation and Bindings
4. Aspectual Polymorphism
Joint Point Interception
JPI approach has disadvantages.JPIs are still the main primitives of AOP.Higher level constructs are to be added
on top of JPIs and advices.
The problems with JPI are presented through the observer patternobserver pattern in AspectJ.
A Graphics Software System
PointPoint
…
……
ShapeShape
LineLine
ScreenScreen
The observer patternobserver pattern 1
Observer
Subject
Abstract Observer
ObserverObserver
SubjectSubject
Color Observer
The observer patternobserver pattern 2
public abstract aspect ObserverProtocol {
protected interface Subject { } protected interface Observer { }
private WeakHashMap perSubjectObservers;
protected List getObservers(Subject s) { if (perSubjectObservers == null) perSubjectObservers = new WeakHashMap(); List observers = (List) perSubjectObservers.get(s); if ( observers == null ) { observers = new LinkedList(); perSubjectObservers.put(s, observers); } return observers; }…
Declaring an Declaring an abstract abstract aspectaspect
public abstract aspectpublic abstract aspect ObserverProtocol { ObserverProtocol {
protected interface Subject { } protected interface Observer { }
private WeakHashMap perSubjectObservers;
protected List getObservers(Subject s) { if (perSubjectObservers == null) perSubjectObservers = new WeakHashMap(); List observers = (List) perSubjectObservers.get(s); if ( observers == null ) { observers = new LinkedList(); perSubjectObservers.put(s, observers); } return observers; }…
Marker Marker InterfacesInterfaces
public abstract aspectpublic abstract aspect ObserverProtocol { ObserverProtocol {
protected interface Subject { } protected interface Observer { }
private WeakHashMap perSubjectObservers;
protected List getObservers(Subject s) { if (perSubjectObservers == null) perSubjectObservers = new WeakHashMap(); List observers = (List) perSubjectObservers.get(s); if ( observers == null ) { observers = new LinkedList(); perSubjectObservers.put(s, observers); } return observers; }…
Hash FieldHash Field
public abstract aspectpublic abstract aspect ObserverProtocol { ObserverProtocol {
protected interface Subject { } protected interface Observer { }
private WeakHashMap perSubjectObservers;
protected List getObservers(Subject s) { if (perSubjectObservers == null) perSubjectObservers = new WeakHashMap(); List observers = (List) perSubjectObservers.get(s); if ( observers == null ) { observers = new LinkedList(); perSubjectObservers.put(s, observers); } return observers; }…
Allocating a Allocating a List of List of Observers Observers for any for any SubjectSubject
public abstract aspectpublic abstract aspect ObserverProtocol { ObserverProtocol {
protected interface Subject { } protected interface Observer { }
private WeakHashMap perSubjectObservers;
protected List getObservers(Subject s) { if (perSubjectObservers == null) perSubjectObservers = new WeakHashMap(); List observers = (List) perSubjectObservers.get(s); if ( observers == null ) { observers = new LinkedList(); perSubjectObservers.put(s, observers); } return observers; }…
The observer patternobserver pattern 3Adding and Adding and removing removing observersobservers
… public void addObserver(Subject s,Observer o){ getObservers(s).add(o); }
public void removeObserver(Subject s,Observer o){ getObservers(s).remove(o); }
abstract protected void updateObserver(Subject s, Observer o);
abstract protected pointcut subjectChange(Subject s);
after(Subject s) : subjectChange(s) { Iterator iter = getObservers(s).iterator(); while ( iter.hasNext() ) updateObserver(s, ((Observer)iter.next())); }}
Abstract Abstract membersmembers
… public void addObserver(Subject s,Observer o){ getObservers(s).add(o); }
public void removeObserver(Subject s,Observer o){ getObservers(s).remove(o); }
abstract protected void updateObserver(Subject s, Observer o);
abstract protected pointcut subjectChange(Subject s);
after(Subject s) : subjectChange(s) { Iterator iter = getObservers(s).iterator(); while ( iter.hasNext() ) updateObserver(s, ((Observer)iter.next())); }}
… public void addObserver(Subject s,Observer o){ getObservers(s).add(o); }
public void removeObserver(Subject s,Observer o){ getObservers(s).remove(o); }
abstract protected void updateObserver(Subject s, Observer o);
abstract protected pointcut subjectChange(Subject s);
after(Subject s) : subjectChange(s) { Iterator iter = getObservers(s).iterator(); while ( iter.hasNext() ) updateObserver(s, ((Observer)iter.next())); }}
AdviceAdvice
… public void addObserver(Subject s,Observer o){ getObservers(s).add(o); }
public void removeObserver(Subject s,Observer o){ getObservers(s).remove(o); }
abstract protected void updateObserver(Subject s, Observer o);
abstract protected pointcut subjectChange(Subject s);
after(Subject s) : subjectChange(s) { Iterator iter = getObservers(s).iterator(); while ( iter.hasNext() ) updateObserver(s, ((Observer)iter.next())); }}
public aspect ColorObserver extends ObserverProtocol{
declare parents: Point implements Subject;
declare parents: Line implements Subject;
declare parents: Screen implements Observer;
protected pointcut subjectChange(Subject s) :
( call ( void Point.setColor(Color)) ||
call ( void Line.setColor(Color)) ) && target(s);
protected void updateObserver(Subject s, Observer o) {
((Screen)o).display("Color change.");
}
}
The observer patternobserver pattern 4
public aspect ColorObserver extends ObserverProtocol{
declare parents: Point implements Subject;
declare parents: Line implements Subject;
declare parents: Screen implements Observer;
protected pointcut subjectChange(Subject s) :
( call ( void Point.setColor(Color)) ||
call ( void Line.setColor(Color)) ) && target(s);
protected void updateObserver(Subject s, Observer o) {
((Screen)o).display("Color change.");
}
}
Mark Mark Base Base ClassesClasses
public aspect ColorObserver extends ObserverProtocol{
declare parents: Point implements Subject;
declare parents: Line implements Subject;
declare parents: Screen implements Observer;
protected pointcut subjectChange(Subject s) :
( call ( void Point.setColor(Color)) ||
call ( void Line.setColor(Color)) ) && target(s);
protected void updateObserver(Subject s, Observer o) {
((Screen)o).display("Color change.");
}
}
Pointcuts Pointcuts Impl.Impl.
public aspect ColorObserver extends ObserverProtocol{
declare parents: Point implements Subject;
declare parents: Line implements Subject;
declare parents: Screen implements Observer;
protected pointcut subjectChange(Subject s) :
( call ( void Point.setColor(Color)) ||
call ( void Line.setColor(Color)) ) && target(s);
protected void updateObserver(Subject s, Observer o) {
((Screen)o).display("Color change.");
}
}
Aspect Aspect Impl.Impl.
public aspect ColorObserver extends ObserverProtocol{
declare parents: Point implements Subject;
declare parents: Line implements Subject;
declare parents: Screen implements Observer;
protected pointcut subjectChange(Subject s) :
( call ( void Point.setColor(Color)) ||
call ( void Line.setColor(Color)) ) && target(s);
protected void updateObserver(Subject s, Observer o) {
((Screen)o).display("Color change.");
}
}
Update Update Impl.Impl.
The observer patternobserver pattern 5Two primary advantages:1.1. ReusabilityReusability
ImplementationImplementation is separated from bindingbinding Implementation is reusable.
2.2. Independent ExtensibilityIndependent Extensibility Subject can be mapped to many classes. A class can be assigned many roles. The same role can be assigned to the same
class in different bindings.
Lack of Support for: Multiabstraction Aspects
• No separation of concerns in the aspect:– Contains all methods of all abstractions
defined in it. Contradicts OOP and AOP.– Fields and inheritance for the abstractions?
• AspectJ’s introduction mechanism leads to losing independent extensibility.
• No dynamic dispatch.
Lack of support for:Sophisticated Mapping
• Each abstraction must be mapped directly to some base class.
• This is not always the case:– Consider a graph aspect, defined in terms of
Node and Edge.– An application in which every Point has a
collection of adjacent points.– Edge cannot be mapped to any base class.
ObserverProtocolObserverProtocol
ColorObserverColorObserver
SoftwareSoftware
Lack of support for: Reusable Aspect Bindings
• Every aspect binding is coupled to one particular aspect implementation.
LocationObserverLocationObserver
ColorObserver ColorObserver 11
ColorObserver ColorObserver 22
ObserverProtocolObserverProtocol
SoftwareSoftware
Lack of support for:Aspectual Polymorphism
• Once the aspect is compiled together with the target package, the changes in the execution are determined.
• It is not possible to determine at runtime which implementation of the aspect to apply.
The The CaesarCaesar Model 1 Model 1
• ACIACI - Aspect Collaboration Interface:
An interface definition for aspects with An interface definition for aspects with multiple mutually recursive nested typesmultiple mutually recursive nested types.
• The purpose of ACI: decoupling aspect implementationsimplementations and aspect bindingsbindings.
• The modules are independently defined, but are indirectly connected.
The The CaesarCaesar Model 2 Model 2
A Software System
…
Observer
Subject
Observer ACI
ObserverObserver
SubjectSubject
Color Observer
Aspect Collaboration Interfaces 1
interface ObserverProtocol {
interface Subject {
provided void addObserver(Observer o);
provided void removeObserver(Observer o);
provided void changed();
expected String getState();
}
interface Observer {
expected void notify(Subject s);
}
}
Nested Nested SubjectSubject InterfaceInterface
interface ObserverProtocol {
interface Subject {
provided void addObserver(Observer o);
provided void removeObserver(Observer o);
provided void changed();
expected String getState();
}
interface Observer {
expected void notify(Subject s);
}
}
ExpectedExpectedMethodMethod
interface ObserverProtocol {
interface Subject {
provided void addObserver(Observer o);
provided void removeObserver(Observer o);
provided void changed();
expected String getState();
}
interface Observer {
expected void notify(Subject s);
}
}
ProvidedProvidedMethodsMethods
interface ObserverProtocol {
interface Subject {
provided void addObserver(Observer o);
provided void removeObserver(Observer o);
provided void changed();
expected String getState();
}
interface Observer {
expected void notify(Subject s);
}
}
Nested Nested ObserverObserver InterfaceInterface
interface ObserverProtocol {
interface Subject {
provided void addObserver(Observer o);
provided void removeObserver(Observer o);
provided void changed();
expected String getState();
}
interface Observer {
expected void notify(Subject s);
}
}
Abstract Abstract Observer Observer AspectAspect
interface ObserverProtocol {
interface Subject {
provided void addObserver(Observer o);
provided void removeObserver(Observer o);
provided void changed();
expected String getState();
}
interface Observer {
expected void notify(Subject s);
}
}
• The ObserverProtocol ACI has 2 nested, mutually recursive, ACIs.
• Determines impl./bindings relations:– provided: what the aspect should provide.– expected: required from the binding.
• The provided & expected facets are implemented in different modules.
• However, They are indirectly connected through the ACI.
Aspect Collaboration Interfaces 2
What do we gain?
1. An abstract aspect.
2. Aspect-related Interfaces that are “aware”
of each other and can collaborate.
3. A modularization of the problem.
4. No binding-specific members.
Aspect Collaboration Interfaces 3
Aspect Implementations 1
• An aspect implementation must implement all the providedprovided methods.
• The implementation class structure is the same as of the ACI structure.
• The implementation of the providedprovided methods can call the expectedexpected methods.
class ObserverProtocolImpl implements ObserverProtocol {
class Subject {
List observers = new LinkedList();
void addObserver(Observer o) { observers.add(o);}
void removeObserver(Observer o) { observers.remove(o); }
void changed() {
Iterator iter = observers.iterator();
while ( iter.hasNext() )
((Observer)iter.next()).notify(this);
}
}
}
Provided Provided MethodsMethods
class ObserverProtocolImpl implements ObserverProtocol {
class Subject {
List observers = new LinkedList();
void addObserver(Observer o) { observers.add(o);}
void removeObserver(Observer o) { observers.remove(o); }
void changed() {
Iterator iter = observers.iterator();
while ( iter.hasNext() )
((Observer)iter.next()).notify(this);
}
}
}
A Nested A Nested ClassClass
class ObserverProtocolImpl implements ObserverProtocol {
class Subject {
List observers = new LinkedList();
void addObserver(Observer o) { observers.add(o);}
void removeObserver(Observer o) { observers.remove(o); }
void changed() {
Iterator iter = observers.iterator();
while ( iter.hasNext() )
((Observer)iter.next()).notify(this);
}
}
}
Observer Observer AspectAspect
class ObserverProtocolImpl implements ObserverProtocol {
class Subject {
List observers = new LinkedList();
void addObserver(Observer o) { observers.add(o);}
void removeObserver(Observer o) { observers.remove(o); }
void changed() {
Iterator iter = observers.iterator();
while ( iter.hasNext() )
((Observer)iter.next()).notify(this);
}
}
}
Aspect Implementations 2
What do we gain?
1. Many kinds of ObserverObserver aspectsaspects, with a
common interface.
2. A modularization of the aspect.
3. No need for “global” members.
4. Still no binding-specific members.
Aspect Implementations 3
Aspect Bindings 1
• An aspect binding implements all the expectedexpected methods in the ACI.
• For each nested ACI there may be zero,one, or more nested bindings.
• Base objects are accessed through wrapperswrappers.
Aspect Bindings 2class ColorObserver binds ObserverProtocol {
class PointSubject binds Subject wraps Point {
String getState() { return "Point colored "+wrappee.getColor()}}
}
class LineSubject binds Subject wraps Line {
String getState() { return "Line colored "+wrappee.getColor(); }
}
class ScreenObserver binds Observer wraps Screen {
void notify(Subject s) {wrappee.display("Color changed: "+s.getState());}
}
after(Point p): (call(void p.setColor(Color))){
PointSubject(p).changed(); }
after(Line l): (call(void l.setColor(Color))){
LineSubject(l).changed(); }
}
AdvicesAdvices
class ColorObserver binds ObserverProtocol {
class PointSubject binds Subject wraps Point {
String getState() { return "Point colored "+wrappee.getColor()}}
}
class LineSubject binds Subject wraps Line {
String getState() { return "Line colored "+wrappee.getColor(); }
}
class ScreenObserver binds Observer wraps Screen {
void notify(Subject s) {wrappee.display("Color changed: "+s.getState());}
}
after(Point p): (call(void p.setColor(Color))){
PointSubject(p).changed(); }
after(Line l): (call(void l.setColor(Color))){
LineSubject(l).changed(); }
}
A “Binding”A “Binding”class ColorObserver binds ObserverProtocol {
class PointSubject binds Subject wraps Point {
String getState() { return "Point colored "+wrappee.getColor()}}
}
class LineSubject binds Subject wraps Line {
String getState() { return "Line colored "+wrappee.getColor(); }
}
class ScreenObserver binds Observer wraps Screen {
void notify(Subject s) {wrappee.display("Color changed: "+s.getState());}
}
after(Point p): (call(void p.setColor(Color))){
PointSubject(p).changed(); }
after(Line l): (call(void l.setColor(Color))){
LineSubject(l).changed(); }
}
Binding of Binding of ObserverObserver
class ColorObserver binds ObserverProtocol {
class PointSubject binds Subject wraps Point {
String getState() { return "Point colored "+wrappee.getColor()}}
}
class LineSubject binds Subject wraps Line {
String getState() { return "Line colored "+wrappee.getColor(); }
}
class ScreenObserver binds Observer wraps Screen {
void notify(Subject s) {wrappee.display("Color changed: "+s.getState());}
}
after(Point p): (call(void p.setColor(Color))){
PointSubject(p).changed(); }
after(Line l): (call(void l.setColor(Color))){
LineSubject(l).changed(); }
}
Binding of Binding of SubjectSubject
class ColorObserver binds ObserverProtocol {
class PointSubject binds Subject wraps Point {
String getState() { return "Point colored "+wrappee.getColor()}}
}
class LineSubject binds Subject wraps Line {
String getState() { return "Line colored "+wrappee.getColor(); }
}
class ScreenObserver binds Observer wraps Screen {
void notify(Subject s) {wrappee.display("Color changed: "+s.getState());}
}
after(Point p): (call(void p.setColor(Color))){
PointSubject(p).changed(); }
after(Line l): (call(void l.setColor(Color))){
LineSubject(l).changed(); }
}
What do we gain?
1. Interface can be bound in many ways.
2. A “Binding” is a module.
3. No need for “global” members.
4. No aspect-implementation specific
details.
Aspect Bindings 3
Wrapper Recycling
• Avoiding multiple wrappers for the same base object.
• Access to a base object is done through the wrapper:outerClassInstance.Wrapper(constructor_args)
• A wrapper may wrap a set of objects.
Most Specific Wrappers 1
A mechanism that determines the most specific wrapper for an object based on the object’s runtime type, when multiple nested binding classes with the same name are available.
Most Specific Wrappers 2class MovableFigures { class MovableFigure implements Movable wraps Figure { void moveBy(int x, int y) {}; } class MovableFigure implements Movable wraps Point { void moveBy(int x, int y) { wrappee.setX(wrappee.getX()+x); wrappee.setY(wrappee.getY()+y); } } class MovableFigure implements Movable wraps Line { void moveBy(int x, int y) { MovableFigure(wrappee.getP1()).moveBy(x,y); MovableFigure(wrappee.getP2()).moveBy(x,y); } }}
Most Specific Wrappers 3
class Test { MovableFigures mv = new MovableFigures(); void move(Figure f) { mv.MovableFigure(f).moveBy(5,7); }}
On a constructor/wrapper call, the dynamic type of the argument determines the actual nested binding to instantiate/recycle.
Pointcuts and Advices
• Supported similarly to AspectJ
• Part of the modular ACIs.
• A binding must be explicitly deployed.
The difference:
Compilation with pointcuts and advices Compilation with pointcuts and advices does notdoes not change the base class semantics change the base class semantics.
Weavelets and Deployment
• Weavelet: a composition of an implementation and a binding.
• A weavelet has to be deployed in order to activate its pointcuts and advices.
class CO extendsObserverProtocol<ColorObserver,ObserverProtocolImpl>{};
Weavelets 2What do we gain?
• Reusable aspect bindings.
• Reusable aspect implementations.
class CO1 extendsObserverProtocol<ColorObserver,ObserverProtocolImpl1>{};
class CO2 extendsObserverProtocol<ColorObserver,ObserverProtocolImpl2>{};
class CO3 extendsObserverProtocol<ColorObserver,ObserverProtocolImpl3>{};
class Obs1 extendsObserverProtocol<Observer1,ObserverProtocolImpl>{};
class Obs2 extendsObserverProtocol<Observer2,ObserverProtocolImpl>{};
class Obs3 extendsObserverProtocol<Observer3,ObserverProtocolImpl>{};
Static Deployment 1
• Pointcuts and advices of co weavelet are engaged only if it is deployed.
• Deployment takes place at loading time of Test.
class Test ... {
deploydeploy public static final CO co = new CO();
...
}
Static Deployment 2
• Weavelet access.
• Objects are accessed through the wrappers mechanism.
class Test{
deploydeploy public static final CO co = new CO();
void register(Point p, Screen s){
co.PointSubject(p).addObserver( co.ScreenObserver(s) );
}
Dynamic Deployment 1It is possible to decide dynamically which It is possible to decide dynamically which aspect implementation to deploy.aspect implementation to deploy.
class Logging { after(): (call(void Point.setX(int)) || call(void Point.setY(int)) ) { System.out.println("Coordinates changed"); }}
class VerboseLogging extends Logging { after(): (call(void Point.setColor(Color)) { System.out.println("Color changed"); }}
Dynamic Deployment 2class Main { public static void main(String args[]) { Logging log = null; Point p[] = createSamplePoints(); if (args[0].equals("-log")) log = new Logging(); else if (args[0].equals("-verbose")) log = new VerboseLogging(); deploy (l) { modify(p); } }
public static void modify(Point p[]) { p[3].setX(5); p[2].setColor(Color.RED); }}
What is the What is the type of type of loglog ? ?
class Main { public static void main(String args[]) { Logging log = null; Point p[] = createSamplePoints(); if (args[0].equals("-log")) log = log = newnew Logging(); Logging(); else if (args[0].equals("-verbose")) log = log = newnew VerboseLogging(); VerboseLogging(); deploy (l) { modify(p); } }
public static void modify(Point p[]) { p[3].setX(5); p[2].setColor(Color.RED); }}
Virtual Classes and Static Typing
All nested interfaces of a CI and all All nested interfaces of a CI and all classes that implement or bind such classes that implement or bind such interfaces, are virtual types/classesinterfaces, are virtual types/classes
Compatible with Java’s approach.
Caesar vs. Hyper/J
• Hyper/J: Independent hypersliceshyperslices, integrated by
composition rules (hypermodulehypermodule).
• Class-based. Can’t change individual objects.
• Lacks CI’s and reusable bindings: either the
modules are independent, or composition
becomes very complex.
• Composition language is not OO enough.
Caesar vs. Composition Filters
• CFs: filters for object’s in/out messages.
Integration through join points.
• CF have no mechanism for separating aspect
implementation from aspect bindings.
• No aspectual polymorphism.
• CFs are more declarative: good for some
kinds of concerns.
Current Status
• in caesarj.org
• “Very active on-going research”.
• The AORTA project.
• Industry: in www.topprax.de
– Applying aspect-oriented programming in
commercial software development
Conclusions• JPI alone does not suffice for a modular
structuring of aspects, resulting in tangled aspect code.
• Caesar enables:– Componentization of aspects.– Reusability of aspects bindings & implementations.– Polymorphic aspects usage.– Dynamic aspect deployment.
• Caesar is based on the notion of an ACI• ACIs can be applied to support a more modular
structuring of aspect code and better aspect reuse.