1 / 42

Mastering AspectJ: Introduction, Implementation, and Analysis

Learn about AspectJ, its structure, key concepts like Join Points and Advice, aspect encapsulation, pointcuts, advice forms, and context-passing aspects. Developed in 1998 at Xerox PARC, a versatile AOP tool for Java developers.

chaconn
Download Presentation

Mastering AspectJ: Introduction, Implementation, and Analysis

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  1. AspectJ John Sung

  2. Presentation Assumptions • Already know the concepts of AOP • Know the problem AOP is attempting to solve. • Have some knowledge of Java • Familiar with OOD

  3. Outline • Introduction to AspectJ • Structure Shyness with Context Passing • Implementing Branches with AspectJ • Conceptual Analysis of DJ, AspectJ, Fred • Master’s Thesis

  4. Introduction to AspectJ • Developed at Xerox PARC • Launched in August 1998 • Provide AOP tool to programmers • Build and support AspectJ community • Improve AspectJ and AOP

  5. Concepts of AspectJ • Join Points • Pointcuts • Advice • Aspect

  6. Highlevel View of AspectJ AspectJ Advice advice body pointcut join point Java Program

  7. Join Points • Transition points or boundaries • Method Call • Class Boundary • Method Execution • Access or Modification of member variable • Exception Handlers • Static and Dynamic Initialization

  8. Graphical View of Join Points bar bar1.foo(); int x; foo(){ x = 0; if (x < 0) throw KException; }

  9. Specifying Join Points with Designators • call(method signature) • handler(exception name) • cflow(join point designator) • this(type name) • target(type name) • within(class name) • execution(method signature) • get(signature), set(signature) • initialization(signature), staticinitialization(type name)

  10. Designators with Wildcards • call(* foo()) • call(public bar.*(..)) • call(void foo(..)) • call(* *(..)) • call(*.new(int, int)) • handler(File*Exception)

  11. Pointcuts • Set of join points • Treats pointcut designators as predicates • Can use &&, || , and ! predicate modifiers • Allows parameter passing from pointcut to the advice

  12. Generic Pointcuts pointcut name(args) : pointcut_designators;

  13. Pointcut Examples • pointcut MemberRead() : call(* *get*(..)) || call( * *Get*(..)); • pointcut MemberReadOrWrite(): MemberRead() || call(* *set*(..)) || call(* *Set*(..)); • pointcut A1(int t2, String m1): !target(t2) && (call(* c*.foo*(..)) || * get(m1));

  14. Advice • Action to take when pointcut holds • Advice Forms • before(param) : pointcut(param) {body} • after(param) : pointcut(param) {body} • after(param) returning []: pointcut(param) {body} • after(param) throwing []: pointcut(param) {body} • type around(param) [throws typelist] : pointcut(param) {body}

  15. Advice Examples • before() : MemberRead() {...} • after() : MemberReadOrWrite() {..} • before(): MemberRead() && within(Lock) {..}

  16. Parameter Information Flow Advice Body Advice Pointcut Join Point Designator

  17. Parameter Example before(int index) : MemberRead(index) { System.out.println(index); } pointcut MemberRead(int index) : args(index) && (call(*get*(..)) || call(*Get*(..)));

  18. Introduction • Additions to a class • Data members • Methods • Inheritance and Interface Specification • Easy to group different concerns within a program into aspects • Structure • Collaborations

  19. Introduction Examples • public int foo.bar(int x); • private int foo.counter; • declare parents: mammal extends animal; • declare parents: MyThread implements MyThreadInterface;

  20. Aspect • Encapsulates an aspect • Looks like a class definition in java • aspect aspect_name { ... } • Abstract aspects

  21. Reflection in AspectJ • thisJoinPoint • Similar to “this” in Java • Able to find various information about the join point that triggered the advice.

  22. thisJoinPoint Example • thisJoinPoint.toString() • thisJoinPoint.getArgs() aspect TraceNonStaticMethods { before(Point p): target(p) && call(* *(..)) { System.out.println("Entering " + thisJoinPoint + " in " + p); } }

  23. Structure Shyness with Context Passing • Need to add functionality to a method • Need to add context to do it • Traditional method • change signature of method or overload • change method body or add method body

  24. caller1 Service caller2 worker2 worker1 worker3 example – context passing • workers need to know the caller: • capabilities • charge backs • to customize result

  25. caller1 Service caller2 worker2 worker1 worker3 context-passing aspects • workers need to know the caller: • capabilities • charge backs • to customize result

  26. context-passing aspects pointcut invocations(Caller c): this(c) && call(void Service.doService(String));

  27. context-passing aspects pointcut invocations(Caller c): this(c) && call(void Service.doService(String)); pointcut workPoints(Worker w): target(w) && call(void Worker.doTask(Task));

  28. context-passing aspects pointcut invocations(Caller c): this(c) && call(void Service.doService(String)); pointcut workPoints(Worker w): target(w) && call(void Worker.doTask(Task)); pointcut perCallerWork(Caller c, Worker w): cflow(invocations(c)) && workPoints(w);

  29. context-passing aspects abstract aspect CapabilityChecking { pointcut invocations(Caller c): this(c) && call(void Service.doService(String)); pointcut workPoints(Worker w): target(w) && call(void Worker.doTask(Task)); pointcut perCallerWork(Caller c, Worker w): cflow(invocations(c)) && workPoints(w); before (Caller c, Worker w): perCallerWork(c, w) { w.checkCapabilities(c); } }

  30. Branches using AspectJ • AspectJ have similar concepts as Fred • Predicates on method calls and arguments • Bodies to be executed

  31. Factorial in Fred x (define-msg fact) fact x-1 (define-branch (and (eq? (dp-msg dp) fact) (= (car (dp-args dp)) 1)) 1) x==1 return 1 (define-branch (eq? (dp-msg dp) fact) (let ((x (car (dp-args dp)))) (* x (fact (- x 1))))) x $ *

  32. Branches in AspectJ AspectJ Base Advice Recursion Advice x-1 if (x>1) if (x==1) Initial Call FactClass.fact(int x) Java Program

  33. Branches in AspectJ class FactClass {} aspect FactExample { static int factReturn; static int FactClass.fact(int x) { return factReturn; } pointcut factRecursion(int x): args(x) && call(static int FactClass.fact(int)) && if (x > 1); pointcut factBase(int x): args(x) && call(static int FactClass.fact(int)) && if(x==1); before(int x) : factRecursion(x) { System.out.print("recurse x = "); System.out.println(x); factReturn = x * FactClass.fact(x-1); } before(int x) : factBase(x) { System.out.print("base x = "); System.out.println(x); factReturn = 1; } }

  34. Conceptual Analysis • Why can I implement Branches in AspectJ? • Taking a look at DJ, AspectJ and Branches • Describe different concepts used • Relationships between concepts • Possible future directions

  35. Conceptual Breakdown • DJ • Traversals, Advice, Strategy Graph, Class Graph, Visitor, Incremental Behavior • AspectJ • Introduction, Predicated Execution, Advice, Incremental Behavior • Branches • Incremental Behavior , Predicated Execution

  36. Logical View of Concepts DJ Traversal Strategy Graph Visitor Class Graph AspectJ Advice Incremental Behavior Introduction Predicated Execution Branches

  37. DJ Conceptual Application • Concepts applied to data structure • Concepts have bigger scope • Things are applied to bigger groups • Incrementally add visitors

  38. AspectJ Conceptual Application • Introduction of almost anything within a java class • Allows very flexible grouping of program • Predicated execution on control flow • Incrementally add aspects

  39. Branches Conceptual Application • Each node is a function call • Each exit from a node is a branch • Predicated execution based on arguments on a branch • Introduction of Branches and nodes • Incrementally add functions and branches

  40. Conceptual Application Traversal Data Structure Visitor DJ Strategy Graph Algorithms Class Graph Control Flow Advice AspectJ Java Elements Incremental Behavior Function Call Branches Predicated Execution Introduction

  41. Master’s Thesis • Attempt to implement AOP concepts using different AOP tools • Mix different AOP tools together • Generalized view of AOP tools and concepts

  42. AspectJ Resources • www.AspectJ.org • downloads, documentation, articles, examples • aosd.net • collection of AO software development

More Related