An Introduction to Aspect-Oriented programming with JBoss AOP

Lightweight Advice Methods

The advices that we have seen so far have been around advices, which have been part of JBoss AOP since its inception. They allow you to add behaviour both before or after invoking the target joinpoint. As seen, these all take a parameter of type Invocation, or a subclass thereof. In a heavily woven application, every time you want to call a joinpoint that has advice methods applied to it, the AOP framework needs to instantiate the Invocation object, and this can pose some overhead. To bring JBoss AOP more in line with what is offered by other AOP frameworks, we have introduced the concept of lightweight advice methods, which do not require the instantiation of an Invocation object. The Invocation object contains quite a lot of conceptual information about what is being called, but we can still obtain most of this using other means. Going back to our logging example, we can rewrite the LoggingAspect for what to do when fields are written to:

package bank;

import org.jboss.aop.advice.annotation.Arg;
import org.jboss.aop.advice.annotation.JoinPoint;
import org.jboss.aop.advice.annotation.Target;
import org.jboss.aop.joinpoint.FieldAccess;

public class LoggingAspect
{
   public void logBefore(@JoinPoint FieldAccess fieldAccess, @Target BankAccount account, @Arg int value)
   {
      System.out.println("F: setting field " + fieldAccess.getField().getName() + " for BankAccount " + account.getAccountNumber());
      System.out.println("F: Field old value " + account.getBalance());
      System.out.println("F: New value will be " + value);
   }


   public void logAfter(@Target BankAccount account)
   {
      System.out.println("F: Field new value " + account.getBalance());
      System.out.println("F: Done");
   }

}

The original log method has been split into two methods. A before advice logBefore() which will be triggered before the field is written to, and an after advice logAfter() that will be triggered after the field is written to. For the logBefore() method the fieldAccess parameter annotated with @JoinPoint contains information about the field, the @Target annotated account parameter receives the object whose field we are writing to, and the @Arg annotated value parameter receives the new value we are setting the field to. Similarly, for the logAfter() method the account parameter annotated with @Target receives the object whose field we set. Note that since lightweight advice methods never receive an Invocation parameter there is no need to call Invocation.invokeNext(). The JBoss AOP framework knows which advices to call before and after the joinpoint is called. To bind these advices we use the following xml:

<aop>
   <aspect class="bank.LoggingAspect"/>

   <bind pointcut="set(* bank.BankAccount->balance)">
      <before aspect="bank.LoggingAspect" name="logBefore"/>
      <after aspect="bank.LoggingAspect" name="logAfter"/>
   </bind>
</aop>

This is similar to our previous logging example, but instead of using “around” in our binding, we now have a “before” and “after” entry, specifying that logBefore() should be called before the field is written to, and logAfter() should be called after the field is written to. Running this example we get the following output:

*** Creating account 1
*** Bank Account constructor
*** BankAccount.credit()
F: setting field balance for BankAccount 1
F: Field old value 0
F: New value will be 150
F: Field new value 150
F: Done
*** Creating account 2
*** Bank Account constructor
*** BankAccount.credit()
F: setting field balance for BankAccount 2
F: Field old value 0
F: New value will be 230
F: Field new value 230
F: Done
*** Balance acount 1: 150
*** Balance acount 2: 230
*** Transfer 50 from account 1 to account 2
*** BankAccount.debit()
F: setting field balance for BankAccount 1
F: Field old value 150
F: New value will be 100
F: Field new value 100
F: Done
*** BankAccount.credit()
F: setting field balance for BankAccount 2
F: Field old value 230
F: New value will be 280
F: Field new value 280
F: Done
*** Balance acount 1: 100
*** Balance acount 2: 280

In addition to “before” and “after”, you also have “throwing” advices which are called when the target joinpoint throws an exception, and “finally” advices which are called after the target joinpoint  regardless of if it resulted in an exception or not. As we have seen “after” advices are called after the target joinpoint has been called, if no exception was thrown.

The code for this example can be found in the listing4/ folder of the download bundle.