Around Aspect XML implementation example

create a spring maven project so that we can manage our dependencies in the pom.xml easily.

Project structure looks like below

AOP_XML_Around


Define the pom.xml file as below to include AspectJ jars and spring jars

  1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  3.   <modelVersion>4.0.0</modelVersion>
  4.  
  5.   <groupId>Spring</groupId>
  6.   <artifactId>SpringAOP</artifactId>
  7.   <version>0.0.1-SNAPSHOT</version>
  8.   <packaging>jar</packaging>
  9.  
  10.   <name>SpringAOP</name>
  11.   <url>http://maven.apache.org</url>
  12.  
  13.   <properties>
  14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  15.   </properties>
  16.  
  17.   <dependencies>
  18.   <dependency>
  19.     <groupId>org.springframework</groupId>
  20.     <artifactId>spring-core</artifactId>
  21.     <version>4.2.4.RELEASE</version>
  22. </dependency>
  23.   <dependency>
  24.     <groupId>org.springframework</groupId>
  25.     <artifactId>spring-context</artifactId>
  26.     <version>4.2.4.RELEASE</version>
  27. </dependency>
  28. <dependency>
  29.     <groupId>org.aspectj</groupId>
  30.     <artifactId>aspectjrt</artifactId>
  31.     <version>1.7.3</version>
  32. </dependency>
  33.  
  34. <dependency>
  35.     <groupId>aspectj</groupId>
  36.     <artifactId>aspectjweaver</artifactId>
  37.     <version>1.5.4</version>
  38. </dependency>
  39.  
  40.  
  41.     <dependency>
  42.       <groupId>junit</groupId>
  43.       <artifactId>junit</artifactId>
  44.       <version>3.8.1</version>
  45.       <scope>test</scope>
  46.     </dependency>
  47.   </dependencies>
  48. </project>
<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>Spring</groupId>
  <artifactId>SpringAOP</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <packaging>jar</packaging>

  <name>SpringAOP</name>
  <url>http://maven.apache.org</url>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  </properties>

  <dependencies>
  <dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-core</artifactId>
	<version>4.2.4.RELEASE</version>
</dependency>
  <dependency>
	<groupId>org.springframework</groupId>
	<artifactId>spring-context</artifactId>
	<version>4.2.4.RELEASE</version>
</dependency>
<dependency>
	<groupId>org.aspectj</groupId>
	<artifactId>aspectjrt</artifactId>
	<version>1.7.3</version>
</dependency>

<dependency>
	<groupId>aspectj</groupId>
	<artifactId>aspectjweaver</artifactId>
	<version>1.5.4</version>
</dependency>


    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>


Let’s create a class which contains a business logic on which we apply Advice.

  1. package com.kb;
  2. public class SimpleCalculator {
  3.     public int add(int x,int y){
  4.         return x+y;
  5.     }
  6.     public int subtract(int x,int y){
  7.         return x-y;
  8.     }
  9. }
package com.kb;
public class SimpleCalculator {
	public int add(int x,int y){
		return x+y;
	}
	public int subtract(int x,int y){
		return x-y;
	}
}

This class has 2 methods where each method performs some business logic,which is addition and subtraction.


Now let’s write the Aspect class as below

  1. package com.kb;
  2. import org.aspectj.lang.ProceedingJoinPoint;
  3.  
  4. public class MyAroundAspect {
  5.    
  6.     public Object myAdvice(ProceedingJoinPoint jp){
  7.         System.out.println("Before the method "+jp.getSignature().getName()+" execution");
  8.         Object[] args=null;
  9.         Object value=null;
  10.         try {
  11.             args=jp.getArgs();
  12.             if((Integer)args[0] == 10){
  13.                 value= jp.proceed();
  14.               }
  15.         } catch (Throwable e) {
  16.             e.printStackTrace();
  17.         }
  18.         System.out.println("After the method "+jp.getSignature().getName()+" execution");
  19.         return value;
  20.     }
  21. }
package com.kb;
import org.aspectj.lang.ProceedingJoinPoint;

public class MyAroundAspect {
	
	public Object myAdvice(ProceedingJoinPoint jp){
		System.out.println("Before the method "+jp.getSignature().getName()+" execution");
		Object[] args=null;
		Object value=null;
		try {
			args=jp.getArgs();
			if((Integer)args[0] == 10){
				value= jp.proceed();
		      }
		} catch (Throwable e) {
			e.printStackTrace();
		}
		System.out.println("After the method "+jp.getSignature().getName()+" execution");
		return value;
	}
}

This Aspect has an advice called myAdvice whose action is to print the log with method name

It takes a parameter called ProceedingJoinPoint which helps to control the execution of the target method.

When we use jp.proceed() , the advised method continues the execution.

So we can use Around advice to execute some code before and after the execution of the advised method.

Based on some condition, we can also stop the further execution of the advised method.

We are continuing the advised method execution only if the first argument passed is 10,otherwise we will stop the execution.


Now let’s create a beans.xml file which is the spring configuration file where we define our aspect beans and configure the AOP as below

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:aop="http://www.springframework.org/schema/aop"
  4.     xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
  5.     xsi:schemaLocation="http://www.springframework.org/schema/beans
  6.        http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  7.        http://www.springframework.org/schema/aop  
  8.         http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
  9.        http://www.springframework.org/schema/context
  10.         http://www.springframework.org/schema/context/spring-context-3.2.xsd">
  11.  
  12.     <aop:aspectj-autoproxy />
  13.  
  14.     <bean id="simpleCalc" class="com.kb.SimpleCalculator"/>
  15.    
  16.     <bean id="myAroundAspect" class="com.kb.MyAroundAspect" />
  17.  
  18.     <aop:config>
  19.         <aop:aspect id="myAspect" ref="myAroundAspect">
  20.             <aop:pointcut id="pointCutAfter"
  21.                 expression="execution(* *.*(..))" />
  22.             <aop:around method="myAdvice" pointcut-ref="pointCutAfter" />
  23.         </aop:aspect>
  24.     </aop:config>
  25. </beans>
<?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:context="http://www.springframework.org/schema/context" 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.2.xsd
        http://www.springframework.org/schema/aop   
    	http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
        http://www.springframework.org/schema/context
  		http://www.springframework.org/schema/context/spring-context-3.2.xsd">

	<aop:aspectj-autoproxy />

	<bean id="simpleCalc" class="com.kb.SimpleCalculator"/>
	
	<bean id="myAroundAspect" class="com.kb.MyAroundAspect" />

	<aop:config>
		<aop:aspect id="myAspect" ref="myAroundAspect">
			<aop:pointcut id="pointCutAfter"
				expression="execution(* *.*(..))" />
			<aop:around method="myAdvice" pointcut-ref="pointCutAfter" />
		</aop:aspect>
	</aop:config>
</beans>


Lets write a class which calls the actual business logic method as below

  1. package com.kb;
  2.  
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5.  
  6. public class AOPTest {
  7.     public static void main(String[] args) {
  8.     ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");  
  9.        SimpleCalculator calculator = (SimpleCalculator) context.getBean("simpleCalc");
  10.       int res1= calculator.add(10, 5);
  11.       System.out.println("Addition result is "+res1);
  12.       int res2= calculator.subtract(10, 5);
  13.       System.out.println("Subtracted result is "+res2);
  14.     }
  15. }
package com.kb;

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

public class AOPTest {
	public static void main(String[] args) {
	ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");  
       SimpleCalculator calculator = (SimpleCalculator) context.getBean("simpleCalc"); 
      int res1= calculator.add(10, 5);
      System.out.println("Addition result is "+res1);
      int res2= calculator.subtract(10, 5);
      System.out.println("Subtracted result is "+res2);
	}
}


Run the above class and see the output as below


Observe the output, before and after the execution of add and subtract method,our advice code has been executed.

Since we passed first argument as 10, we got our advised method execution successfully.


Lets modify the above Test program by passing 5 as the first value in the subtract method call as below

  1. package com.kb;
  2.  
  3. import org.springframework.context.ApplicationContext;
  4. import org.springframework.context.support.ClassPathXmlApplicationContext;
  5.  
  6. public class AOPTest {
  7.  
  8.     public static void main(String[] args) {
  9.     ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");  
  10.        SimpleCalculator calculator = (SimpleCalculator) context.getBean("simpleCalc");
  11.       int res1= calculator.add(10, 5);
  12.       System.out.println("addition result is "+res1);
  13.       int res2= calculator.subtract(5,10);
  14.       System.out.println("subtracted result is "+res2);
  15.     }
  16. }
package com.kb;

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

public class AOPTest {

	public static void main(String[] args) {
	ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");  
       SimpleCalculator calculator = (SimpleCalculator) context.getBean("simpleCalc"); 
      int res1= calculator.add(10, 5);
      System.out.println("addition result is "+res1);
      int res2= calculator.subtract(5,10);
      System.out.println("subtracted result is "+res2);
	}
}


See the output as below


Add method got executed successfully, but subtract method failed to execute.

Since subtract method call has passed 5 as the first argument, it did not get executed as our Around advice has a control to stop its execution if the first parameter is not 10.

So using Around advice, we can access the method arguments and we can control the advised method execution.

Download this project SpringAOPXML_AroundAdvice.zip

About the Author

Raj
Founder of javainsimpleway.com
I love Java and open source technologies and very much passionate about software development.
I like to share my knowledge with others especially on technology 🙂
I have given all the examples as simple as possible to understand for the beginners.
All the code posted on my blog is developed,compiled and tested in my development environment.
If you find any mistakes or bugs, Please drop an email to kb.knowledge.sharing@gmail.com

Connect with me on Facebook for more updates

Share this article on