Building Spring 2 Enterprise Applications: Chapter 4: Spring AOP 2.0

This bean itself is not touched or affected in any way. In fact, the messagePrinter bean is not aware that it's being declared as an aspect. This tag by itself won't trigger the creation of proxy objects during auto-proxy creation. The tag only declares an aspect that can hold zero or more pointcut and advice/pointcut declarations in XML.

Next, we'll load xml-aspect-context.xml into a test case to verify the tournamentMatchManager bean is proxied correctly. The test case in Listing 4-26 shows MessagePrintingXmlAspectIntegration Tests, which extends MessagePrintingAspectIntegrationTests from Listing 4-6.

Listing 4-26. Test Case to Verify the XML Aspect Works As Expected

package com.apress.springbook.chapter04; 

public class MessagePrintingXmlAspectIntegrationTests extends 
MessagePrintingAspectIntegrationTests { 
protected String[] getConfigLocations() { 
  return new String[] { 
     "classpath:com/apress/springbook/chapter04/" + 
     "xml-aspect-context.xml" 
   }; 
  } 
} 

=== GOING TO CALL METHOD ON BEAN FROM CONTAINER === 
Attempting to start tennis match! 
=== FINISHED CALLING METHOD ON BEAN FROM CONTAINER === 
=== GOING TO CALL METHOD ON NEWLY CREATED OBJECT === 
=== FINISHED CALLING METHOD ON NEWLY CREATED OBJECT === 

Pointcut Declaration and Reuse with XML

Listing 4-27. Reusing a Pointcut Declared in an @AspectJ-Style Aspect

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

  <aop:config> 
    <aop:aspect ref="securityEnforcer"> 
      <aop:before method="denyAccessToAll" 
                 pointcut="com.apress.springbook.chapter04.aspects. --> 
      SystemPointcutsAspect.inServiceLayer()"/> 
</aop:aspect> 
</aop:config> 

  <bean id="securityEnforcer" 
    class="com.apress.springbook.chapter04.SecurityEnforcer"/> 
</beans> 

Listing 4-28. Declaring and Reusing a Pointcut in an XML Aspect

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

  <aop:config> 
    <aop:aspect ref="securityEnforcer"> 
      <aop:pointcut id="inServiceLayer" 
                expression="within(com.apress.springbook.chapter04..*)"/> 
      <aop:before method="denyAccessToAll" 
                pointcut-ref="inServiceLayer"/> 
    </aop:aspect> 
  </aop:config> 

  <bean id="securityEnforcer" 
    class="com.apress.springbook.chapter04.SecurityEnforcer"/> 
</beans> 

The <aop:pointcut> tag declares a pointcut and takes a name (id) and pointcut expression (expression). This pointcut is then reused by the <aop:before> tag (pointcut-ref).

Listing 4-29 shows a pointcut that is declared inside the <aop:config> tag. This pointcut can be reused inside <aop:aspect> tags in this and other Spring XML files.

Listing 4-29. Declaring a Pointcut Outside an Aspect and Reusing It Inside an XML Aspect

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

  <aop:config> 
    <aop:pointcut id="inServiceLayer" 
expression="within(com.apress.springbook.chapter04..*)"/> 
<aop:aspect ref="securityEnforcer"> 
<aop:before method="denyAccessToAll" 
pointcut-ref="inServiceLayer"/> 
</aop:aspect> 
</aop:config> 

  <bean id="securityEnforcer" 
    class="com.apress.springbook.chapter04.SecurityEnforcer"/> 
</beans> 

Advice Declaration in XML

Now we'll look at how to declare each of the different advice types in XML. Later, in the "Binding Advice Arguments" section, we'll rewrite the aspects we've used to explain how to bind advice arguments on @AspectJ-style advice methods and show the equivalent XML, so that you can easily compare the two.

Listing 4-30 shows an example for a before advice XML declaration. Listing 4-30. Before Advice Declaration in XML

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



  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:before method="printMessageToInformMatchStarts" 
pointcut="execution(* startMatch(..))"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

Listing 4-31. After Returning Advice Declared in XML

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

  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:after-returning method="printMessageToInformMatchHasStarted" 
pointcut="execution(* startMatch(..))"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
<!-- properties omsitted --> 
</bean> 
</beans> 

Listing 4-32. After Throwing Advice Declared in XML

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





  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:after-throwing method="printMessageWhenMatchIdentifierIsNotFound" 
pointcut="execution(* startMatch(..) throws --> 
com.apress.springbook.chapter04.UnknownMatchException)"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

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

  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:after method="printMessageWhenStartMatchAttemptIsOver" 
pointcut="execution(* startMatch(..))"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

Listing 4-34. The printMessageWhenStartMatchAttemptIsOver() method on MessagePrinter

package com.apress.springbook.chapter04; 

public class MessagePrinter { 
  public (.*?) { 
      System.out.println("Tried to start a match and this attempt is now over!");    } 
} 

Again, there are no surprises since the after (finally) advice XML declaration is very similar to the @AspectJ-style declaration we've discussed previously.

And last, but not least, is the around advice as an XML declaration. As you may suspect, this advice type requires the declaration of a ProceedingJoinPoint argument in the advice method. This binds the MessagePrinter class to the AspectJ API. Listing 4-35 shows an around advice declaration in XML.

Listing 4-35. Around Advice Declared in XML

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

  <aop:config> 
    <aop:aspect ref="messagePrinter"> 
<aop:around method="controlStartMatchMethodExecution" 
pointcut="execution(* startMatch(..))"/> 
</aop:aspect> 
</aop:config> 

  <bean id="messagePrinter" 
    class="com.apress.springbook.chapter04.MessagePrinter"/> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

Listing 4-36. The controlStartMatchMethodExecution() method on MessagePrinter

package com.apress.springbook.chapter04; 

import org.aspectj.lang.ProceedingJoinPoint; 

public class MessagePrinter { 
  public Object controlStartMatchMethodExecution(ProceedingJoinPoint pjp) 
    throws Throwable { 
  System.out.println("A match is about to be started!"); 
try { 
Object result = pjp.proceed(); 
System.out.println("The match has been started successfully!"); 
return result; 
} catch (Throwable t) { 
System.out.println("Oops, something went wrong while starting the match."); 
throw t; 
  } 
} 
} 

The controlStartMatchMethodExecution() method on MessagePrinter is a classic example of interception advice.

Advice Ordering in XML

• Advices declared in the same XML aspect that is executed on one join point are ordered according to their order of declaration in the XML file.
• If you want to control the order of advice declared in different XML aspects, you must implement the org.springframework.core.Ordered interface on the classes where advice methods are declared (like the MessagePrinter class in Listing 4-24).

By implementing the Ordered interface, you can also control the order between XML advice and @AspectJ-style advice on the same join point.

Advisors with AspectJ Pointcuts

When you add an advisor to the Spring container and configure auto-proxy creation, its pointcut can match join points on beans in the container; when it does, proxy objects will be created.

Consider the example in Listing 4-37. Note that you must define advisors before aspects.

Listing 4-37. Configuring a PointcutAdvisor with the <aop:advisor> Tag

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

  <aop:config> 
    <aop:advisor advice-ref="loggingAdvice" pointcut="execution(* startMatch(..))"/> 
</aop:config> 

  <bean id="loggingAdvice" 
    class="org.springframework.aop.interceptor.CustomizableTraceInterceptor"> 
<property name="enterMessage" 
value="Entering $[methodName] on $[targetClassShortName]"/> 
</bean> 

  <bean id="tournamentMatchManager" 
    class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

Auto-proxy creation will create a proxy for the tournamentMatchManager bean, since its startMatch() method is matched by the advisor's pointcut.

The advisors take part in auto-proxy creation, which means their advice objects can be executed together with other advices on the same join point. To set the order of an advisor, you can configure the order attribute, as shown in Listing 4-38.

Listing 4-38. Setting the Order of the Advice for This Advisor

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

  <aop:config> 
    <aop:advisor advice-ref="loggingAdvice" 
              order="20" 
              pointcut="execution(* startMatch(..))"/> 
</aop:config> 

  <bean id="loggingAdvice" 
    class="org.springframework.aop.interceptor.CustomizableTraceInterceptor"> 
<property name="enterMessage" 
              value="Entering $[methodName] on $[targetClassNameShort]"/> 
</bean> 

  <bean id="tournamentMatchManager" 
              class="com.apress.springbook.chapter04.DefaultTournamentMatchManager"> 
    <!-- properties omitted --> 
  </bean> 
</beans>

Proxy Type Selection in XML

Listing 4-39. Forcing the Use of CGLIB Proxy Objects

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

    <aop:config proxy-target-class="true"> 

  </aop:config> 

</beans> 

So, now that you've seen the two different ways to configure Spring AOP, let's look at pointcuts in more detail.

Working with Pointcuts

• All methods of a specific class
• All methods of all classes in a specific package
• All methods of all classes in a specific package and its subpackages
• All methods with a specific annotation
• All methods of a class with a specific annotation
• All methods with a specific name
• All methods where the name contains a specific string
• All methods with specific argument types

• Pointcut designators: We've already used execution() and within(). Spring AOP supports more designators, as you'll see in the following examples. They narrow down the selection of the join points based on some property. Other constructs in this list are used in combination with these designators.
• Boolean operators: You can combine pointcut designators to narrow down the selection. The AND (&&) and OR (||) operators, as well as the NOT operator (!), are supported.
• Class names: Often, you need to specify class names, such as to narrow down the selection to a target type or a method argument type. These class names must always be fully qualified (including the full package name), even for classes in the java.lang package.
• Visibility operators: You can narrow the search to only public or protected methods.
• Wildcards: Frequently, you will want to use a wildcard operator. Supported wildcard operators are the asterisk (*) for any method or class name or any argument type and double dot (..) for zero or more arguments.
• Method names: These can be the full name, a partial match of the name, or a wildcard (any name).
• Annotations: You can select methods based on annotations, as discussed in the next sections.

Let's start with how to select methods directly.

Selecting Methods Directly

Selecting on Method Names

Listing 4-40 shows a pointcut that selects all relax(), enjoy(), and chillOut() methods.

Listing 4-40. Selecting Some Enjoyable Methods

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("execution(* relax(..)) || execution(* enjoy(..)) || " + 
      "execution(* chillOut(..))") 
  public void goodTimes() {  } 
} 

You can also use wildcards in method names. Listing 4-41 shows a pointcut that selects all methods whose names start with do.

Listing 4-41. Selecting All Methods Whose Names Start with do

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("execution(* do*(..))") 
  public void performAction() {  } 
} 

Selecting methods on their names is one of the most basic pointcut criteria. They can be combined with other criteria to narrow the selection to make sure only the intended methods are selected.

One powerful way to narrow down the method selection is to also select on method arguments.

Selecting on Argument Types

• All methods without arguments
• All methods with one argument, regardless of its type
• All methods with one java.lang.String argument
• All methods with java.lang.String as the first argument and zero or more other arguments
• All methods with java.lang.String as the second argument and zero or more other arguments

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("execution(* *())")   
  public void allMethodsWithoutArguments() {} 

  @Pointcut("execution(* *(*))")   
  public void allMethodsWithOneArgumentRegarlessOfType() {} 

  @Pointcut("execution(* *(java.lang.String))")   
  public void allMethodsWithOneArgumentOfTypeString() {} 

  @Pointcut("execution(* *(java.lang.String,..))")   
  public void  
  allMethodsWithFirstArgumentOfTypeStringAndZeroOrMoreOtherArguments() {} 
@Pointcut("execution(* *(*,java.lang.String,..))")   
  public void  
      allMethodsWithSecondArgumentOfTypeStringAndZeroOrMoreOtherArguments () {  } 
} 

Listing 4-43. Selecting Methods Based on Actual Argument Values Instead of Argument Declaration

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 
import org.aspectj.lang.annotation.Before; 


@Aspect 
public class MessagePrintingAspect { 

  @Before("args(java.util.Hashtable)")   
  public void printWarningForUsageOfHashtable() { 
    System.out.println("Warning: java.util.Hashtable is passed as argument!"); 
  } 
} 

Three method signatures will all be selected by this pointcut:

public java.util.List getUniqueValuesFromMap(java.util.Map map) { … } 

public Object getLowestKeyValueFromMap(java.util.Map map) { … } 

public String transformObjectToString(Object o) { … }

These three method signatures will be matched by the pointcut in Listing 4-43 during autoproxy creation since Spring AOP has no way of determining which argument value will be passed to these methods. Spring AOP knows any of these single-argument methods can be potentially matched by this pointcut. But even though Spring AOP will decide to create a proxy object for beans that implement any of these methods, that does not mean that the advice will always be executed for these methods. Spring AOP will need to do a match each time these methods are executed to decide whether or not to execute the advice, based on the argument value that is passed. This process may have the undesired side effect of creating many more proxy objects than intended.

In Spring AOP, proxy creation is relatively inexpensive and of no concern for singleton beans.

It's a different story for prototype beans, since a proxy object needs to be created each time it's requested via dependency lookup or dependency injection. You should be aware of the performance impact dynamic pointcuts may have on prototype bean creation in the Spring container if you're going to create many prototype objects.

Selecting on a Return Type Declaration

execution(* startMatch(..)) 

The asterisk (*) in this pointcut matches any return type; the return type and the method signature are both required fields for the execution() pointcut designator. We can change this pointcut to match only startMatch() methods that return the type we expect, like this:

execution(com.apress.springbook.chapter04.Match startMatch(..)) 

Why do we want to specify the return type when we have only one startMatch() method in the entire application and * is much less typing?

When writing pointcuts, you need to be careful about which join points you will select. Any join point that is selected as an unintended side effect is overhead. When applications grow, many small overheads often become significant.

You can also use the void keyword as the return type to select only methods that don't return anything.

---

Note

Selecting methods on their return type declaration does not require a dynamic pointcut since Spring AOP can look at static method signatures at auto-proxy creation time.

---

Selecting on a throws Declaration

To match an exception type, it must be declared in method signatures. As you are probably aware, Java has two exception types:

Unchecked exceptions: These are unrecoverable exceptions, meaning there is usually little or nothing an application can do in response to these exceptions when they occur. Because of their unrecoverable nature, Java does not require these exceptions to be declared in method signatures or caught by application code. Exceptions that are type-compatible with java.lang.Error and java.lang.RuntimeException are unchecked.

Checked exceptions: These are usually recoverable exceptions, meaning the application logic can do something significant in response to their occurrence. These exceptions must be either caught in a try/catch block or declared in the method signature to pass them on to the caller.

Exceptions that are not type-compatible with java.lang.Error and java.lang.Runtime Exception are checked.

Checked exceptions must be declared in method signatures if not caught in the method body; unchecked exceptions may be declared, but this is not required. Unchecked exceptions are sometimes declared in method signatures to inform callers they may be thrown. However, even when unchecked exceptions are declared in method signatures, they don't need to be caught by the caller.

This leads us to conclude the following:

• Checked exceptions are typically declared in method signatures.
• Unchecked exceptions are often not declared in method signatures.

Since pointcuts can match only methods that declare exceptions in their signatures, you will typically be able to match only against checked exceptions, as shown in Listing 4-44.

Listing 4-44. Matching Against java.io.IOException

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 
import org.aspectj.lang.annotation.Before; 


@Aspect 
public class MessagePrintingAspect { 

  @Before("execution(* *(..) throws java.lang.IOException)")   
  public void printWarningIOExceptionMayBeThrown() { 

    System.out.println("Warning: IOException may be thrown. Brace yourselves!"); 
  } 
} 

public String readFileToString(java.io.File file) throws java.io.IOException, java.lang.IllegalArgumentException { … } public void copy(java.io.InputStream in, java.io.OutputStream out) java.io.IOException, java.lang.IllegalStateException { … } When we talk about binding advice method arguments later in this chapter, we'll look at how to respond to exceptions that are actually thrown by methods.

---

Note

Selecting methods on their throws declaration does not require a dynamic pointcut since Spring AOP can look at static method signatures at auto-proxy creation time.

---

Selecting Methods via Classes, Packages, and Inheritance

• Logging: You want to learn exactly how your application components interact, or you want to measure the performance of method executions.
• Auditing: You have a requirement to log who executes operations on a series of components.
• Security: You want to enforce user roles when invoking methods, or you want to filter return values based on security policies.
• Optimization: You want to learn how your users use your domain logic to learn where you can add more features or how you can improve performance, reduce memory usage, or reduce database access for common operations.

Each of these requirements typically has an impact on large sets of methods based on generic properties, such as containing classes, containing packages, or inheritance hierarchies. Some of these requirements can be implemented only by binding advice methods arguments, which we'll discuss later in this chapter. Here, we'll focus on how to select methods based on classes, packages, and inheritance.

Selecting on a Class

• Pointcuts that can determine matches based on static (as in nondynamic) class and method information. The execution() and within() pointcut designators will look only at static information and are great to narrow down the selection on a pointcut.
• Pointcuts that require a method execution context to determine a match. Pointcuts that require method execution can't always be avoided, but it's important that you know how to limit the number of objects that will be proxied to only the intended ones.

You're already familiar with execution(), but we haven't discussed yet how you can select methods in one class. The within() pointcut designator can also narrow the selection to all methods on a specific type. Here are two pointcuts that select exactly the same join points:

execution(* com.apress.springbook.chapter04.DefaultTournamentMatchManager.*(..)) 
within(com.apress.springbook.chapter04.DefaultTournamentMatchManager) 

These pointcuts select all methods on the DefaultTournamentMatchManager class. They use static information so don't require the context of the method execution. However, sometimes you need this, specifically when using advice method argument binding, as we'll discuss shortly. We've already discussed the args() pointcut designator, which enforces dynamic pointcuts.

Two other dynamic pointcut designators are target() and this(). The target() designator narrows down the selection on the target object of a proxy object. The this() designator narrows down the selection on the proxy object itself. (See Chapter 6 of the Spring 2.0 reference manual for more details on target() and this().)

Selecting Methods via Inheritance

execution(* com.apress.springbook.chapter04.TournamentMatchManager+.*(..)) 
within(com.apress.springbook.chapter04.TournamentMatchManager+) 

These pointcuts will select all objects that are type-compatible with the TournamentMatch Manager interface. Notice the use of the + operator to tell Spring AOP to take the class hierarchy into account.

Selecting Methods on all Classes in a Package

execution(* com.apress.springbook.chapter04.*.*(..)) 
within(com.apress.springbook.chapter04.*) 

If you want to include all subpackages, you need to provide on extra dot (..). Compare the preceding pointcuts to these:

execution(*com.apress.springbook.chapter04..*.*(..)) 
within(com.apress.springbook.chapter04..*) 

Narrowing down on the package level helps you to select specific methods.

Selecting Methods via Annotations

Here, we'll use the example of auditing to demonstrate how to select methods with annotations and methods in classes with annotations. Throughout this example, we'll use the @Audit annotation shown in Listing 4-45.

Listing 4-45. The @Audit annotation

package com.apress.springbook.chapter04; 

import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 

@Retention(RetentionPolicy.RUNTIME) 
public @interface Audit { 
  } 

Listing 4-46. Using the @Audit annotation to Mark a Method That Requires Retention of Audit Information

package com.apress.springbook.chapter04; 

public class BusinessOperations { 
  @Audit   
  public void sensitiveOperation(long recordId) { …   } 
  } 

The information that is to be stored and how it is to be stored is very likely defined in a policy document and is equal for all methods. We've only marked a method and can now implement the retention policy with an aspect.

Selecting on Method Annotation Declarations

We will select only the methods that declare the @Audit annotation and leave other methods unaffected. This is a great way of working, since we can be sure there will be no side effects. We'll delegate the actual saving of audit information to the AuditInformationRetentionPolicy interface, as shown in Listing 4-47.

Listing 4-47. The AuditInformationRetentionPolicy Interface

package com.apress.springbook.chapter04; 

public interface AuditInformationRetentionPolicy { 
  public void retainMethodInvocationInformation( 
    String currentUser, String methodDescription, Object[] arguments); 
} 

don't want to tie the implementation of our aspect to a specific authentication mechanism. We create the CurrentUserInformation interface, as shown in Listing 4-48.

Listing 4-48. The CurrentUserInformation Interface

package com.apress.springbook.chapter04; 

public interface CurrentUserInformation { 
  public String getUsername(); 
    } 

The first step is to add a pointcut to the SystemPointcutsAspect, since we want to centralize systemwide pointcuts, as shown in Listing 4-49.

Listing 4-49. Adding a Systemwide Pointcut

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("@annotation(com.apress.springbook.chapter04.Audit)")   
  public void auditableMethods() {  }  
} 

Notice that we're not selecting specific methods, classes, or packages anymore. We can obviously further narrow down the selection of the pointcut if desired.

Listing 4-50 shows the AuditInformationRetentionAspect that is responsible for trapping all executions of methods that are marked with the @Audit annotation and call the retainMethod InvocationInformation() on the AuditInformationRetentionPolicy interface.

Listing 4-50. The AuditInformationRetentionAspect Is Responsible for Saving Audit Information for Sensitive Operations

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.CurrentUserInformation; 
import com.apress.springbook.chapter04.AuditInformationRetentionPolicy; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.JoinPoint; 


@Aspect 
public class AuditInformationRetentionAspect { 
  

private AuditInformationRetentionPolicy auditInformationRetentionPolicy; 
private CurrentUserInformation currentUserInformation;   
  public void setAuditInformationRetentionPolicy( 
  AuditInformationRetentionPolicy auditInformationRetentionPolicy 
) { 
   this.auditInformationRetentionPolicy = auditInformationRetentionPolicy; 
  } 

  public void setCurrentUserInformation 
   ( 
   CurrentUserInformation currentUserInformation 
   ) { 
      this.currentUserInformation = currentUserInformation; 
  } 
  
  public void init() { 
    if (this.auditInformationRetentionPolicy == null) { 
      throw new IllegalStateException("AuditInformationRetentionPolicy " + 
        "object is not set!"); 
    } 
    if (this.currentUserInformation == null) { 
      throw new IllegalStateException("CurrentUserInformation " + 
        "object is not set!"); 
    } 
  } 
  @Before("com.apress.springbook.chapter04.aspects." + 
  "SystemPointcutsAspect.auditableMethods()")   
    public void retainMethodInvocationInformation(JoinPoint joinPoint) { 
      String currentUser = this.currentUserInformation.getUsername(); 
      String methodDescription = joinPoint.getSignature().toLongString(); 
      Object[] arguments = joinPoint.getArgs(); 

      this.auditInformationRetentionPolicy.retainMethodInvocationInformation( 
      currentUser, methodDescription, arguments); 
    } 
} 

The aspect in Listing 4-50 uses the org.aspectj.lang.JoinPoint object to obtain a description of the method that is executed and the arguments that have been passed.

Listing 4-51 shows the Spring XML configuration file for the BusinessOperations class and the AuditInformationRetentionAspect aspect.

Listing 4-51. Configuring the Auditable Class and Audit Aspect

<beans> 
  <bean class="org.springframework.aop.aspectj.annotation. --> 
AnnotationAwareAspectJAutoProxyCreator"/> 

  <bean class="com.apress.springbook.chapter04.aspects. --> 
AuditInformationRetentionAspect" 
  init-method="init"> 

  <property name="auditInformationRetentionPolicy" 
               ref="auditInformationRetentionPolicy"/> 
  <property name="currentUserInformation" ref="currentUserInformation"/> 
</bean> 

  <bean id="businessOperations" 
    class="com.apress.springbook.chapter04.BusinessOperations"> 
    <!-- properties omitted --> 
  </bean> 
</beans> 

Selecting on Class Annotation Declarations

Sometimes you also want to mark an entire class with an annotation to enforce a policy for all methods in this class. This is a viable approach in those cases where all the responsibilities of a class require the enforcement of a policy such as auditing. Methods that don't require these policies consequently don't belong in this class.

While this is an interesting approach, you need to take into account one consequence. If you recall, one of the requirements of working with aspects in Spring AOP is that callers use the proxy object, not the target object.

Consider the MoreBusinessOperations class in Listing 4-52.

Listing 4-52. The MoreBusinessOperations Class

package com.apress.springbook.chapter04; 

@Audit 
public class MoreBusinessOperations { 
  public (.*?) { 
      // do some work 
     someOtherSensitiveOperation(recordId); 
} 
  
  public void someOtherSensitiveOperation(long recordId) { 
    // work with sensitive data 
  } 
} 

Whether or not the someSensitiveOperation() method has been called via a proxy object is not relevant. This method calls another method on the same object, so that the method call will not pass through a proxy object. This means the auditing policy will not be enforced for the someOtherSensitiveOperation(). Although this sounds dramatic, we need to consider if saving audit information when the someSensitiveOperation() is executed is sufficient to cover both method executions. If this is not sufficient, then do two methods that both require audit information retention, one called by the other, belong in the same class? It's entirely possible that placing these two methods in the same class overloads the class with responsibilities.

If the someOtherSensitiveOperation() method always requires audit information to be saved, it should probably be moved to a separate class. An object of that class can then be injected in a MoreBusinessOperations object, which can then call the someOtherSensitiveOperation() method on the injected object.

There are no hard-and-fast rules for solving this kind of conflict between application design and limitations imposed by technical frameworks such as Spring AOP. We recommend that you use some common sense and consider the class, the methods, and the policy to be enforced to come to a solution.

To match methods in classes that declare the @Audit annotation, we need to change the auditableMethods() pointcut in SystemPointcutsAspect, as shown in Listing 4-53.

Listing 4-53. Also Match Methods in Classes That Declare the @Audit annotation

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("@within(com.apress.springbook.chapter04.Audit)") 
  public void auditableMethods() {  } 
} 

Now that we've covered how to match Java 5 annotations with pointcuts, let's look at how to bind advice.

Binding Advice Arguments

Let's start with the aspect from the first examples in this chapter, shown in Listing 4-54.

Listing 4-54. Printing a Message When a Tennis Match Starts

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 


@Aspect 
public class MessagePrintingAspect { 
  @Before("execution(* startMatch(..))") 
  public void printMessageToInformMatchStarts() { 
      System.out.println("Attempting to start tennis match!"); 
  } 
} 

The printMessageToInformMatchStarts() advice method in Listing 4-54 has no arguments.

Let's look again at the TournamentMatchManager interface and its startMatch() method, shown in Listing 4-55.

Listing 4-55. The TournamentMatchManager Interface

package com.apress.springbook.chapter04; 

public interface TournamentMatchManager { 
  public Match startMatch(long matchId) throws 
    UnknownMatchException, MatchIsFinishedException, 
    MatchCannotBePlayedException, PreviousMatchesNotFinishedException; 
} 

Listing 4-56. Getting an Argument Value via the JoinPoint Object

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.JoinPoint; 


@Aspect 
public class MessagePrintingAspect { 
  @Before("execution(* startMatch(..))") 
  public void printMessageToInformMatchStarts(JoinPoint jp) { 
  Long matchId = (Long)jp.getArgs()[0]; 
  System.out.println("Attempting to start tennis match with identifier " + 
      matchId + "!"); 
  } 
} 

So we now have the match identifier, but there is a problem: the pointcut expression must be changed to avoid errors. The current pointcut expression will select any startMatch() method, regardless of its argument types. We need to change the pointcut to select only methods that have a first argument of type long, as shown in Listing 4-57, because the advice method assumes it's present.

Listing 4-57. Changing the Pointcut Expression to Further Narrow the Method Selection

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.JoinPoint; 

@Aspect public class MessagePrintingAspect { @Before("execution(* startMatch(long,..))") public void printMessageToInformMatchStarts(JoinPoint jp) { Long matchId = (Long)jp.getArgs()[0]; System.out.println("Attempting to start tennis match with identifier " + matchId + "!"); } } This is better, but Listing 4-57 can still be improved. Spring AOP allows us to declare a long argument in the printMessageToInformMatchStarts() advice method, instead of having to use the JoinPoint object, as the next sections demonstrate.

Spring AOP supports advice argument binding as follows:

• Binding values, possible for all advice types
• Binding return values, possible only for after returning advice
• Binding exception objects, possible only for after throwing advice
• Binding annotation objects, possible for all advice types

You need to configure your Java compiler to include debug information in Java classes to make argument binding work correctly. Typically, the compilers in IDEs are configured this way by default. See Chapter 6 of the Spring 2.0 reference manual for more details.

Binding Method Argument Values

For the example, we want to bind the match identifier value to an argument of the print MessageToInformMatchStarts() advice method, so first we need to add an argument to this method.

However, we also need to use the args() pointcut designator to specify that we want to bind method arguments. We've changed the MessagePrintingAspect as shown in Listing 4-58.

Listing 4-58. Binding the Match Identifier Value to the Advice Method

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 
import org.aspectj.lang.JoinPoint; 


@Aspect 
public class MessagePrintingAspect { 

  @Before("execution(* startMatch(..)) && args(matchId, ..)")   
  public void printMessageToInformMatchStarts(long matchId) { 
    System.out.println("Attempting to start tennis match with identifier " + 
      matchId + "!"); 
  } 
} 

The pointcut in Listing 4-58 tells Spring AOP to bind the first argument value of the join point to the sole argument of the printMessageToInformMatchStarts() advice method. When this advice method is executed, its argument will contain the value that was passed to the startMatch() method execution on the proxy object.

Note the following about the pointcut and advice method in Listing 4-58:

• We've kept the static argument selection in the execution() point designator. Remember that execution() uses static method signature information, while args() needs a dynamic pointcut. To avoid selecting too many startMatch() methods as join points that can match the pointcut at auto-proxy creation time, we add as much static criteria as we can.
• The printMessageToInformMatchStarts() advice method cannot change the value of the match identifier. To change argument values, the JoinPoint object must be used.
• When adding the argument to the printMessageToInformMatchStarts() advice methods, this argument must be bound by the pointcut, so we must add the args() pointcut designator.

When we add more arguments, we will need to change the pointcut so that these extra arguments will also be bound. The names used in the args() pointcut designator must match the argument names in the advice method arguments.

To do this in XML, add the following to your configuration file:

<aop:aspect ref="messagePrinter"> 
  <aop:before method="printMessageToInformMatchStarts" 
              arg-names="matchId" 
              pointcut="execution(* startMatch(..)) && args(matchId, ..)"/> 
</aop:aspect>

Binding Return Values

Listing 4-59. Getting the Return Value

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.Match; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.AfterReturning; 

import org.aspectj.lang.JoinPoint; 


@Aspect 
public class MessagePrintingAspect { 
  @AfterReturning( 
    value = "execution(com.apress.springbook.chapter04.Match" + 
        " startMatch(..))", 
    returning = "match" 
)   
  public void printMessageToInformMatchHasStarted(Match match) { 
    System.out.println("This match has been started: " + match); 
  } 
} 

Binding the return value is a special kind of static pointcut. Spring AOP doesn't need to do any matching at runtime, but it does need to pass the return value as an argument to the printMessage ToInformMatchHasStarted() advice method. Notice that we provide the return type in the execution() pointcut designator as a safety measure, so that the advice method will be executed for only the startMatch() methods with the correct return type.

We've specified the returning property on the @AfterReturning annotation in Listing 4-59 to indicate we want to bind the return value to the advice method. The value we pass to the returning property is the argument name to which we want to bind. To do this in XML, add the returning attribute:

<aop:aspect ref="messagePrinter"> 
  <aop:after-returning method="printMessageToInformMatchHasStarted" 
                  returning="match" 
                  pointcut="execution(* startMatch(..))"/> 
</aop:aspect>

Binding Exceptions

Listing 4-60. Getting Exceptions That Are Thrown by the startMatch() method

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.UnknownMatchException; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.AfterThrowing; 

import org.aspectj.lang.JoinPoint; 


@Aspect 
public class MessagePrintingAspect { 
  @AfterThrowing( 
    value = "execution(* startMatch(..) throws " + 
      "com.apress.springbook.chapter04." + 
      "UnknownMatchException)", 
    throwing = "exception" 
  )   
  public void printMessageWhenMatchIdentifierIsNotFound( 
  UnknownMatchException exception) { 
    System.out.println("No match found for match identifier " + 
    exception.getInvalidMatchIdentifier() + "!"); 
  } 
} 

However, what will happen if another exception type is thrown by the startMatch() method?

The startMatch() declares three other exception types in addition to UnknownMatchException and can also throw any unchecked exception.

The printMessageWhenMatchIdentifierIsNotFound() advice method will be executed only if the exception type declared in its sole argument is thrown; otherwise, the advice will not be executed at all. This allows us to add more @AfterThrowing advice to handle specific exception types. We don't necessarily need to use the exception object, but by binding it to advice methods, Spring AOP can choose the correct advice.

Note, however, the pointcut in Listing 4-60 is not a dynamic pointcut. Spring AOP will match join points based on the static execution() pointcut designator. When an exception is thrown, Spring AOP will decide per advice if it needs to be executed, based on the binding information. This means the static pointcut must be sufficiently strict to select only the methods that can actually throw the exception. A pointcut that is not strict enough will trigger the creation of proxy objects for too many beans during auto-proxy creation.

The throwing property on the @AfterThrowing annotation must be present when binding exceptions and should have the name of the exception argument that is declared in the advice method as its value.

To bind on the exception using XML notation, you would do the following:

<aop:aspect ref="messagePrinter"> 
  <aop:after-throwing method="printMessageWhenMatchIdentifierIsNotFound" 
                     throwing="exception" 
                     pointcut="execution(* startMatch(..) throws --> 
                     com.apress.springbook.chapter04.UnknownMatchException)"/> 
</aop:aspect>

Binding Annotations

We will continue to look at binding annotation objects to advice method arguments that come from two locations:

• Annotations declared on methods
• Annotations declared on classes In this section, we will extend the @Audit example we used when we introduced annotations earlier in this chapter. First, we will add a property to the @Audit annotation, as shown in Listing 4-61.

Listing 4-61. Adding a Property to the @Audit annotation

package com.apress.springbook.chapter04; 

import java.lang.annotation.Retention; 
import java.lang.annotation.RetentionPolicy; 

@Retention(RetentionPolicy.RUNTIME) 
public @interface Audit { 
  String value() default ""; 
} 

By adding a value to the @Audit annotation, we can pass specific information that we can use while retaining audit information. Next, we'll change the auditableMethods() pointcut declaration on the SystemPointcutsAdvice to work with argument binding, as shown in Listing 4-62.

Listing 4-62. Changing the auditableMethods() pointcut Declaration to Work with Argument Binding

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.Audit; 
import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("@annotation(audit)") 
  public void auditableMethods(Audit audit) {  } 
} 

Listing 4-63 shows the BusinessOperations class with the @Audit annotation.

Listing 4-63. Declaring the @Audit annotation with Additional Information

package com.apress.springbook.chapter04; 

public class BusinessOperations { 
  @Audit("top secret") 
  public void sensitiveOperation(long recordId) { …   } 
} 

Listing 4-64. Binding Annotation Objects Declared on Objects

package com.apress.springbook.chapter04.aspects; 

import com.apress.springbook.chapter04.Audit; 
import com.apress.springbook.chapter04.CurrentUserInformation; 
import com.apress.springbook.chapter04.AuditInformationRetentionPolicy; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Before; 

import org.aspectj.lang.JoinPoint; 

@Aspect 
public class AuditInformationRetentionAspect { 
  private AuditInformationRetentionPolicy auditInformationRetentionPolicy; 
  private CurrentUserInformation currentUserInformation;   

  public void setAuditInformationRetentionPolicy( 
    AuditInformationRetentionPolicy auditInformationRetentionPolicy) { 
    this.auditInformationRetentionPolicy = auditInformationRetentionPolicy; 
  } 
  
  public void setCurrentUserInformation( 
    CurrentUserInformation currentUserInformation) { 
    this.currentUserInformation = currentUserInformation; 
  } 
  
  public void init() { 
    if (this.auditInformationRetentionPolicy == null) { 
    throw new IllegalStateException("AuditInformationRetentionPolicy " + 
    "object is not set!"); 
  } 

  if (this.currentUserInformation == null) { 
    throw new IllegalStateException("CurrentUserInformation " + 
    "object is not set!"); 
  } 
} 

@Before("com.apress.springbook.chapter04.aspects." + 
    "SystemPointcutsAspect.auditableMethods(audit)")   
  public void retainMethodInvocationInformation(JoinPoint joinPoint, Audit audit) { 
    String currentUser = this.currentUserInformation.getUsername(); 
    String methodDescription = audit.value() + ":" + 
       joinPoint.getSignature().toLongString(); 
    Object[] arguments = joinPoint.getArgs(); 

    this.auditInformationRetentionPolicy.retainMethodInvocationInformation( 
      currentUser, methodDescription, arguments); 
  } 
} 

The JoinPoint argument is bound automatically by Spring AOP, and auditableMethods() calls @annotation() to bind the Audit annotation argument.

Because the pointcut doesn't specify the annotation type, Spring AOP decides that the argument in @annotation() is referred to by name. In this way, the retainMethodInvocationInformation() advice method is executed only for join points that declare the @Audit annotation.

Notice the pointcut in Listing 4-64 doesn't reuse another pointcut. The reuse of pointcuts doesn't support binding arguments to advice methods.

We can also bind annotations that are declared on classes to advice methods using the @within() pointcut designator. Consider again the MoreBusinessOperations class, as shown in Listing 4-65.

Listing 4-65. The MoreBusinessOperations Class Is Now Classified Top Secret

package com.apress.springbook.chapter04; 

@Audit("top secret") 
public class MoreBusinessOperations { 
  public (.*?) { 
      // do some work 
    someOtherSensitiveOperation(recordId); 
} 
  
  public void someOtherSensitiveOperation(long recordId) { 
    // work with sensitive data 
  } 
} 

Listing 4-66. SystemPointcutsAspect Selects @Audit annotations on Classes

package com.apress.springbook.chapter04.aspects; 

import org.aspectj.lang.annotation.Aspect; 
import org.aspectj.lang.annotation.Pointcut; 


@Aspect 
public class SystemPointcutsAspect { 
  @Pointcut("@within(audit)") 
  public void auditableMethods(Audit audit) {  } 
} 

Being able to create your own annotations, annotate your methods and classes, and bind the annotation objects to your advice method arguments is an extremely interesting feature of Spring AOP. See Chapter 6 of the Spring reference manual for more details about binding advice arguments, as well as other Spring AOP topics.

Summary

AspectJ aspects are rich, fine-grained, and powerful constructs that allow you to change and augment the behavior of Java classes. This chapter covered all you need to know to get started with the new Spring AOP features and aspects in your application. Aspects are supported for Java 5 by leveraging the @AspectJ-style annotations and for older Java versions by leveraging the AOP XML Schema. The next chapter introduces data access with the Spring Framework.

The source code for this book is available to readers at http://www.apress.com/book/view/1590599187.

Interface21 is a privately held international company made up of consultants who build, use, and train for the most popular application framework in the world. Springframework.com is operated by Interface21 Limited, a privately owned company. The developers who brought you the Spring framework also provide training, consulting, and support. Interface21 also has partnerships in Europe and North America, partnering with companies that value a high quality of service and have experience with Spring, as well as partnerships with developers who deliver .NET services. Interface21 wants to be your first partner for enterprise development.

Seth Ladd is a software engineer and professional Spring Framework trainer and mentor specializing in object-oriented and testable web applications. He started his own company building websites at age 17, but now enjoys having a real job. Currently working for Camber Corporation, Seth has built and deployed systems for NEC, Rochester Institute of Technology, Brivo Systems, and National Information Consortium. He has architected and developed enterprise applications in Java and C for both the server and remotely connected embedded devices. He enjoys speaking and teaching, and is a frequent presenter at local Java user groups and at corporate developer conferences. Seth is very thankful for living and working in Kailua, Hawaii, with his wife.

Bram Smeets is a Java architect with over 8 years’ experience in developing enterprise Java applications. Currently, Bram is technical director at JTeam (www.jteam.nl), a Java software development company based in the Netherlands and senior consultant at SpringSource (www.springsource.com). He is a regular speaker at technology–focused conferences like The Ajax Experience and SpringOne. Using GWT, Bram has delivered several successful RIA projects at JTeam. He also delivered Ajax and GWT trainings at several companies.