Spring Advisor in Java using @Bean

Question

I'm wondering if it's okay to create my own Spring Advisor via Java configuration, similar to what's proposed here. I too wanted to have annotated methods intercepted.

I had such an Advisor defined in our application, but after removing a completely unrelated @Configuration class, the whole thing collapsed and the advice no longer worked. After a lot of debugging, I figured that this could work

@Bean
@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
public Advisor sessionContextAdvisor(OpenSessionInterceptor openSessionInterceptor)
{
    AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
    pointcut.setExpression("@annotation(my.app.SessionContext)");
    return new DefaultPointcutAdvisor(pointcut, openSessionInterceptor);
}

and indeed, that worked. I needed to declare the bean as an infrastructure bean @Role(BeanDefinition.ROLE_INFRASTRUCTURE) for Spring. I gotta say, this feels even more hackey now.

On the other hand, there is a way to add custom Advisors via XML, using <aop:advisor> ..., as documented in the Spring docs. But I couldn't find a Spring-documented way to register an Advisor via Java configuration.

Also, Spring JavaDoc has to say this about the Advisor interface:

This interface is not for use by Spring users, but to allow for commonality in support for different types of advice.

That doesn't sound like you're supposed to create instances of this interface. But if there's an XML-way, is there really no Java configuration way to achieve the same thing? Is my solution not so bad after all?

Answer 1

Any aop-specific Java configuration for Advisor beans is not required (except @EnableAspectJAutoProxy) cause spring-aop discovers such beans via BeanFactory, please check org.springframework.aop.framework.autoproxy.BeanFactoryAdvisorRetrievalHelper

As regards to the question whether is it legitimate to use custom Advisor beans or not - just think about why @Transactional and @Cacheable are not implemented via @Aspect or check the example below:

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

public interface DemoAnnotationApi {

    @DemoAnnotation
    default void method1() {

    }

    @DemoAnnotation
    void method2();

    void method3();

}

@Component
public class DemoAnnotationImpl implements DemoAnnotationApi {

    @Override
    public void method2() {

    }

    @DemoAnnotation
    @Override
    public void method3() {

    }
}

@Aspect
@Component
public class DemoAnnotationAspect {

    @Pointcut("@annotation(DemoAnnotation)")
    public void annotated() {
        // nop - pointcut
    }

    @Around("annotated()")
    public Object invoke(ProceedingJoinPoint pjp) {
        return doProceed(pjp);
    }

    @SneakyThrows
    protected Object doProceed(ProceedingJoinPoint pjp) {
        System.out.println("\tDemoAnnotationAspect: " + pjp.getSignature().getName());
        return pjp.proceed();
    }

}

@Component
public class DemoAnnotationAdvisor extends AbstractPointcutAdvisor {

    private final Advice advice;

    private final Pointcut pointcut;

    public DemoAnnotationAdvisor() {
        this.advice = new MethodInterceptor() {
            @Nullable
            @Override
            public Object invoke(@Nonnull MethodInvocation invocation) throws Throwable {
                System.out.println("\tDemoAnnotationAdvisor: " + invocation.getMethod().getName());
                return invocation.proceed();
            }
        };
        this.pointcut = new AnnotationMatchingPointcut(null, DemoAnnotation.class, true);
    }

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

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

@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class DemoAnnotationTestIT {

    @Autowired
    DemoAnnotationApi api;

    @Test
    void test() {
        System.out.println("Calling method1");
        api.method1();
        System.out.println("Calling method2");
        api.method2();
        System.out.println("Calling method3");
        api.method3();
    }

}

output:

Calling method1
    DemoAnnotationAdvisor: method1
    DemoAnnotationAspect: method1
Calling method2
    DemoAnnotationAdvisor: method2
Calling method3
    DemoAnnotationAdvisor: method3
    DemoAnnotationAspect: method3