java search
Loading
Help improve Java Search

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.

The Simple application ...
  • Search Engine Interface :
    /*
    * Author: Abhi Vuyyuru
    */
    package search;

    import java.util.List;

    public interface SearchEngine {
    public List<String> search(String prefix);
    }
    SearchEngine.java
  • Search Engine Class :
    /*
    * Author: Abhi Vuyyuru
    */
    package search;

    import java.util.ArrayList;
    import java.util.List;

    public class SearchEngineImpl implements SearchEngine {

    public List<String> search(String prefix) {
    System.out.println("In search implementation");
    List<String> list =
    new ArrayList<String>();
    list.add
    (prefix + " result 1");
    list.add
    (prefix + " result 2");
    return list;
    }

    }
    SearchEngineImpl.java
  • Main method:
    /*
    * Author: Abhi Vuyyuru
    */
    package main;

    import java.util.List;

    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.FileSystemXmlApplicationContext;

    import search.SearchEngine;

    public class AopTest {

    public static void main(String[] args) {
    ApplicationContext ctx = new FileSystemXmlApplicationContext(
    "applicationContext.xml");

    SearchEngine searchEngine =
    (SearchEngine) ctx.getBean("searchEngine");
    List<String> searchResults = searchEngine.search
    ("search");
    System.out.println
    ("Number of results : " + searchResults.size());

    }
    }
    AopTest.java
Spring AOP classes and configuration
  • Appication Conext : This the spring configuration file for the example.
    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xsi:schemaLocation="
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <!--Enables AspectJ auto-proxying-->
    <aop:aspectj-autoproxy />
    <bean id="adviceObject" class="aop.AspectJAdvice" />
    <bean id="searchEngine" class="search.SearchEngineImpl" />
    </beans>
    applicationContext.xml
    This 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.
    SearchEngine searchEngine = (SearchEngine) ctx.getBean("searchEngine");

    Hence, the AOP configuration was set to
    <aop:aspectj-autoproxy />
    If you have to use the concrete class in your application, as shown below
    SearchEngineImpl searchEngine = (SearchEngineImpl) ctx.getBean("searchEngine");

    You have to change the AOP configuration to the following
    <!-- 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.
      /*
      * Applied around a any public method.
      */
      @Around("execution(public * *(..))")
      public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
      System.out.println("Around advice before joinpoint");
      Object obj = pjp.proceed
      ();
      System.out.println
      ("Around advice after running");
      return obj;
      }
      Around advice has the ability to change the behavior of the join point, and even to stop the join point execution.
    /*
    * Author: Abhi Vuyyuru
    */
    package aop;

    import org.aspectj.lang.ProceedingJoinPoint;
    import org.aspectj.lang.annotation.AfterReturning;
    import org.aspectj.lang.annotation.Around;
    import org.aspectj.lang.annotation.Aspect;
    import org.aspectj.lang.annotation.Before;
    import org.aspectj.lang.annotation.Pointcut;
    @Aspect
    public class AspectJAdvice {

    /*
    * Applied around a any public method.
    */
    @Around("execution(public * *(..))")
    public Object aroundAdvice(ProceedingJoinPoint pjp) throws Throwable {
    System.out.println("Around advice before joinpoint");
    Object obj = pjp.proceed
    ();
    System.out.println
    ("Around advice after running");
    return obj;
    }

    /*
    * Applied before the execution of any method which takes a String argument.
    */
    @Before("execution(* *(..)) &&" + "args(prefix)")
    public void beforeAdvice(String prefix) {
    System.out.println("Before advice : " + prefix);
    }

    /*
    * Applied after returning from the pointcut defined by anyPublicMethod
    */
    @AfterReturning("anyPublicMethod()")
    public void afterAdvice() {
    System.out.println("After Returning advice");
    }

    /*
    * Defines a pointcut that matches any public method.
    */
    @Pointcut("execution(public * *(..))")
    private void anyPublicMethod() {
    }

    }
    AspectJAdvice.java
    • 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:

  1. hi abhi,
    i am new to this blog and found it
    very 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 time

    CGLIB Enhancement failed: com.hiber.SpringCheck
    java.lang.NoSuchMethodError:class name
    does it create any problem in future

    can u plz explore things

    thanks
    ranvijay

    ReplyDelete