Plog

AspectJ Run-time Weaving without a Java Agent

January 13, 2006 at 12:29 am · Filed under Software Development

Note: I am still working on this, so this code is development only, and not to be used in production, or maybe by hobbyists. It is recommended to use the WeavingURLClassLoader (that comes with AspectJ) instead of this class loader.

I might as well drop this to the public since the AspectJ documentation cuts short at this very specific task I wanted. The documentation has this much to say about load-time-weaving without an agent:

“A public interface is provided to allow a user written class loader to instantiate a weaver and weave classes after loading and before defining them in the JVM. This enables load-time weaving to be supported in environments where no weaving agent is available. It also allows the user to explicitly restrict by class loader which classes can be woven. For more information, see aj and the API documentation and source for WeavingURLClassLoader and WeavingAdapter. “

So I did what it said and attempted to simply create a WeavingURLClassLoader (which makes its own WeavingAdapter) and I got nothing. The final way that I got load time weaving to work without an agent was to download the entire AspectJ repository and step through the code line by line in Netbeans. It turns out that the current implementation of WeavingURLClassLoader happily accepts your aspects but does nothing to actually convert classes loaded by this class loader into weaved classes. This was very confusing, so I decided to abandon the recommended text from the LTW guide. Instead I just looked at the code that implements the Java agent itself. The real workhorse of loadtime weaving apparently comes from a class called ClassLoadingWeavingAdapter. Since this class was too hard to use, I decided to step back even more and finally managed to just use a class called Aj. Aj is used by the weaving agent as a class “pre-processor”. In the end I decided this was the correct route to take and ended up calling the weaving pre-processor directly.

Since most people want to have a weaving class loader I created a small class called WeaveClassLoader that uses Aj directly. In the end I managed to get AOP code to run from something as simple as:

package swingaoptest;
public class Main
{
public static void main(String[] args) throws Throwable
{
com.bitspy.aop.AJWeave.main(args);
}
}

Which runs:

package com.bitspy.aop;
public class AJWeave
{
public static void main(String[] args)
throws Throwable
{
new WeaveClassLoader(
ClassLoader.getSystemClassLoader()).main(args);
}
}
Now the thing to understand next is what main is eventually called (see the last line above). The main method that is run is picked up from aop.xml. I changed the aop.xml format just enough to support the following:

> … rest of aop.xml
The rest of aop.xml remains the same as you find it within the load-time-weaving guide of AspectJ.

My eventual plan of all of this is to make a AOP/Groovy software instrumentation framework that can be used to modify already written java software. It would be very cool to intercept a JButton click in any Swing application and replace the functionality with something completely different. Well I hope this serves anyone’s purpose. The WeaveClassLoader is attached.

WeaveClassLoader

Permalink

AspectJ Run-time Weaving without a Java Agent

Leave a Comment

Archives

Categories

Meta