4.3.9.RELEASE Spring Framework
248
aspects. If you are not using Eclipse, or have only a few aspects that do not play a major role in your application, then you may want to consider using the AspectJ style and sticking with a regular Java
compilation in your IDE, and adding an aspect weaving phase to your build script.
AspectJ or XML for Spring AOP?
If you have chosen to use Spring AOP, then you have a choice of AspectJ or XML style. There are various tradeoffs to consider.
The XML style will be most familiar to existing Spring users and it is backed by genuine POJOs. When using AOP as a tool to configure enterprise services then XML can be a good choice a good test
is whether you consider the pointcut expression to be a part of your configuration you might want to change independently. With the XML style arguably it is clearer from your configuration what aspects
are present in the system. The XML style has two disadvantages. Firstly it does not fully encapsulate the implementation of the
requirement it addresses in a single place. The DRY principle says that there should be a single, unambiguous, authoritative representation of any piece of knowledge within a system. When using the
XML style, the knowledge of how a requirement is implemented is split across the declaration of the backing bean class, and the XML in the configuration file. When using the AspectJ style there is a
single module - the aspect - in which this information is encapsulated. Secondly, the XML style is slightly more limited in what it can express than the AspectJ style: only the singleton aspect instantiation
model is supported, and it is not possible to combine named pointcuts declared in XML. For example, in the AspectJ style you can write something like:
Pointcutexecution get
public void
propertyAccess {} Pointcutexecutionorg.xyz.Account+ ..
public void
operationReturningAnAccount {} PointcutpropertyAccess operationReturningAnAccount
public void
accountPropertyAccess {}
In the XML style I can declare the first two pointcuts:
aop:pointcut id
= propertyAccess
expression =
execution get aop:pointcut
id =
operationReturningAnAccount expression
= executionorg.xyz.Account+ ..
The downside of the XML approach is that you cannot define the accountPropertyAccess
pointcut by combining these definitions.
The AspectJ style supports additional instantiation models, and richer pointcut composition. It has the advantage of keeping the aspect as a modular unit. It also has the advantage the AspectJ aspects
can be understood and thus consumed both by Spring AOP and by AspectJ - so if you later decide you need the capabilities of AspectJ to implement additional requirements then it is very easy to migrate
to an AspectJ-based approach. On balance the Spring team prefer the AspectJ style whenever you have aspects that do more than simple configuration of enterprise services.
11.5 Mixing aspect types
It is perfectly possible to mix AspectJ style aspects using the autoproxying support, schema-defined aop:aspect
aspects, aop:advisor
declared advisors and even proxies and interceptors
4.3.9.RELEASE Spring Framework
249
defined using the Spring 1.2 style in the same configuration. All of these are implemented using the same underlying support mechanism and will co-exist without any difficulty.
11.6 Proxying mechanisms
Spring AOP uses either JDK dynamic proxies or CGLIB to create the proxy for a given target object. JDK dynamic proxies are preferred whenever you have a choice.
If the target object to be proxied implements at least one interface then a JDK dynamic proxy will be used. All of the interfaces implemented by the target type will be proxied. If the target object does not
implement any interfaces then a CGLIB proxy will be created. If you want to force the use of CGLIB proxying for example, to proxy every method defined for the
target object, not just those implemented by its interfaces you can do so. However, there are some issues to consider:
• final
methods cannot be advised, as they cannot be overridden. • As of Spring 3.2, it is no longer necessary to add CGLIB to your project classpath, as CGLIB classes
are repackaged under org.springframework and included directly in the spring-core JAR. This means that CGLIB-based proxy support just works in the same way that JDK dynamic proxies always have.
• As of Spring 4.0, the constructor of your proxied object will NOT be called twice anymore since the CGLIB proxy instance will be created via Objenesis. Only if your JVM does not allow for constructor
bypassing, you might see double invocations and corresponding debug log entries from Spring’s AOP support.
To force the use of CGLIB proxies set the value of the proxy-target-class
attribute of the aop:config
element to true:
aop:config proxy-target-class
= true
-- other beans defined here... --
aop:config
To force CGLIB proxying when using the AspectJ autoproxy support, set the proxy-target-
class attribute of the
aop:aspectj-autoproxy element to
true :
aop:aspectj-autoproxy proxy-target-class
= true
Note
Multiple aop:config
sections are collapsed into a single unified auto-proxy creator at runtime, which applies the strongest proxy settings that any of the
aop:config sections typically from different XML bean definition files specified. This also applies to the
tx:annotation-driven and
aop:aspectj-autoproxy elements.
To be clear: using proxy-target-class=true
on tx:annotation-driven
, aop:aspectj-autoproxy
or aop:config
elements will force the use of CGLIB proxies for all three of them.
Understanding AOP proxies
Spring AOP is proxy-based. It is vitally important that you grasp the semantics of what that last statement actually means before you write your own aspects or use any of the Spring AOP-based aspects supplied
with the Spring Framework.
4.3.9.RELEASE Spring Framework
250
Consider first the scenario where you have a plain-vanilla, un-proxied, nothing-special-about-it, straight object reference, as illustrated by the following code snippet.
public class
SimplePojo implements
Pojo {
public void
foo { this next method invocation is a direct call on the this reference
this .bar;
}
public void
bar { some logic...
} }
If you invoke a method on an object reference, the method is invoked directly on that object reference, as can be seen below.
public class
Main {
public static
void mainString[] args {
Pojo pojo = new
SimplePojo; this is a direct method call on the pojo reference
pojo.foo; }
}
Things change slightly when the reference that client code has is a proxy. Consider the following diagram and code snippet.
4.3.9.RELEASE Spring Framework
251
public class
Main {
public static
void mainString[] args {
ProxyFactory factory = new
ProxyFactory new
SimplePojo; factory.addInterfacePojo.
class ;
factory.addAdvice new
RetryAdvice; Pojo pojo = Pojo factory.getProxy;
this is a method call on the proxy pojo.foo;
} }
The key thing to understand here is that the client code inside the main..
of the Main
class has a reference to the proxy. This means that method calls on that object reference will be calls on
the proxy, and as such the proxy will be able to delegate to all of the interceptors advice that are relevant to that particular method call. However, once the call has finally reached the target object, the
SimplePojo reference in this case, any method calls that it may make on itself, such as
this.bar or
this.foo , are going to be invoked against the this reference, and not the proxy. This has important
implications. It means that self-invocation is not going to result in the advice associated with a method invocation getting a chance to execute.
Okay, so what is to be done about this? The best approach the term best is used loosely here is to refactor your code such that the self-invocation does not happen. For sure, this does entail some work
on your part, but it is the best, least-invasive approach. The next approach is absolutely horrendous, and I am almost reticent to point it out precisely because it is so horrendous. You can choke totally
tie the logic within your class to Spring AOP by doing this:
public class
SimplePojo implements
Pojo {
public void
foo { this works, but... gah
Pojo AopContext.currentProxy.bar; }
public void
bar { some logic...
} }
This totally couples your code to Spring AOP, and it makes the class itself aware of the fact that it is being used in an AOP context, which flies in the face of AOP. It also requires some additional configuration
when the proxy is being created:
public class
Main {
public static
void mainString[] args {
ProxyFactory factory = new
ProxyFactory new
SimplePojo; factory.adddInterfacePojo.
class ;
factory.addAdvice new
RetryAdvice; factory.setExposeProxytrue;
Pojo pojo = Pojo factory.getProxy; this is a method call on the proxy
pojo.foo; }
}
4.3.9.RELEASE Spring Framework
252
Finally, it must be noted that AspectJ does not have this self-invocation issue because it is not a proxy- based AOP framework.
11.7 Programmatic creation of AspectJ Proxies
