Aspect Oriented Programming Using Spring AOP – An Introduction [Part 2]

In my last article, I’ve explained how to enable @AspectJ support in a Spring application. And today, in the last post of the series, I’ll show you a small example code that uses the AOP concepts for logging method calls. Before reading this post, I’ll suggest you to read the basics of AOP and Using AOP in Spring posts which will help you to understand AOP better.

Spring AOP – Hello World Example:

The below steps explains how to get started with the Hello World example using Spring AOP for logging the method call details, when ever the HelloWorld class’s methods are called by the external world.

1. Firstly, you need to set up the @AspectJ support in Spring by adding the required JARs and enabling the @AspectJ in the Spring configuration file (for example, applicationContext.xml). Please read this post how to do this.
2. Once the environment is setup, next task will be to create the world fame POJO class ‘Hello World’. Below is the code for the same.

   package com.veerasundar.aop.demo
   
   public class HelloWorld{
      public void sayHello(String name){
         System.out.println("Hello " + name);
      }
   
      public static void main(String args[]){
         HelloWorld hw = new HelloWorld();
         hw.sayHello();
      }
   }
   

3. Now we will add our logging code, using AOP, so that whenever the method sayHello is called, that call will be logged. Below is our Aspect code.

   package com.veerasundar.aop.aspects
   import org.aspectj.lang.annotation.Aspect;
   import org.aspectj.lang.annotation.Pointcut;
   import org.aspectj.lang.annotation.Before;
   
   @Aspect
   public class HelloWorldLoggerAspect{
      @Pointcut("execution(* com.veerasundar.aop.demo.*.*(..))")
       public void helloWorldMethods(){}
   
      @Before("helloWorldMethods()")
      public void logMethodCall(){
         System.out.println("The Hello World Method has been called.");
      }
   }
   

   So, what are we doing here in this HelloWorldLoggerAspect? In the code,

   1. After the package declaration, we are importing the AspectJ related classes to use in our code.
   2. Then we are declaring that the class HelloWorldLoggerAspect is an aspect using the @AspectJ annotation. (Note: to enable this kind of annotation based configuration, you need to have AspectJ jars in your classpath and you need to configure the Spring configuration file properly. See this article enabling @AspectJ in Spring AOP for more details.)
   3. Then inside the class, we are declaring pointcut which matches all the methods inside the com.veerasundar.aop.demo package. So, all the methods inside the mentioned package will be matched for the helloWorldMethods pointcut (note that, Spring supports only method matching in pointcut definitions). And the pattern inside the @Pointcut definition is AspectJ style pattern. Please refer AspectJ documentation for more information on the same. In our code, we are saying that “what ever the methods with any return type and which takes any number of parameters and which resides inside the com.veerasundar.aop.demo package” match it as helloWorldMethods pointcut.
   4. Finally in using the @Before annotation, we are defining our Advice code, which will be executed before the helloWorldMethods(). i.e. When ever the methods which are matching the helloWorldMethods pointcut are called, our logMethodCalls will be executed first and then the control will go to the actual function called. This process is called as Weaving and the Spring AOP takes care of it.
4. There is one more step that needs to be done – configuring the spring configuration file. Add the below lines to your Spring config file, to declare the aspect HelloWorldLoggerAspect.

   <aop:aspectj-autoproxy/> <bean id="helloWorldLoggerBean" class="com.veerasundar.aop.aspects.HelloWorldLoggerAspect" />
   

5. With that configurations are all done, now when ever a call made to the sayHello() method inside the HelloWorld object, the call will be logged (i.e. a message will appear on the console. in real world applications, this will a be log message).

So, with this post, I’m concluding the AOP series. I hope that the series would be useful to you to have basic understanding about the AOP. Please let me what do you think about this series through your comments.