spring aop @within not working correctly for custom annotation

Question

I have created a custom annotation for some logging purpose. This annotation is applied over spring jpa repository created in project by extending JpaRepository. So what is happening now is that for read methods it is working correctly but for save part @Around advice never get invoked. Below is my @Around advice

@Around("@within(com.myproject.annotations.RepoAware)")
public void log(final ProceedingJoinPoint jp){
  return log(jp,true);
}

my log method is taking one boolean argument on the basis of which i log something.Below is the repo code

@Repository
@RepoAware
public interface MyRepo extends JpaRepository<Student,Long>{
}

Now when i call repo method that is not part of my repository MyRepo like save, saveAll or specifically the method that exists in parent hierarchy then @Around advice not working. When i applied debugger then i can see that during save call proxy is of type CrudRepository. So when i override the save method in MyRepo.class it starts working. I am confused here because MyRepo eventually has CrudRepository extended through JpaRepository. Please let me know how to fix this or what i am doing wrong here.

Also provide help over how to use not expression in pointcut. Say for above example i want to target my all repositories except that have @RepoAware annotation. I created below advice but it's also not working.

@Around("target(org.springframework.data.jpa.repository.JpaRepository) and !@within(com.myproject.annotations.RepoAware)")
public Object logDBMetrics(final ProceedingJoinPoint pjp) throws Throwable {
        return log(pjp,false);
}

above advice get invoked also for repos that have @RepoAware annotation.

Thanks in advance !

Answer 1

The solution for a Spring AOP aspect, i.e. the proxy-based Spring-style AOP framework, looks like this, if you want to avoid runtime reflection:

@Pointcut(
  "execution(* (" +
  "@com.example.accessingdatajpa.CustomRepositoryAnnotation " +
  "org.springframework.data.repository.CrudRepository+" +
  ").*(..))"
)

This is targeting

• executions of any methods
• in any class where
  • the class is CrudRepository or one of its subclasses (+),
  • the class type is annotated by @CustomRepositoryAnnotation.

---

Update 2: A simpler, more generic version of the solution pointcut is:

@Pointcut("execution(* (@com.example.accessingdatajpa.CustomRepositoryAnnotation *..*).*(..))")

FYI, normally * instead of *..* should work as a simpler replacement for "any class in any package" in AspectJ syntax, but it seems that in this case it is not working.

---

What does not work and why:

• @within(CustomRepositoryAnnotation): The save*, findAll*, delete* methods are not defined in a class annotated by @CustomRepositoryAnnotation, but in CrudRepository.
• @target(CustomRepositoryAnnotation): Interface annotations are not inherited by implementing classes (therefore also not by dynamic proxies) in Java. This is a general JDK issue and unrelated to Spring or even Spring AOP. See my answer here, scroll down to the "update" section.

---

Update 1, answering questions asked in a comment:

@target(CustomRepositoryAnnotation) ... - how was you able to start application?

By excluding Spring packages as described in my answer here and also excluding final types from the JDK, which of course cannot subclassed and therefore not be be proxied either:

"@target(com.example.accessingdatajpa.CustomRepositoryAnnotation)"
    + " && !within(org.springframework..*) && !within(is(FinalType))"

But in this case, the pointcut does not match, because of what I explained above.

btw, it does not explain why target(MarkerInterface) does work, it seems that annotation support is broken in Spring AOP.

No, it is not broken, just your expectation that annotations be inherited by classes implementing annotated interfaces is wrong.

target(MarkerInterface) works, because the runtime type implements the interface, and therefore the pointcut matches. Class inheritance is not the same as annotation inheritance. Like it or not, the latter only exists to the limited degree explained in the answer I linked to and stated in the @Inherited javadoc.

Answer 2

AspectJ has very limited functionality in case of spring infrastructure, however it is possible to implement your requirements via advisors (please also check: Spring Advisor in Java using @Bean)

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.TYPE})
@Inherited
public @interface CustomRepositoryAnnotation {
}


@Component
public class CustomRepositoryAnnotationAdvisor extends AbstractPointcutAdvisor {

    private static final Logger log = LoggerFactory.getLogger(CustomRepositoryAnnotationAdvisor.class);

    private final Advice advice;

    private final Pointcut pointcut;

    public CustomRepositoryAnnotationAdvisor() {
        this.advice = new MethodInterceptor() {
            @Nullable
            @Override
            public Object invoke(@NonNull MethodInvocation invocation) throws Throwable {
                log.info("DemoAnnotationAdvisor: {}", invocation.getMethod().getName());
                return invocation.proceed();
            }
        };
        this.pointcut = new AnnotationMatchingPointcut(CustomRepositoryAnnotation.class, null, true);
    }

    @Override
    public Pointcut getPointcut() {
        return pointcut;
    }

    @Override
    public Advice getAdvice() {
        return advice;
    }

}

Demo project on GH

---

UPD.

Have performed some research on the topic and found a brilliant article about Spring and AspectJ pointcut designators

First of all, @within is not supposed to work in your case (intercepting superinterface methods) - you ought to use @target, unfortunately @target pointcut designator seems to be broken in Spring AOP: existence of advice with single @target pointcut causes spring to create CGLIB proxies for every bean, which is undesirable and even not possible (jdk classes, final classes, classes without public constructor, etc), attempt to narrow down the scope of advice also fails: for example spring does not apply advice @target(annotation) && target(JpaRepository) for unknown reason.

At second, in case of Spring APO & AspectJ it is possible to achieve your requirements via introducing marker interface and using target(marker interface) as poincut designator, however, I would prefer to stay clear of those puzzles.

Answer 3

I finally able to get it worked and below is the approach i used. Thanks to @Andrey B. Panfilov.

I created an marker interface which is extended by MyRepo and then in my around advice i used class type to check if it is assignable from that interface. If yes then log with true otherwise false.

@Around("target(org.springframework.data.jpa.repository.JpaRepository)")
public void log(final ProceedingJoinPoint jp){
  Class<?> clazz=MyRepoInterface.class;
  return clazz.isAssignableFrom(pjp.getTarget().getClass())?log(jp,true):log(pjp,false);
}

----
@Repository
public interface MyRepo extends JpaRepository<Student,Long>,MyRepoInterface{
}

-----
public interface MyRepoInterface{}

spring-aop behaviour is still unknown for some point cuts. Like using AND , NOT with expression doesn't seems to work. I tried several mentioned approaches but none of them worked.