Why Spring AOP is not weaving external jars at runtime?

Question

I have a java application build upon Spring 3. This project has another jar as a dependency.

This dependency contains a @org.aspectj.lang.annotation.Aspect class (lets say, com.aspectprovider.aspects.MyAspect). There's a @Before advice to weave a method from classes that implements the interface Foo. Something like:

@Before("execution(* com.project.Foo.save(..))")

The Foo interface can be inside the "project" or in another jar. It doesn't matter for this example.

My project contains classes that implements Foo. Those are the classes that I want it to be weaved, of course.

My Spring application context configuration file (applicationContext.xml) contains the line:

<aop:aspectj-autoproxy />

I also declare the aspect as a bean, and inject some properties:

<bean id="myAspect" class="com.aspectprovider.aspects.MyAspect"
  factory-method="aspectOf" >
  <property name="someproperty" value="somevalue" />
</bean>

Trough logging I can see that MyAspect is instantiated and the properties are injected. But the method save is not intercepted. This is the problem.

If I copy the aspect classes from the jar to the application that has Spring, it works. When those aspects are contained in external jars, the method save is not intercepted. Any clues?

edit: how I am calling Foo's save method:

//in a JSF managed bean
@Inject
private Foo myFoo;  //there's a implementation of Foo in a package that spring is looking at. So it is injected correctly.

public String someAction() {
    myFoo.save("something"); //the @Before advice is only called if the class containing the aspect is not in an external jar
}


//in a class with a main method
void main(String[] ars) {
    ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
    //right after the previous line, I can see in the log that MyAspect is instantiated.
    Foo myFoo = ac.getBean(Foo.class);
    myFoo.save("something"); //the @Before advice is only called if the class containing the aspect is not in an external jar
}

Basically, my applicationContext.xml has the following lines:

<context:annotation-config />
<context:component-scan base-package="com.project" />
<context:component-scan base-package="com.aspectprovider.aspects" />
<aop:aspectj-autoproxy />
<bean id="myAspect" class="com.aspectprovider.aspects.MyAspect" factory-method="aspectOf" >
    <property name="someproperty" value="somevalue" />
</bean>

I don't think I need to put anything like

<context:component-scan  base-package="com.project">
    <context:include-filter type="aspectj" expression="com.aspectprovider.aspects.*" />
</context:component-scan>

Answer 1

I have the same problem. I solved this problem packaging with maven. Check the aspectj-maven-plugin and option weaveDependency

http://mojo.codehaus.org/aspectj-maven-plugin/weaveJars.html

Answer 2

Considering it works perfectly fine when the classes are packaged with the application and spring I can only think it would be a classloading issue.

If it works fine when your bundled in your app then then when AOP scans all the classes that it will have to monitor then it is referencing the right classloader with all the right jars. But now when you remove it and set it into a JAR it is scanning under the classloader with all of the other third party jars.

I am not 100% sure how it is mapped out but it could be something like this:

Bootstrap Classloader <- Third Party Classloader  <- Application Class Loader (with all your classes)
                              \                         \
                               aspectj.jar               spring.jar

If its aspect.jar is scanning under only its classloader then it will not be able to see 'all your classes'. One way you can try confirming this is to get a heap dump of your app. Run it against Eclipse MAT, Check out Class Loader explorer and look for the aspect classes. If they do not reside under the same classloader as your application you would have to look at a way to have tomcat tell the third party libraries of the application classes.