Spring AOP and Annotation based AspectJ

The concept

Recently I had to work on a requirement that asked that logs be kept when anyone performs certain actions upon the database.

For example if some chose to remove an item from the database – the action, who performed it, when it was performed and any extra information should be noted in the database.

Implementing this can be performed in a variety of ways. We could have simply told developers to call a function within any database methods to log the action. However Spring AOP provides a better way of doing this.

The idea

To make it easier to store the logs I wanted users to simply be able to annotate any methods they felt needed logging in the message.

Then using AspectJ we would have code that would intercept the methods and log the action in the database. All developers would need to do is very simply annotate their methods.

The Annotation

First of all I had to create the Java Method annotation that can be placed above the required methods.

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface LogAction {
	String actionPerformed();
}

The annotation simply has one parameter that allows the developer to specify the action performed such as ‘object deleted’ etc.

The aspect class

Next was to write the Spring aspect class which will perform the actual logging of the action

First of all we write a simple class and add the @Aspect annotation before the class

@Aspect
public class MyAspect

Next we need to define the Pointcut. As a Spring defintion a Pointcut is:

Pointcut: a predicate that matches join points. Advice is associated with a pointcut expression and runs at any join point matched by the pointcut (for example, the execution of a method with a certain name). The concept of join points as matched by pointcut expressions is central to AOP, and Spring uses the AspectJ pointcut expression language by default.

I’m writing a simple point cut that matches any public methods. This is coded like so:

@Pointcut(value="execution(public * *(..))")
public void anyPublicMethod() { }

The last part of the Aspect class is the Advice. Spring defines the advice as:

Advice: action taken by an aspect at a particular join point. Different types of advice include “around,” “before” and “after” advice. Many AOP frameworks, including Spring, model an advice as an interceptor, maintaining a chain of interceptors around the join point.

I need my advice to handle the “around” advice and only methods with my @LogAction annotation

To do this I used the following method:

@Around("anyPublicMethod() && @annotation(logAction)")
public Object logAction(ProceedingJoinPoint pjp, LogAction logAction) throws Throwable {
}

The method uses my anyPublicMethod Pointcut and the @annotation(logAction) to match only public methods with the LogAction annotation specified.

I have also included the ProceedingJoinPoint parameter so I can access the various arguments in the annotated method.

The final Aspect class is as follows:

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
 
@Aspect
public class MyAspect{
 
	@Pointcut(value="execution(public * *(..))")
	public void anyPublicMethod() {
	}
 
	@Around("anyPublicMethod() && @annotation(logAction)")
	public Object logAction(ProceedingJoinPoint pjp, LogAction logAction) throws Throwable {
 
		// Do what you want with the actionperformed
		String actionPerformed = logAction.actionPerformed();
 
		// Do what you want with the join point arguments
		for ( Object object : pjp.getArgs()) {
			System.out.println(object);
		}
 
		return pjp.proceed();
	}
}

Updating the Spring app config

To ensure that our @Aspect annotated class is picked up by Spring you simply need to add the following to your app-config.xml

<aop:aspectj-autoproxy/>
<bean id="myAspect" class="package.to.my.MyAspect" />

This assumes that you have the aop namespace within your app-config beans definition like so

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

Setting up intercepted methods

The final step is to mark the methods we want to be intercepted

This is as easy as doing the following

@LogAction(actionPerformed="doSomething")
public void doSomething(MyObject someParameter) {
}

Now whenever that method is executed we will firstly execute our Aspect code.