AspectJ - Weaving with custom ClassLoader at runtime

Question

I'm trying to load classes at runtime and weave them with some AspectJ aspects at this point. I have load-time weaving enabled, and it works when I use it more conventionally.

I have the following in my @Aspect class:

@Before("call(* mypackage.MyInterface.*())")
public void myInterfaceExecuteCall(JoinPoint thisJoinPoint,
        JoinPoint.StaticPart thisJoinPointStaticPart,
        JoinPoint.EnclosingStaticPart thisEnclosingJoinPointStaticPart) {
    System.out.println(thisJoinPoint.getSignature().getDeclaringType());
    System.out.println(thisJoinPoint.getSignature().getName());
}

Then I'm scanning the jars and finding classes that are implementations of MyInterface:

URLClassLoader classLoader = new URLClassLoader(new URL[] { urlOfJar },
        ClassLoader.getSystemClassLoader());
WeavingURLClassLoader weaver = new WeavingURLClassLoader(
        classLoader);
HashSet<Class<?>> executableClasses = new HashSet<Class<?>>();
for (String name : classNamesInJar) {
    try {
        Class<?> myImplementation = weaver.loadClass(name);
        if (MyInterface.class.isAssignableFrom(myImplementation)) {
            executableClasses.add(myImplementation);
        }
    } catch (Exception e) {
        e.printStackTrace();
    } catch (NoClassDefFoundError e) {
        e.printStackTrace();
    }
}

... and then I'm executing a specific method in the loaded classes at some point:

try {
    Method execute = myImplementation.getMethod("execute");
    execute.invoke(myImplementation.newInstance());
} catch (Exception e) {
    e.printStackTrace();
}

However, the @Before method that I gave you above is never executed when I call execute.invoke(...) (although the execute method itself is obviously executed, since I see its output).

Does someone know what I'm doing wrong? What's the way to make myInterfaceExecuteCall get called before the loaded class's methods get called?

Answer 1

OK I found out what it was, and it doesn't work quite the way I intended it, but here is a workaround:

Just do a @Before("execution(* mypackage.MyInterface.*())") instead of call. This works even if the class was loaded manually and at runtime by a custom class loader. This is because AspectJ doesn't care about calls that are done with using Method.invoke(...). I hope someone else can use this workaround.

Here is a link to the documentation containing the memorable info:

For example, the call pointcut does not pick out reflective calls to a method implemented in java.lang.reflect.Method.invoke(Object, Object[]).

http://www.eclipse.org/aspectj/doc/released/progguide/implementation.html

If you have a different solution, please don't hesitate to answer!