Wednesday, July 29, 2009

Spring AOP with XML-based Configuration

The previous post described how to use AspectJ annotations to implement Spring AOP. However, many programmers prefer to put configuration outside code. In such case Spring support for AOP through XML declaration of AOP components comes in handy. In this post we'll see how the same application can be implemented using Schema-based AOP support in Spring. An example of using pointcuts method parameters is also shown. 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"
    &nbspxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
    &nbspxmlns:tx="http://www.springframework.org/schema/tx"
    &nbspxsi:schemaLocation="
    &nbsphttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
    &nbsphttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd
    &nbsphttp://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">
    <!--
    <aop:aspectj-autoproxy proxy-target-class="true"/> <bean
    &nbspid="adviceObject" class="aop.AspectJAdvice" />
    &nbsp-->
    <aop:config>
    <!-- Pointcut for every method invocation -->
    <aop:pointcut id="searchEnginePc" expression="execution(* *(..))" />

    <!-- Pointcut for every method invocation with a String parameter -->
    <aop:pointcut id="pointcutWithParam" expression="execution(* *(..)) and args(prefix)" />

    <!-- After returning advice -->
    <aop:aspect id="springAspect" ref="adviceObject">

    <aop:around pointcut-ref="searchEnginePc" method="aroundAdvice" />

    <aop:after-returning pointcut-ref="searchEnginePc"
    &nbspmethod="afterAdvice" />

    <aop:before pointcut-ref="pointcutWithParam" method="beforeAdvice" />

    </aop:aspect>
    </aop:config>

    <bean id="adviceObject" class="aop.SpringAdvice" />
    <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:config >
      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:config proxy-target-class="true">
      This will force the use of CGLIB proxies which allow proxying concrete classes too.
    • The aop-config element defines 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. The Before advice in the example uses a pointcut that uses arguments and can be used as a model for applying Advice for methods based on the parameter passed to the methods.
      • 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.
        */
        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.
    • The Aspect:
    /*
    * Author: Abhi Vuyyuru
    */
    package aop;

    import org.aspectj.lang.ProceedingJoinPoint;

    public class SpringAdvice {
    /*
    * Applied around a any public method, based on XML configuration
    */
    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.
    * Based on XML configuration
    */
    public void beforeAdvice(String prefix) {
    System.out.println("Before advice : " + prefix);
    }

    /*
    * Applied after returning, based on XML configuration
    */
    public void afterAdvice() {
    System.out.println("After Returning advice");
    }



    }
    AspectJAdvice.java

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.

Wednesday, July 15, 2009

EasyMock for Unit Tests

One of the basic requirements for unit testing is the creation of mock objects. Easy mock is a library that helps to dynamically create mock objects. This way we can avoid much of the tedious work involved in manually coding mock objects. However, EasyMock itself is not the silver bullet, we still have to define expectations in test cases. Using EasyMock also means that you have make certain design changes (if your design follows the usual design principles you may not have to change much. Here's a sample Unit Test using EasyMock. You can download easymock from here.
  • Class Under Test:


    package sample;

    import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;

    public class DateFormatter {
    public static final String DATE_FORMAT = "MM/dd/yyyy";

    private DateFormatterHelper helper = null;

    public DateFormatter() {
    }

    public String convertToStandardFormat(String dateString, String format) throws ParseException {
    if (dateString == null || dateString.equals(""))
    return "";
    dateString = dateString == null ? "" : dateString;
    DateFormat df = helper.getDateFormat(format);
    Date date = df.parse(dateString);
    SimpleDateFormat sdf = new SimpleDateFormat(DATE_FORMAT);
    return sdf.format(date);
    }

    public DateFormatterHelper getHelper() {
    return helper;
    }

    public void setHelper(DateFormatterHelper helper) {
    this.helper = helper;
    }
    }
    DateFormatter.java
  • Helper Class and Interface: If you are to mock any class using EasyMock, it is required that you have an interface for the class. If you are following the old design principle "program to an interface, not an implementation", you are good here.

    package sample;

    import java.text.DateFormat;

    public interface DateFormatterHelper {
    public DateFormat getDateFormat(String format);
    }
    DateFormatterHelper.java


    package sample;

    import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;

    public class DateFormatterHelperImpl implements DateFormatterHelper {

    public DateFormatterHelperImpl() {
    }

    public DateFormat getDateFormat(String format) {
    SimpleDateFormat sdf = new SimpleDateFormat(format);
    sdf.setCalendar(Calendar.getInstance());
    sdf.setLenient(false);
    return sdf;
    }


    public static void main(String args[]) {
    DateFormatterHelper helper = new DateFormatterHelperImpl();
    try {
    System.out.println(helper.getDateFormat("MM/dd/yyyy").parse("11/27/2008"));
    } catch (ParseException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }

    }

    }
    DateFormatterHelperImpl.java
  • The test class:


    package tests;

    import static org.junit.Assert.fail;

    import java.text.ParseException;
    import java.text.SimpleDateFormat;

    import org.easymock.EasyMock;
    import org.junit.Assert;
    import org.junit.Before;
    import org.junit.Test;

    import sample.DateFormatter;
    import sample.DateFormatterHelper;

    public class DateFormatterTests {

    private DateFormatter formatter = null;

    DateFormatterHelper helper = null;

    @Before
    public void setUp() throws Exception {
    helper = EasyMock.createMock(DateFormatterHelper.class);
    formatter = new DateFormatter();
    formatter.setHelper(helper);
    }

    @Test
    public void testConvertToStandardFormat() {

    String formatted = null;
    try {
    EasyMock.expect(helper.getDateFormat("MM-dd-yyyy")).andReturn(new SimpleDateFormat("MM-dd-yyyy"));
    EasyMock.replay(helper);
    formatted = formatter.convertToStandardFormat("11-27-2008", "MM-dd-yyyy");
    } catch (ParseException e) {
    e.printStackTrace();
    fail("Exception");
    }
    Assert.assertEquals(formatted, "11/27/2008");

    }
    }
    DateFormatterTests.java
    Note that in the EasyMock.expect method line, we use the "andReturn" method. This is to define the expected behavior when the method under test is invoked by the testcase. As can be expected, the replay method simply replays the pre-defined behavior when the actual call is made on the mock object.

Popular Posts