Did you create an aspect bean in the same @Configuration class? Here’s what the docs suggest: @Configuration @EnableAspectJAutoProxy public class AppConfig { @Bean public FooService fooService() { return new FooService(); } @Bean // the Aspect itself must also be a Bean public MyAspect myAspect() { return new MyAspect(); } }
In Spring 3.0 it can be specified by the proxyMode attribute of @Scope annotation: @Scope(value = “session”, proxyMode = ScopedProxyMode.INTERFACES)
As long as you have control of your AOP I think it’s efficient. We did have performance problems anyway, so by own reasoning we were not fully in control 😉 This was mostly because it’s important that anyone that writes aspects has full understanding of all the other aspects in the system and how they … Read more
Your method is not wrong, but there’s a better one. You have to cast to MethodSignature MethodSignature signature = (MethodSignature) joinPoint.getSignature(); Method method = signature.getMethod();
The aspect is applied to a proxy surrounding the bean. Note that everytime you get a reference to a bean, it’s not actually the class referenced in your config, but a synthetic class implementing the relevant interfaces, delegating to the actual class and adding functionality, such as your AOP. In your above example you’re calling … Read more
Joinpoint: A joinpoint is a candidate point in the Program Execution of the application where an aspect can be plugged in. This point could be a method being called, an exception being thrown, or even a field being modified. These are the points where your aspect’s code can be inserted into the normal flow of … Read more
You can get the Signature from a ProceedingJoinPoint and in case of a method invocation just cast it to a MethodSignature. @Around(“execution(public * *(..)) && @annotation(com.mycompany.MyAnnotation)”) public Object procede(ProceedingJoinPoint call) throws Throwable { MethodSignature signature = (MethodSignature) call.getSignature(); Method method = signature.getMethod(); MyAnnotation myAnnotation = method.getAnnotation(MyAnnotation.class); } But you should first add an annotation attribute. … Read more
You should combine a type pointcut with a method pointcut. These pointcuts will do the work to find all public methods inside a class marked with an @Monitor annotation: @Pointcut(“within(@org.rejeev.Monitor *)”) public void beanAnnotatedWithMonitor() {} @Pointcut(“execution(public * *(..))”) public void publicMethod() {} @Pointcut(“publicMethod() && beanAnnotatedWithMonitor()”) public void publicMethodInsideAClassMarkedWithAtMonitor() {} Advice the last pointcut that combines … Read more
It’s a limitation of Spring AOP (dynamic objects and cglib). If you configure Spring to use AspectJ to handle the transactions, your code will work. The simple and probably best alternative is to refactor your code. For example one class that handles users and one that process each user. Then default transaction handling with Spring … Read more
Spring-AOP Pros It is simpler to use than AspectJ, since you don’t have to use LTW (load-time weaving) or the AspectJ compiler. It uses the Proxy pattern and the Decorator pattern Spring-AOP Cons This is proxy-based AOP, so basically you can only use method-execution joinpoints. Aspects aren’t applied when calling another method within the same … Read more