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