Spring Tutorials

Spring AOP defaults to using standard JDK dynamic proxies for AOP proxies. This enables any interface (or set of interfaces) to be proxied. Spring AOP can also use CGLIB (Code Generation Library) proxies. This is necessary to proxy classes, rather than interfaces. CGLIB is used by default if a business object does not implement an interface. As it is good practice to program to interfaces rather than classes, business classes normally will implement one or more business interfaces.

It is possible to force the use of CGLIB, in those (hopefully rare) cases where you need to advise a method that is not declared on an interface, or where you need to pass a proxied object to a method as a concrete type.

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. 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.

Example

public class Simple 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 main(String[] 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.

public class Main {
public static void main(String[] args) {
ProxyFactory factory = new ProxyFactory(new SimplePojo());
factory.addInterface(Pojo.class);
factory.addAdvice(new RetryAdvice());
Pojo pojo = (Pojo) factory.getProxy();
// this is a method call on the proxy!
pojo.foo();
}}

Here 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.

AOP implementations in Spring are provided the following main task as given below.

1. Spring AOP
2. AspectJ
3. JBoss AOP

Spring supports the @AspectJ annotation style approach and the schema-based approach to implement custom aspects.

1. XML Schema based Aspects are implemented using regular classes along with XML based configuration.
2. @AspectJ based @AspectJ refers to a style of declaring aspects as regular Java classes annotated with Java 5 annotations.