A simple application to demonstrate how to implement After Throwing Advice using Classic Spring Proxy-Based AOP in Java.
Step 1:- Divide.java Interface
Step 2:- DivideImpl.java Service Implementation Class
Step 3:- After Throwing Advice Implementation class
Step 4 :- Spring Configuration file
Step 5:- Test class
Output of the program :
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
|
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 :