Tuesday, July 28, 2009

Spring AOP with AspectJ Annotations

This post describes how to use Spring AOP with AspectJ aspects using AspectJ annotations. An example of using pointcuts method parameters is also shown. I assume that you are familiar with the basic AOP concepts, however, here are a couple of things that you must to know if you are new to AOP.

Cross-cutting concerns: Any part of the application that has implications through most of the major modules of the application may be termed as a cross-cutting concern. Coding such cross-cutting concerns into the business methods will not only increase code-complexity but also reduce re-usability. Application security and transaction management are the best examples of cross-cutting concerns.

Aspect: An aspect is the "unit of modularity" of any of the cross-cutting concerns within the applications. In Spring AOP, aspects are implemented using regular Java class

with annotations AspectJ is enabled

declaratively, without annotations, in the application context.

Join point and pointcut: join point is any point during the program execution of a program, such as the execution of a method or the handling of an exception. Spring AOP only supports methods as join points. A pointcut is a predicate which is used to identify join points.

Advice: Action applied at join points. Advice can be applied before, after or around a join point. In Spring, advice is modeled as an interceptor. Multiple advices hare maintained as a chain of intercptors around the join point.

One important thing to note here is that, by default, Spring uses Java Dynamic Proxies to implement Aspect Oriented Programming support. This requires you to "program to interfaces rather than classes" which is anyway a good programming practice. But if you have to code to concrete classes, you can force Spring AOP to use CGLIB proxies. How to do so is explained with the example. For an in-depth understanding of AOP concepts, refer to either AspectJ and/or Spring AOP documentation. Here's the code, followed by the explanations.

applicationContext.xmlThis xml is used for the default Spring AOP implementation with Java dynamic proxies. Note that the main method is programmed to the SearchEngine interface rather than the concrete class.

<!-- proxy-target-class forces the use of CGLIB proxies, which allows proxying classes in addition to interfaces.--><aop:aspectj-autoproxy proxy-target-class="true" />

This will force the use of CGLIB proxies which allow proxying concrete classes too.

The Aspect: This aspect defines a pointcut and three different types of advice, around-advice, before advice, and after return advice.

Before Advice: Applied before a join point. This does not have the ability to prevent jointpoint (method execution) unless it throws an exception.

After Return Advice: Applied after the join points returns without exception.

Around Advice: Is applied around a join point. Note that the around advice is NOT called "before and after" the join point, but rather "around" the join point. If you look at the code below, the around advice is invoked when the join point is about to execute, but the around advice takes control of the execution. If you do not call the pjp.proceed() method in the following code, the join point will not be invoked.

The pointcut here simply explains how a pointcut can be used instead of using predicates in the Advice annotations. Pointcuts come in handy when the advice predicates become too complex, in which case multiple pointcuts can be combined to form the proper predicate for matching the join point.

The Before advice in the example uses a predicate that uses arguments and can be used as a model for applying Advice for methods based on the parameter passed to the methods.

1 comment:

hi abhi, i am new to this blog and found itvery helpful.i am a spring beginner whenever i am integrating hibernate with spring it works successfully.but in log file i got following error all timeCGLIB Enhancement failed: com.hiber.SpringCheckjava.lang.NoSuchMethodError:class name does it create any problem in future