Pin It

How to implement Around Advice using @AspectJ Annotation-Driven AOP in Java ?.

A simple application to demonstrate how to implement Around Advice using @AspectJ Annotation-Driven AOP in Java.

Step 1:- Create a Interface Division.java

package com.hubberspot.aspectj.annotation.aroundadvice;

// Its a simple interface for the Division service.
// It contains one single method called as divide().
// This method takes in two arguments both of the type
// int.

public interface Division {

 public int divide(int a , int b);

}



Step 2:- DivisionImpl.java Service Implementation Class

package com.hubberspot.aspectj.annotation.aroundadvice;

// It is the implementation class for the 
// Division service. It just calculates and returns 
// division of two numbers passed to it as arguments.

public class DivisionImpl implements Division {

 @Override
 public int divide(int a, int b) {

  System.out.println("Number are : " + a + ", " + b);

  return a/b;
 }

}



Step 3:- Around Advice Implementation class

package com.hubberspot.aspectj.annotation.aroundadvice;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;

//@Aspect annotation treats this Java class as 
//Aspect. Its not ordinary POJO class.
@Aspect
public class AroundDivideAdvice {

 // Method invoke() is a around advice
 // implemented by providing @Around annotation.
 // This annotation takes in Pointcut expression, which 
 // indicates when this advice executes.
 // This Pointcut expression tells that invoke() advice
 // will execute around divide method of Division interface.
 // The after advice takes in ProceedingJoinPoint which 
 // helps in invoking the divide method.
 // Based on the user inputs the advice decides whether divide should 
 // be called or not.
 // invoke() methods takes in ProceedingJoinPoint type as a argument
 // It takes out arguments which user inputs from the ProceedingJoinPoint
 // and than validate it accordingly. 
 // It also has a proceed() which transfers controls to method being advised.
 @Around("execution(* com.hubberspot.aspectj.annotation.aroundadvice.Division.divide(..))")
 public Object invoke(ProceedingJoinPoint joinPoint) throws Throwable {
  Object arguments[] = joinPoint.getArgs();

  int number = ((Integer)arguments[1]).intValue();

  if (number == 0) {
   throw new Exception("Cannot divide with 0.... ");
  }
  return joinPoint.proceed();
 }
}




Step 4 :- Spring Configuration file


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

   <aop:aspectj-autoproxy></aop:aspectj-autoproxy>

   <!-- Implementation Class -->
   <bean id="divide"
 class="com.hubberspot.aspectj.annotation.aroundadvice.DivisionImpl" />

   <bean id="aroundAdvice"
 class="com.hubberspot.aspectj.annotation.aroundadvice.AroundDivideAdvice" />

</beans>


Step 5:- Test class

package com.hubberspot.aspectj.annotation.aroundadvice;

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

public class DivisionTest {

 public static void main(String[] args) {

  // ApplicationContext is a Spring interface which 
  // provides with the configuration for an application. 
  // It provides us with all the methods that BeanFactory 
  // provides. It loads the file resources in a older 
  // and generic manner. It helps us to publish events to the
  // listener registered to it. It also provides quick support
  // for internationalization. It provides us with the object 
  // requested, it reads the configuration file and provides
  // us with the necessary object required.
  // We are using concrete implementation of AbstractApplicationContext
  // here called as ClassPathXmlApplicationContext because this 
  // bean factory reads the xml file placed in the classpath of 
  // our application. We provide ClassPathXmlApplicationContext
  // with a configuration file called as around_advice.xml placed
  // at classpath of our application.


  ApplicationContext context = 
    new ClassPathXmlApplicationContext("around_advice.xml");

  // In order to get a object instantiated for a particular bean 
  // we call getBean() method of ClassPathXmlApplicationContext
  // passing it the id for which the object is to be needed. 
  // Here getBean() returns an Object. We need to cast it back 
  // to the Divide object. Without implementing new keyword we 
  // have injected object of Divide just by reading an xml 
  // configuration file.

  Division divide = (Division)context.getBean("divide");

  int result = divide.divide(10 , 5);

  System.out.println("Result = " + result);

  result = divide.divide(10, 0);

  System.out.println("Result = " + result);


 }

}


Output of the program : 


 
Please Give Us Your 1 Minute In Sharing This Post!
SOCIALIZE IT →
FOLLOW US →
SHARE IT →
Related Posts Plugin for WordPress, Blogger...

Post your related queries below ...

comments powered by Disqus
Powered by Blogger.
 
© 2012 Learn Java by Examples Template by Hubber Spot