Short Answer Don’t iterate through all the loaded classes from Instrumentation. Instead, just examine the class name passed in to the transformer and if it matches your target class, then transform it. Otherwise, simply return the passed classfileBuffer unmodified. Make the set up calls outside the transformer, (i.e. in your case, do the following from … Read more
Let’s imagine you want to log the time taken by some annoted methods using a @LogExecTime annotation. I first create an annotation LogExecTime: @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.METHOD) public @interface LogExecTime { } Then I define an aspect: @Component // For Spring AOP @Aspect public class LogTimeAspect { @Around(value = “@annotation(annotation)”) public Object LogExecutionTime(final ProceedingJoinPoint joinPoint, final LogExecTime … Read more
Why “vs”? It is not “vs”. You can use Aspect Oriented programming in combination with functional programming, but also in combination with Object Oriented one. It is not “vs”, it is “Aspect Oriented Programming with Object Oriented Programming”. To me AOP is some kind of “meta-programming”. Everything that AOP does could also be done without … Read more
Spring AOP can only be applied to Spring-managed components/beans, not to non-Spring POJOs. If you want to apply AOP to non-Spring classes you need AspectJ, not a proxy-based “AOP lite” framework like Spring AOP. For more information about how to use AspectJ (which does not need Spring at all) in combination with Spring and how … Read more
Turns out that there is an org.aspectj.lang.Aspects class to provide for specifically this purpose. It appears that the aspectOf() method is added by the LTW which is why it works fine in XML configuration, but not at compile time. To get around this limitation, org.aspectj.lang.Aspects provides a aspectOf() method: @Bean public com.xyz.profiler.Profiler profiler() { com.xyz.profiler.Profiler … Read more
I believe you have to implement an around advice, instead of a before advice. Because you can use proceed with your new arguments: proceed(newArgs);
You cannot bind an argument at an arbitrary position via args() in AspectJ because this could lead to ambiguity. Just imagine you have two or more parameters of the same type (or annotated by the same annotation type in this case). Which one of them should be bound to the named args() parameter? So while … Read more
It’s possible to have advice on annotated controllers. I assume you want to advice after execution of all methods in classes annotated with @Controller. Here’s an example: import org.aspectj.lang.annotation.AfterReturning; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; @Aspect public class ControllerAspect { @Pointcut(“within(@org.springframework.stereotype.Controller *)”) public void controllerBean() {} @Pointcut(“execution(* *(..))”) public void methodPointcut() {} @AfterReturning(“controllerBean() && methodPointcut() “) public … Read more
Jamis Buck, who wrote Copland and Needle, posted here about Needle, dependency injection and their usefulness in a Ruby world. It’s long but worth reading, but in case you want the single paragraph most relevant to your question, I’d suggest this one, from just before the end: DI frameworks are unnecessary. In more rigid environments, … Read more
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