Spring AOP Advices - Around advice example - xml based configuration

In Spring, aspect-oriented programming (AOP) is a programming paradigm that aims to increase modularity by allowing the separation of cross-cutting concerns. AOP forms a basis for aspect-oriented software development.

In this page you will see an example for Spring AOP - Around advice. It combines all three advices (before advice, after returning advice and around advice) during method execution.

pom.xml file gives all required dependencies:

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
    http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>SpringJavaBasedConfig</groupId>
    <artifactId>SpringJavaBasedConfig</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <properties>
        <spring.version>3.2.0.RELEASE</spring.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.1</version>
        </dependency>
    </dependencies>
</project>

My business logic service class:

package com.java2novice.bean;

public class MyBusinessService {

    public void runMyBusinessLogic(){
        System.out.println("************************************");
        System.out.println("Running business logic...");
        System.out.println("************************************");
    }

    public void testThrowException() {
        throw new NullPointerException();
    }
}

Now create “Around Advice”. Create a class which implements MethodInterceptor interface. You must call Object result = metInvocation.proceed() method to proceed on the original method execution, else the original method will not execute.

package com.java2novice.aop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class ExecuteAroundMethod implements MethodInterceptor{

    @Override
    public Object invoke(MethodInvocation metInvocation) throws Throwable {

        System.out.println("Inside RunBeforeExecution.before() method...");
        System.out.println("Running before advice...");
        try{
            Object result = metInvocation.proceed();

            System.out.println("Inside RunAfterExecution.afterReturning() method...");
            System.out.println("Running after advice...");

            return result;
        } catch(NullPointerException ne){
            //this is for ThrowsAdvice
            throw ne;
        }

    }

}

Here is the xml based configuration file. Add bean entry for ExecuteAroundMethod class (around advice class). Also create a proxy for MyBusinessService class. In this proxy configuration, you should add two properties called ‘target’ and ‘interceptorNames‘. ‘target’ defines in which bean you want to introduce advice. ‘interceptorNames’ defines that which advice class you want to introduce to the said target.

<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/context 
    http://www.springframework.org/schema/context/spring-context-3.0.xsd">

    <bean id="busService" class="com.java2novice.bean.MyBusinessService" />
    <bean id="aroundThrow" class="com.java2novice.aop.ExecuteAroundMethod" />
    <bean id="busServiceProxy" class="org.springframework.aop.framework.ProxyFactoryBean" >
        <property name="target" ref="busService" />
        <property name="interceptorNames">
            <list>
                <value>aroundThrow</value>
            </list>
        </property>
    </bean>
</beans>

Here is the final demo class: Note that we are calling proxy bean object, not the business service bean directly.

package com.java2novice.test;

import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import com.java2novice.bean.MyBusinessService;

public class SpringDemo {

    public static void main(String a[]){

        String confFile = "applicationContext.xml";
        ConfigurableApplicationContext context 
                                = new ClassPathXmlApplicationContext(confFile);
        MyBusinessService busServ = (MyBusinessService) context.getBean("busServiceProxy");
        busServ.runMyBusinessLogic();
    }
}

Output:

Inside RunBeforeExecution.before() method...
Running before advice...
************************************
Running business logic...
************************************
Inside RunAfterExecution.afterReturning() method...
Running after advice...