420 likes | 516 Views
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)
E N D
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 methods void f(ClassGraph cg) { cg.traverse(this, “from A to S”, new Visitor() {…});}
DJ AU • add methods to classes
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