Features of AOP languages
• AOP languages have the following main elements: – a join point model (JPM) wrt base PL
– a specification language for expressing sets of join points (JPS)
– a means of specifying behavior involving join points (BJP)
– encapsulated units combining JPS and BJP (CSB)
– method of attachment of units to base program (AU)
Comparing
• AspectJ
• DemeterJ
• DJ
• ATC
• AspectC
AspectJ JPM
• principled points of execution– message sends (basically a method call),
message receptions, method executions– field references (get and set)– exception throwing and handling– constructor execution
• which context is available at each join point?
AspectJ JPS
• pointcut designators– primitive: calls(sig), receptions(sig), executions(sig),
instanceof(type), within(type), cflow(pcd), getter(sig?), setter(sig?)
– operators: &&, ||, !
• can name a pointcut and expose context– pointcut foo (V v):pcd (using v);
• pointcut maybe abstract (declaration) and defined in a subaspect.
AspectJ BJP
• before, after, around: a pointcut.
• can refer to thisJoinPoint– explain join point object:
• instance of JoinPoint class. Interface: getSignature(), getActualParameters(),…
• JoinPoint has eleven subclasses: CallJoinPoint, ReceptionJoinPoint, ExecutionJoinPoint, ExceptionJoinPoint, …
• in around (instead of) can say: proceed()
AspectJ CSB
• an aspect contains a list of advice and point cut declarations and introductions and regular fields and methods.
Explaining aspect instance
• when you declare an aspect, you say either of eachJVM() or of eachobject(pcd)
• logging: log stream put in aspect instance of each VM (one instance for whole program)
• dft: mark field put it in aspect instance of each object (node object of the graph)
AspectJ AU
• ajc takes a list of files: aspects and classes and weaves them together.
DemeterJ JPM
• traversal method calls on Java object, constructor calls
DemeterJ JPS
• strategies
– define family of traversal programs to be enhanced
– approximation: function mapping object graphs to subgraphs
• sentences
– define family of Java objects: executions of constructor calls
DemeterJ BJP
• visitor classes– before *
DemeterJ CSB
• adaptive methods– void f() to S (V1, V2)
DemeterJ AU
• make new .beh file, add to .prj file, demeterj
DJ JPM
• object graph : nodes and edges
• principled points: traversal of nodes or edges
• fix a traversal algorithm
DJ JPS
• strategies
– define family of traversal programs to be enhanced
– approximation: function mapping object graphs to subgraphs (object graph slices)
DJ BJP
• visitor classes– before(A a), after(C c), cbefore_x(Object a,
Object b), caround_x(Object a, Object b, Subtraverser st)
– each method applies to a different part of the point cut (strategy)
DJ CSB
• aspectual methodsvoid f(ClassGraph cg) {
cg.traverse(this,
“from A to S”,
new Visitor() {…});}
DJ AU
• add methods to classes
DJ: Second view: Doug
DJ JPM
• object graph slices: nodes and edges
• fix a traversal algorithm
DJ JPS
• strategies
– define family of traversal programs to be enhanced
– approximation: function mapping object graphs to subgraphs (object graph slices)
• in addition: visitor methods are pointcut designators
• pointcut designators are encoded in signatures of visitor methods
DJ BJP
• visitor classes– each visitor method is advice on the point cut
specified by the method signature
DJ CSB
• a visitor class is a package of advice
• when you use a visitor in a traversal of an ogs (in traverse) then each pointcut is intersected with the traversal pointcut, namely cflow(traverse). (can also use within)
DJ AU
• to attach an aspect you call traverse with an aspect (visitor).
• traverse expression attaches the aspect to an object graph slice.
AspectC JPM
• function calls, variable references
• data available: args to function calls
AspectC JPS
• point cut designators– call (foo( c )): all calls of function foo with one
argument
– cflow( any point cut designator): “whatever comes afterwards on the stack”
– varref(name)
– combine with && , || and !
AspectC BJP
• before, after, around
AspectC CSB
• are hardwired together: when advice is given, you need to give point cut
AspectC AU
• concatenated to the source
ATC JPMAspects in Tiny CLOS
• generic function receptions, method executions
• use MOP to implement aspects
• what data is exported: see join point object
ATC JPS !
• point cut designators– predicate on aspect instance and join point object
– explain join point object:• instance of <join-point> class. Interface: slots: generic (generic
function being called), args (actual parameters), stack (stack of join points in current control flow)
• <join-point> has two subclasses: <reception-join-point> and <execution-join-point>
• <execution-join-point> has additional slot: method (being executed)
• (all the traversal methods in the cflow of the first traversal call)
ATC BJP
• before, after, around: take aspect instance and join point object as argument.
• around has third arg: continuation
• generic function ...
ATC CSB
• advice has a pointcut generic function (like an abstract pointcut in AspectJ). Methods of generic function are specified separately.
• an aspect contains a list of advice (no point cut declaration)
• an aspect is an instance of <aspect>
Explaining aspect instance
• class <aspect> has two subclasses: <aspect-of-each-vm> <aspect-of-each-object >
• logging: log stream put in aspect instance of each VM (one instance for whole program)
• dft: mark field put it in aspect instance of each object (node object of the graph)
ATC AU !
• <aspectizable> mixin: has slot aspects: holds list of attached aspects
• <aspectizable-generic> is a subclass of both <generic> and <aspectizable> (<generic> is the class of all generic functions)
• add-aspect! , remove-aspect!
• all generic functions in base program are aspectizable (non-obliviousness ok)
Aspectual Collaborations JPM
• principled points of execution– abstract join points that are mapped by the
adapter to concrete ones– execution of methods modified by collaboration
• enhance the class graph: open classes: add more members to existing classes
• which context is available at each join point?
Aspectual Collaborations JPS
• sets of join points: collaboration + adapter (in the adapters we express the cross cutting)
• collaboration roles only: have the flavor of an abstract pointcut.
Aspectual Collaborations BJP
• before, after, around: for methods
• can refer to actual parameters
• in replace (around (instead of)) can say: expected()
Aspectual Collaborations CSB
• collaborations and adapters
Aspectual Collaborations AU
• ac-compiler (non existent) takes a list of files: classes and collaborations and adapters and weaves them together.
Using AspectJ to implement collaborations/adapters
• AspectJ can only express the adapted collaborations
• AspectJ supports interfaces with full methods and multiple inheritance
Goal
• Input: classes, collaborations, adapters
• Output: AspectJ code