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();
}
}
|
|