JBoss.org Community Documentation
This rule is quite simple, it means that an advice that receives only a joinpoint bean
(@JoinPoint)
as its parameter will have a higher priority than another advice
that receives all other annotated parameters available (notice we are following the
annotation priority order just described).
In other words, the first OneAspect.after()
advice method will be chosen when
calling POJO.someMethod()
in this example:
public class POJO { String someMethod(String s){} } <aop> <aspect class="OneAspect"/> <bind pointcut="execution(* POJO->someMethod(..))"> <after aspect="OneAspect" name="after"/> </bind> </aop> public class OneAspect { public void after(@JoinPoint MethodJoinPoint mjp){} //1 public String after(@Target POJO pojo, @Return String ret, @Arg String arg0){} //2 }
Again in the following example, the first OneAspect.after()
advice method
will be chosen when calling POJO.someMethod()
. The first after()
advice method’s highest priority parameter is @Target
, the second advice parameter’s
highest priority parameter is @Return
, and @Target
has a higher
priority than @Return
:
public class POJO { String someMethod(String s){} } <aop> <aspect class="OneAspect"/> <bind pointcut="execution(* POJO->someMethod(..))"> <after aspect="OneAspect" name="after"/> </bind> </aop> public class OneAspect { public void after(@Target POJO pojo){} //1 public String after(@Return String ret, @Arg String arg0){} //2 }
In cases where the highest priority annotated parameter of two advice methods is
the same, we move on to the next highest priority annotated parameter of both advices.
In the following scenario, both OneAspect.after()
methods have the
@JoinPoint
parameter as the highest priority parameter. The first one
has a @Target
as its second-highest priority parameter while the second
one has @Return
as its second-highest priority parameter. Since
@Target
has a higher priority than @Return
, the first
OneAspect.after()
is chosen for POJO.someMethod()
.
public class POJO { String someMethod(String s){} } <aop> <aspect class="OneAspect"/> <bind pointcut="execution(* POJO->someMethod(..))"> <after aspect="OneAspect" name="after"/> </bind> </aop> public class OneAspect { public void after(@JoinPoint MethodJoinPoint mjp, @Target POJO pojo){} //1 public String after(@JoinPoint MethodJoinPoint mjp, @Return String ret){} //2 }
In the next example, the first OneAspect.before()
advice is chosen
over the second one when calling POJO.someMethod()
. The reason is that,
all else being equal, the first one matches more parameters:.
public class POJO { String someMethod(String s, int i){} } <aop> <aspect class="OneAspect"/> <bind pointcut="execution(* POJO->someMethod(..))"> <before aspect="OneAspect" name="before"/> </bind> </aop> public class OneAspect { public void before(@Arg String s, @Arg int i){} //1 public String before(@Arg String s){} //2 }
If the priority of annotated parameters using the presence criterion is the same on more than one advice, the next criterion, the assignability degree, is used.