An Introduction to Aspect-Oriented programming with JBoss AOP

JBoss Application Server ships with support for aspect-oriented programming, so you can use AOP in your applications deployed in JBoss AS. JBoss AS 5, which is currently available as a community release, has AOP built into its core. However, JBoss AOP is also available as a standalone framework for use in your other applications.

This article will take a simple example, and use JBoss AOP to add to its behaviour, while explaining some of the core functionality of JBoss AOP. We will look at encapsulating cross-cutting concerns into aspects, have a look at around advices vs the new lightweight advices in the upcoming JBoss AOP 2.0 release, and also look at using interface-introductions and mixins to add interfaces to your classes.

Table of Contents

• Our Core Application
• Logging as a Cross-Cutting Concern
• Externalising Security Checks
• Lightweight Advice Methods
• Observer with Introductions and Mixins

Our Core Application

package bank;
public class BankAccount 
{
   int accountNumber;
   int balance;
   
   public BankAccount(int accountNumber)
   {
      System.out.println("*** Bank Account constructor");
      this.accountNumber = accountNumber;
   }
   
   public int getAccountNumber()
   {
      return accountNumber; 
   }
   
   public int getBalance()
   {
      return balance;
   }
   
   public void debit(int amount)
   {
      System.out.println("*** BankAccount.debit()");
      balance -= amount;
   }
   
   public void credit(int amount)
   {
      System.out.println("*** BankAccount.credit()");
      balance += amount;
   }
}

In addition it has a main Bank class:

package bank;

import java.util.HashMap;
import java.util.Map;

public class Bank
{
   static Map bankAccounts = new HashMap();
   
   public static void transfer(BankAccount from, BankAccount to, int amount)
   {
      from.debit(amount);
      to.credit(amount);
   }
   
   public static void main(String[] args)
   {
      System.out.println("*** Creating account 1");
      BankAccount acc1 = new BankAccount(1);
      acc1.credit(150);
      bankAccounts.put(acc1.getAccountNumber(), acc1);
      
      System.out.println("*** Creating account 2");
      BankAccount acc2 = new BankAccount(2);
      acc2.credit(230);
      bankAccounts.put(acc2.getAccountNumber(), acc2);
      
      System.out.println("*** Balance acount 1: " + acc1.getBalance());
      System.out.println("*** Balance acount 2: " + acc2.getBalance());
      
      //Transfer some money
      System.out.println("*** Transfer 50 from account 1 to account 2");
      transfer(acc1, acc2, 50);
      
      System.out.println("*** Balance acount 1: " + acc1.getBalance());
      System.out.println("*** Balance acount 2: " + acc2.getBalance());
   }
}

As you can see, we create two bank accounts with their account numbers, set the initial balances, and then transfer 50 from account1 to account 2. Running this simple example we get the following expected output:

*** Creating account 1
*** Bank Account constructor
*** BankAccount.credit()
*** Creating account 2
*** Bank Account constructor
*** BankAccount.credit()
*** Balance acount 1: 150
*** Balance acount 2: 230
*** Transfer 50 from account 1 to account 2
*** BankAccount.debit()
*** BankAccount.credit()
*** Balance acount 1: 100
*** Balance acount 2: 280

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