Avoid recursive AOP - spring

Question

I have an Aspect that intercepts a method a() decorated with the annotation #Foo. This method
calls another method b() also decorated with the annotation #Foo. I want my aspect to intercept
only a() and not b(). How can I do this?
I have tried within() but with no success. With ThreadLocal it works but I am wondering
if there is a Spring solution.
#Component
#Order(value = 2)
#Aspect
public class FooAspect {
#Around(value = "#annotation(Foo)")
public Object aroundAdvice(ProceedingJoinPoint pjp, Foo foo) {
...
}
}

Answer 1

I don't think there is a way to do that with Aspects only. The interception will happen no matter what.
However, one solution is to use a ThreadLocal Byte to flag that you've already applied the advice.
private ThreadLocal<Byte> flag = new ThreadLocal<>();
#Around(value = "#annotation(Foo)")
public Object aroundAdvice(ProceedingJoinPoint pjp, Foo foo) throws Throwable {
if (flag.get() == null) {
try {
flag.set((byte) 1); // or 0, whatever
// apply advice
return pjp.proceed();
} finally {
flag.remove();
}
} else {
// don't apply advice
return pjp.proceed();
}
}
You'll need to catch or throws the Throwable thrown from proceed().

Answer 2

There is a cflow like poincut in the framework, but it's not supported by Aspectj-style.
However you can use it with aop-schema configuration approach.
For example:
public class NotInFlowPoincut extends AspectJExpressionPointcut {
private ControlFlowPointcut cflow;
private Class<?> flowClass;
private String methodName;
public NotInFlowPoincut() {
}
#PostConstruct
public void init() {
cflow = new ControlFlowPointcut(flowClass, methodName);
}
#Override
public boolean matches(Method method, Class targetClass, Object[] args) {
return super.matches(method, targetClass, args) && ! cflow.matches(method, targetClass, args);
}
public Class<?> getFlowClass() {
return flowClass;
}
public void setFlowClass(Class<?> flowClass) {
this.flowClass = flowClass;
}
public String getMethodName() {
return methodName;
}
public void setMethodName(String methodName) {
this.methodName = methodName;
}
}
public class FooAspect {
public Object aroundAdvice(ProceedingJoinPoint pjp, Foo foo) throws Throwable {
System.out.println("in aroundAdvice");
return pjp.proceed();
}
public static void main(String[] args) {
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("/context.xml");
A a = ctx.getBean(A.class);
a.a();
B b = ctx.getBean(B.class);
b.b();
}
}
public class A {
#Autowired B b;
#Foo
public void a() {
System.out.println("In a()");
b.b();
}
}
public class B {
#Foo
public void b() {
System.out.println("In b()");
}
}
And finally
<bean id="cflow" class="test.NotInFlowPoincut">
<property name="expression" value="#annotation(foo) " />
<property name="methodName" value="aroundAdvice" />
<property name="flowClass" value="test.FooAspect" />
</bean>
<bean id="foo" class="test.FooAspect" />
<bean id="a" class="test.A" />
<bean id="b" class="test.B" />
<aop:config proxy-target-class="true">
<aop:aspect ref="foo" >
<aop:around method="aroundAdvice" pointcut-ref="cflow" />
</aop:aspect>
</aop:config>
Will output:
in aroundAdvice
In a()
In b()
in aroundAdvice
In b()
That seems to be what you are looking for.
Note that cflow poincut is slow, see javadoc.