Aspect-oriented programming is a way of modularizing crosscutting concerns much like object-oriented programming is a way of modularizing common concerns. AspectJ is an implementation of aspect-oriented programming for Java
A join point is a well-defined point in the program flow. A pointcut picks out certain join points and values at those points. A piece of advice is code that is executed when a join point is reached. These are the dynamic parts of AspectJ.
AspectJ's aspect are the unit of modularity for crosscutting concerns. They behave somewhat like Java classes, but may also include pointcuts, advice and inter-type declarations.
AspectJ provides for many kinds of join points, but this chapter discusses only one of them: method call join points. A method call join point encompasses the actions of an object receiving a method call. It includes all the actions that comprise a method call, starting after all arguments are evaluated up to and including return (either normally or by throwing an exception). when a particular method body executes execution(void Point.setX(int)) when a method is called call(void Point.setX(int)) when an exception handler executes handler(ArrayOutOfBoundsException) when the object currently executing (i.e. this) is of type SomeType this(SomeType) when the target object is of type SomeType target(SomeType) when the executing code belongs to class MyClass within(MyClass) when the join point is in the control flow of a call to a Test's no-argument main method cflow(call(void Test.main()))
Pointcuts compose through the operations or ("||"), and ("&&") and not ("!"). * It is possible to use wildcards. So 1. execution(* *(..)) 2. call(* set(..)) means (1) the execution of any method regardless of return or parameter types, and (2) the call to any method named set regardless of return or parameter types -- in case of overloading there may be more than one such set method; this pointcut picks out calls to all of them. * You can select elements based on types. For example, 3. execution(int *()) 4. call(* setY(long)) 5. call(* Point.setY(int)) 6. call(*.new(int, int)) means (1) the execution of any method with no parameters that returns an int, (2) the call to any setY method that takes a long as an argument, regardless of return type or declaring type, (3) the call to any of Point's setY methods that take an int as an argument, regardless of return type, and (4) the call to any classes' constructor, so long as it takes exactly two ints as arguments. * You can compose pointcuts. For example, 7. target(Point) && call(int *()) 8. call(* *(..)) && (within(Line) || within(Point)) 9. within(*) && execution(*.new(int)) 10. !this(Point) && call(int *(..)) means (1) any call to an int method with no arguments on an instance of Point, regardless of its name, (2) any call to any method where the call is made from the code in Point's or Line's type declaration, (3) the execution of any constructor taking exactly one int argument, regardless of where the call is made from, and (4) any method call to an int method when the executing object is any type except Point. * You can select methods and constructors based on their modifiers and on negations of modifiers. For example, you can say: 11. call(public * *(..)) 12. execution(!static * *(..)) 13. execution(public !static * *(..)) which means (1) any call to a public method, (2) any execution of a non-static method, and (3) any execution of a public, non-static method. * Pointcuts can also deal with interfaces. For example, given the interface * ------------------------------------------------- interface MyInterface { ... } the pointcut call(* MyInterface.*(..)) picks out any call to a method in MyInterface's signature -- that is, any method defined by MyInterface or inherited by one of its a supertypes. call vs. execution
When methods and constructors run, there are two interesting times associated with them. That is when they are called, and when they actually execute.
AspectJ exposes these times as call and execution join points, respectively, and allows them to be picked out specifically by call and execution pointcuts.
So what's the difference between these join points? Well, there are a number of differences:
Firstly, the lexical pointcut declarations within and withincode match differently. At a call join point, the enclosing code is that of the call site. This means that call(void m()) && withincode(void m()) will only capture directly recursive calls, for example. At an execution join point, however, the program is already executing the method, so the enclosing code is the method itself: execution(void m()) && withincode(void m()) is the same as execution(void m()).
Secondly, the call join point does not capture super calls to non-static methods. This is because such super calls are different in Java, since they don't behave via dynamic dispatch like other calls to non-static methods.
The rule of thumb is that if you want to pick a join point that runs when an actual piece of code runs (as is often the case for tracing), use execution, but if you want to pick one that runs when a particular signature is called (as is often the case for production aspects), use call.