How to implement After Throwing Advice using Classic Spring Proxy-Based AOP in Java ?.

A simple application to demonstrate how to implement After Throwing Advice using Classic Spring Proxy-Based AOP in Java.

Step 1:- Divide.java Interface

package com.hubberspot.classic.aop.afterthrowsadvice;

// 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 Divide {

 public int divide(int a , int b);

}

Step 2:- DivideImpl.java Service Implementation Class

package com.hubberspot.classic.aop.afterthrowsadvice;

// It is the implementation class for the 
// Division service. It just calculates and returns 
// division of two numbers passed to it as arguments.
// If denominator passed to it as zero than 
// new ArithmeticException() is thrown.

public class DivideImpl implements Divide {

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

  if(b != 0) {

   return a/b;

  }

  else {

   throw new ArithmeticException();

  }

 }

}

Step 3:- After Throwing Advice Implementation class

package com.hubberspot.classic.aop.afterthrowsadvice;

import java.lang.reflect.Method;
import org.springframework.aop.ThrowsAdvice;

// This class is a simple After Throwing Advice which implements 
// interface called as ThrowsAdvice. This interface is the 
// marker interface that provides Spring additional info 
// for handling a thrown exception. We have defined a method 
// by name afterThrowing.

public class AfterThrowsDivisionAdvice implements ThrowsAdvice {

 // All the parameters to this method are optional except 
 // Exception exception that indicates which exception is to be
 // handled by this advice.

 public void afterThrowing(Method method, Object[] args, Object target, 
   Exception exception) {

  System.out.println("Exception is thrown on method " + method.getName());

 }

}

Step 4 :- Spring Configuration file

1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30. 31. 32. 33. 34. 35. 36. 37. 38. 39. 40. 41. 42. 43. 44. 45. 46. 47. 48. 49. 50. 51. 52. 53. 54. <?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"> <!-- After Throwing Advice:- Advice is been configured as beans --> <bean id="afterThrowsDivision" class="com.hubberspot.classic.aop.afterthrowsadvice.AfterThrowsDivisionAdvice" /> <!-- Implementation Class --> <bean id="divideImpl" class="com.hubberspot.classic.aop.afterthrowsadvice.DivideImpl" /> <!-- Proxy Implementation Class:- This configuration binds advices to the implementation code using a proxy factory bean. In order to apply the advice final bean has to be proxied. Spring's ProxyFactoryBean is a factory that creates a proxy which implies one or more interceptors to bean --> <bean id="divide" class="org.springframework.aop.framework.ProxyFactoryBean"> <!-- This proxy bean definition has three properties 1. target :- It tells ProxyFactoryBean to which bean it will be making proxy. 2. intercepterNames :- Interceptor Names property is configured as a list of interceptor or advices which is being applied to this proxy. 3. proxyInterfaces :- It just tells to ProxyFactoryBean that which interface Proxy bean has to implement. --> <property name="target"> <ref bean="divideImpl" /> </property> <property name="interceptorNames"> <list> <value>afterThrowsDivision</value> </list> </property> <property name="proxyInterfaces"> <value>com.hubberspot.classic.aop.afterthrowsadvice.Divide</value> </property> </bean> </beans>

Step 5:- Test class

package com.hubberspot.classic.aop.afterthrowsadvice;

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 after_throwing_advice.xml placed
  // at classpath of our application.


  ApplicationContext context = 
    new ClassPathXmlApplicationContext("after_throwing_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.

  Divide divide = (Divide)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 :