Features of AOP languages - PowerPoint PPT Presentation

features of aop languages n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Features of AOP languages PowerPoint Presentation
Download Presentation
Features of AOP languages

play fullscreen
1 / 76
Features of AOP languages
117 Views
Download Presentation
lilah-buckner
Download Presentation

Features of AOP languages

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

  1. 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)

  2. 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) JPS and BJP are sometimes overlapping. JPS might already define an initial behavior plus a set of join points in that behavior.

  3. Comparing • AspectJ • DemeterJ • DJ • ATC • AspectC • Aspectual Collaborations • D (COOL, RIDL) • BETA • RG

  4. AspectJ • from Xerox PARC

  5. 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?

  6. 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.

  7. 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()

  8. AspectJ CSB • an aspect contains a list of advice and point cut declarations and introductions and regular fields and methods.

  9. 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)

  10. AspectJ AU • ajc takes a list of files: aspects and classes and weaves them together.

  11. DemeterJ • From Northeastern

  12. DemeterJ JPM • traversal method calls on Java object, constructor calls

  13. DemeterJ JPS • strategies • define family of traversal programs to be enhanced • approximation: function mapping object graphs to subgraphs • are enhanced by visitors • sentences • define family of Java objects: executions of constructor calls • are not further enhanced

  14. DemeterJ BJP • visitor classes • before *

  15. DemeterJ CSB • adaptive methods • void f() to S (V1, V2)

  16. DemeterJ AU • make new .beh file, add to .prj file, demeterj

  17. DJ • Java library from Northeastern • Present two views of DJ as an AOP system • Two views • object graphs as join points • object graph slices as join points

  18. DJ JPM • object graph : nodes and edges • principled points: traversal of nodes or edges • fix a traversal algorithm

  19. DJ JPS • strategies • define family of traversal programs to be enhanced • approximation: function mapping object graphs to subgraphs (object graph slices)

  20. 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)

  21. DJ CSB • aspectual methods void f(ClassGraph cg) { cg.traverse(this, “from A to S”, new Visitor() {…});}

  22. DJ AU • add methods to classes

  23. DJ: Second view: Doug • Doug Orleans

  24. DJ JPM • object graph slices: nodes and edges • fix a traversal algorithm

  25. 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

  26. DJ BJP • visitor classes • each visitor method is advice on the point cut specified by the method signature

  27. 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)

  28. DJ AU • to attach an aspect you call traverse with an aspect (visitor). • traverse expression attaches the aspect to an object graph slice.

  29. AspectC • From the University of BC

  30. AspectC JPM • function calls, variable references • data available: args to function calls

  31. 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 !

  32. AspectC BJP • before, after, around

  33. AspectC CSB • are hardwired together: when advice is given, you need to give point cut

  34. AspectC AU • concatenated to the source

  35. ATC • From Doug Orleans at Northeastern

  36. ATC JPMAspects in Tiny CLOS • generic function receptions, method executions • use MOP to implement aspects • what data is exported: see join point object

  37. 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)

  38. ATC BJP • before, after, around: take aspect instance and join point object as argument. • around has third arg: continuation • generic function ...

  39. 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>

  40. 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)

  41. 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)

  42. Aspectual Collabs • From NU

  43. join point model allows for parameterization; join point patterns and their instances.

  44. 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?

  45. Aspectual Collaborations JPM • syntactic methods and fields, not points of execution • Replacement allows us to capture execution • Two kinds of method capture • tradeoff between access to arguments/result vs. generality

  46. 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. • adapter specifies links between methods and fields • requirements can be exported unfulfilled. • future version: globbing with guard operators

  47. Aspectual Collaborations BJP • before, after, around: for methods • can refer to actual parameters • in replace (around (instead of)) can say: expected() • Depending on which join point model: can access/modify aguments or cannot.

  48. Aspectual Collaborations CSB • collaborations and adapters • Each adapter is processed to generate a new collaboration. Collaborations can encapsulate some behavior and export other.

  49. AC instances • Complicated sharing model • ?

  50. Aspectual Collaborations AU • ac-compiler (non existent) takes a list of files: classes and collaborations and adapters and weaves them together. • Weaving is incremental. Compilation is external to weaving. • Process is finished when no more requirements remain.