Language Versus Framework

To contrast AspectJ against a framework AOP implementation, we look at the approach to defining aspects taken by AspectWerkz.

Chapter 6 provides an overview of metadata annotations .

To compare how the approach of the AspectWerkz framework to AOP differs from that of AspectJ, consider the code snippet in Listing 11-4, which depicts a plain Java implementation of the AuditingAspect from the AspectJ example.

Listing 11-4. AspectWerkz AuditingAspect Class

package stock;

import org.codehaus.aspectwerkz.joinpoint.JoinPoint;

public class AuditingAspect {

  public void beforeAddStockItem(JoinPoint joinPoint) {
    .
    .
    .
  }

  public void afterAddStockItem(JoinPoint joinPoint) {
    .
    .
    .
  }
}

The code snippet in Listing 11-4 is devoid of any AOP language constructs, although there are a few hints such as the JoinPoint class. We look first at how an external XML definition file transforms the class into a full-fledged aspect.

XML Aspect Definition

One of the first approaches of many of the AOP frameworks was to declare pointcut designators and the location of advice methods using XML definition files. Listing 11-5 shows a sample of an AspectWerkz definition file that turns the plain AuditingAspect Java class into an aspect.

Listing 11-5. XML Definition File aop.xml

<aspectwerkz>
  <system id="stockcontrol">
    <package name="stock">

<!-- Define the class implementing the aspect -->

<aspect class="stock.AuditingAspect"
              deployment-model="perInstance">

<!-- Named pointcut -->

<pointcut name="auditStockItem"
                   expression="call(* Warehouse.add(..))"/>

<!-- Bind aspect before method to pointcut -->

<advice name="beforeAddStockItem"
                 type="before"
                 bind-to="auditStockItem"/>

<!-- Bind aspect after method to pointcut -->

<advice name="afterAddStockItem"
                 type="after"
                 bind-to="auditStockItem"/>

      </aspect>
    </package>
  </system>
</aspectwerkz>

Comparing the aspect definition in the XML file against the example from AspectJ reveals many similarities. Most notable is the syntax for the pointcut declaration. For example, here is the declaration for the pointcut in AspectJ:

pointcut auditStockItem() :

call(* Warehouse.add(..));

Compare this to the corresponding declaration in the AspectWerkz configuration:

<pointcut name="auditStockItem"
          expression=

"call(* Warehouse.add(..))"/>

Note

Supporters of AspectJ emphasize that these definition files present a similar learning curve to the new language constructs of AspectJ. This is a valid argument, but the strength of AspectWerkz lies in its ability to bring AOP to an existing system without requiring a move to an AOP compiler.

Aspects as Metadata Annotations

Later versions of AspectWerkz offer an alternative mechanism for specifying aspects using metadata annotations. This method moves AspectWerkz closer to the AspectJ model by embedding AOP constructs as annotations within the language. The advantage of embedded annotations over an external XML file is that all code related to the aspect resides within a single file.

Listing 11-6 shows the AuditingAspect class but this time adorned with AspectWerkz annotations.

Listing 11-6. AuditingAspect Class with Metatags

package stock;

import org.codehaus.aspectwerkz.joinpoint.JoinPoint;

/**
 *

@Aspect

perInstance
 */
public class AuditingAspect {

  /**
   *

@Before

call(* Warehouse.add(..))
   */
  public void beforeAddStockItem(JoinPoint joinPoint) {
    .
    .
    .
  }

  /**
   *

@After

call(* Warehouse.add(..))
   */
  public void afterAddStockItem(JoinPoint joinPoint) {
    .
    .
    .
  }
}

This new version of the AuditingAspect now bears a strong resemblance to the AspectJ version.

Here is the declaration of the before advice from the AspectJ example:

before() :

auditStockItem() {...}

AspectWerkz produces a similar construct using metatags. The metadata also identifies the join points for the advice.

/**
 *

@Before

call(* Warehouse.add(..))
 */
public void beforeAddStockItem(JoinPoint joinPoint) {...}

Metadata annotations replace the previous XML definition file, although a smaller file is still required to alert the AspectWerkz framework to the presence of aspects within the application.

Precompilation of AOP metadata information into the application makes it available at runtime for the AspectWerkz weaver . However, moving to J2SE 5.0 removes the need for the precompilation step.

Tip

The introduction of metadata annotations with J2SE 5.0 offers other interesting advantages to AOP frameworks. In addition to supporting the annotation model used by AspectWerkz, annotations make excellent join point candidates because they are unambiguous. For example, the declaration call(@annotation * *(..)) offers the AOP developer more options when determining the location of join points within the application.