Spring AOP Example

There are given examples of Spring1.2 old style AOP (dtd based) implementation.

Though it is supported in spring 3, but it is recommended to use spring aop with aspectJ that we are going to learn in next page.

There are 4 types of advices supported in spring1.2 old style aop implementation.

Before Advice it is executed before the actual method call.
After Advice it is executed after the actual method call. If method returns a value, it is executed after returning value.
Around Advice it is executed before and after the actual method call.
Throws Advice it is executed if actual method throws exception.

To understand the basic concepts of Spring AOP, visit the previous page.

Understanding the hierarchy of advice interfaces

Let's understand the advice hierarchy by the diagram given below:

All are interfaces in aop.

MethodBeforeAdvice interface extends the BeforeAdvice interface.

AfterReturningAdvice interface extends the AfterAdvice interface.

ThrowsAdvice interface extends the AfterAdvice interface.

MethodInterceptor interface extends the Interceptor interface. It is used in around advice.

1) MethodBeforeAdvice Example

Create a class that contains actual business logic.

File: A.java

package com.javatpoint;
public class A {
public void m(){System.out.println("actual business logic");}
}

Now, create the advisor class that implements MethodBeforeAdvice interface.

File: BeforeAdvisor.java

package com.javatpoint;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;
public class BeforeAdvisor implements MethodBeforeAdvice{
	@Override
	public void before(Method method, Object[] args, Object target)throws Throwable {
		System.out.println("additional concern before actual logic");
	}
}

In xml file, create 3 beans, one for A class, second for Advisor class and third for ProxyFactoryBean class.

File: applicationContext.xml

<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

<bean id="obj" class="com.javatpoint.A"></bean>
<bean id="ba" class="com.javatpoint.BeforeAdvisor"></bean>

<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="obj"></property>
<property name="interceptorNames">
<list>
<value>ba</value>
</list>
</property>
</bean>

</beans>

Understanding ProxyFactoryBean class:

The ProxyFactoryBean class is provided by Spring Famework. It contains 2 properties target and interceptorNames. The instance of A class will be considered as target object and the instance of advisor class as interceptor. You need to pass the advisor object as the list object as in the xml file given above.

The ProxyFactoryBean class is written something like this:

public class ProxyFactoryBean{
private Object target;
private List interceptorNames;
//getters and setters
}

Now, let's call the actual method.

File: Test.java

package com.javatpoint;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class Test {
public static void main(String[] args) {
	Resource r=new ClassPathResource("applicationContext.xml");
	BeanFactory factory=new XmlBeanFactory(r);
	
	A a=factory.getBean("proxy",A.class);
	a.m();
}
}

Output

Printing additional information in MethodBeforeAdvice

We can print additional information like method name, method argument, target object, target object class name, proxy class etc.

You need to change only two classes BeforeAdvisor.java and Test.java.

File: BeforeAdvisor.java

package com.javatpoint;
import java.lang.reflect.Method;
import org.springframework.aop.MethodBeforeAdvice;

public class BeforeAdvisor implements MethodBeforeAdvice{
	@Override
	public void before(Method method, Object[] args, Object target)throws Throwable {
		System.out.println("additional concern before actual logic");
		System.out.println("method info:"+method.getName()+" "+method.getModifiers());
		System.out.println("argument info:");
		for(Object arg:args)
			System.out.println(arg);
		System.out.println("target Object:"+target);
		System.out.println("target object class name: "+target.getClass().getName());
	}
}

File: Test.java

package com.javatpoint;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;
public class Test {
public static void main(String[] args) {
	Resource r=new ClassPathResource("applicationContext.xml");
	BeanFactory factory=new XmlBeanFactory(r);
	
	A a=factory.getBean("proxy",A.class);
        System.out.println("proxy class name: "+a.getClass().getName());
	a.m();
}
}

Output

2) AfterReturningAdvice Example

Create a class that contains actual business logic.

File: A.java

Same as in the previous example.

Now, create the advisor class that implements AfterReturningAdvice interface.

File: AfterAdvisor.java

package com.javatpoint;
import java.lang.reflect.Method;
import org.springframework.aop.AfterReturningAdvice;
public class AfterAdvisor implements AfterReturningAdvice{
	@Override
	public void afterReturning(Object returnValue, Method method,
         Object[] args, Object target) throws Throwable {
		
		System.out.println("additional concern after returning advice");
	}

}

Create the xml file as in the previous example, you need to change only the advisor class here.

File: applicationContext.xml

<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

<bean id="obj" class="com.javatpoint.A"></bean>
<bean id="ba" class="com.javatpoint.AfterAdvisor"></bean>

<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="obj"></property>
<property name="interceptorNames">
<list>
<value>ba</value>
</list>
</property>
</bean>

</beans>

File: Test.java

Same as in the previous example.

Output

3) MethodInterceptor (AroundAdvice) Example

Create a class that contains actual business logic.

File: A.java

Same as in the previous example.

Now, create the advisor class that implements MethodInterceptor interface.

File: AroundAdvisor.java

package com.javatpoint;
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class AroundAdvisor implements MethodInterceptor{

	@Override
	public Object invoke(MethodInvocation mi) throws Throwable {
		Object obj;
		System.out.println("additional concern before actual logic");
		obj=mi.proceed();
		System.out.println("additional concern after actual logic");
		return obj;
	}

}

Create the xml file as in the previous example, you need to change only the advisor class here.

File: applicationContext.xml

<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

<bean id="obj" class="com.javatpoint.A"></bean>
<bean id="ba" class="com.javatpoint.AroundAdvisor"></bean>

<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="obj"></property>
<property name="interceptorNames">
<list>
<value>ba</value>
</list>
</property>
</bean>

</beans>

File: Test.java

Same as in the previous example.

Output

4) ThrowsAdvice Example

Create a class that contains actual business logic.

File: Validator.java

package com.javatpoint;
public class Validator {
	public void validate(int age)throws Exception{
		if(age<18){
			throw new ArithmeticException("Not Valid Age");
		}
		else{
			System.out.println("vote confirmed");
		}
	}
}

Now, create the advisor class that implements ThrowsAdvice interface.

File: ThrowsAdvisor.java

package com.javatpoint;
import org.springframework.aop.ThrowsAdvice;
public class ThrowsAdvisor implements ThrowsAdvice{
	public void afterThrowing(Exception ex){
		System.out.println("additional concern if exception occurs");
	}
}

Create the xml file as in the previous example, you need to change only the Validator class and advisor class.

File: applicationContext.xml

<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">

<bean id="obj" class="com.javatpoint.Validator"></bean>
<bean id="ba" class="com.javatpoint.ThrowsAdvisor"></bean>

<bean id="proxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="obj"></property>
<property name="interceptorNames">
<list>
<value>ba</value>
</list>
</property>
</bean>

</beans>

File: Test.java

package com.javatpoint;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

public class Test {
public static void main(String[] args) {
	Resource r=new ClassPathResource("applicationContext.xml");
	BeanFactory factory=new XmlBeanFactory(r);
	
	Validator v=factory.getBean("proxy",Validator.class);
	try{
	v.validate(12);
	}catch(Exception e){e.printStackTrace();}
}
}

Output

Next TopicSpring AOP AspectJ Annotation Example

← prev next →

Spring Tutorial

Spring in IDE

Dependency Injection

Spring AOP

Spring JdbcTemplate

Spring ORM

SPEL

Spring MVC

Spring MVC Tiles

Spring Remoting

Spring OXM

Spring Java Mail

Spring Web

Spring Interview

Spring Quiz

Spring AOP Example

To understand the basic concepts of Spring AOP, visit the previous page.

Understanding the hierarchy of advice interfaces

1) MethodBeforeAdvice Example

Output

Printing additional information in MethodBeforeAdvice

Output

2) AfterReturningAdvice Example

Output

3) MethodInterceptor (AroundAdvice) Example

Output

4) ThrowsAdvice Example

Output