A simple application to demonstrate how to implement After Advice using @AspectJ Annotation-Driven AOP in Java.
Step 1:- Create a Interface Sum.java
Step 2:- SumImpl.java Service Implementation Class
Step 3:- After Advice Implementation class
Step 4 :- Spring Configuration file
Step 5:- Test class
Output of the program :
Step 1:- Create a Interface Sum.java
package com.hubberspot.aspectj.annotation.afteradvice; // Its a simple interface for the Sum service. // It contains one single method called as addition(). // This method takes in two arguments both of the type // int. public interface Sum { public int addition(int a , int b); }
Step 2:- SumImpl.java Service Implementation Class
package com.hubberspot.aspectj.annotation.afteradvice; // It is the implementation class for the // Sum service. It just calculates and returns // sum of two numbers passed to it as arguments. public class SumImpl implements Sum { @Override public int addition(int a, int b) { System.out.println("Addition method called ..."); return (a + b); } }
Step 3:- After Advice Implementation class
package com.hubberspot.aspectj.annotation.afteradvice; import org.aspectj.lang.JoinPoint; import org.aspectj.lang.annotation.After; import org.aspectj.lang.annotation.Aspect; //@Aspect annotation treats this Java class as //Aspect. Its not ordinary POJO class. @Aspect public class AfterSumAdvice { // Method after() is a after advice // implemented by providing @After annotation. // This annotation takes in Pointcut expression, which // indicates when this advice executes. // This Pointcut expression tells that after() advice // will execute addition method of Sum interface. // The after advice takes in JoinPoint which here represents // method execution. @After("execution(* com.hubberspot.aspectj.annotation.afteradvice.Sum.addition(..))") public void after(JoinPoint joinPoint) { System.out.println("Call after addition method ..."); } }
Step 4 :- Spring Configuration file
|
Step 5:- Test class
package com.hubberspot.aspectj.annotation.afteradvice; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class SumTest { 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 before_advice.xml placed // at classpath of our application. ApplicationContext context = new ClassPathXmlApplicationContext("after_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 Sum object. Without implementing new keyword we // have injected object of Sum just by reading an xml // configuration file. Sum sum = (Sum)context.getBean("sum"); int result = sum.addition(5, 10); System.out.println("Result = " + result); } }
Output of the program :