In short, all AOP frameworks define two things: a way to implement crosscutting concerns, and a programmatic construct — a programming language or a set of tags to specify how you want to apply those snippets of code. Let us take a look at how JBoss AOP, its cross-cutting concerns, and how you can implement a metrics aspect in JBoss Enterprise Application Platform.
The first step in creating a metrics aspect in JBoss AOP is to encapsulate the metrics feature in its own Java class. The following code extracts the
finally block in our first code example's
BankAccountDAO.withdraw() method into
Metrics, an implementation of a JBoss AOP Interceptor class.
The following example code demonstrates implementing metrics in a JBoss AOP Interceptor
01. public class Metrics implements org.jboss.aop.advice.Interceptor
03. public Object invoke(Invocation invocation) throws Throwable
05. long startTime = System.currentTimeMillis();
08. return invocation.invokeNext();
12. long endTime = System.currentTimeMillis() - startTime;
13. java.lang.reflect.Method m = ((MethodInvocation)invocation).method;
14. System.out.println("method " + m.toString() + " time: " + endTime + "ms");
Under JBoss AOP, the Metrics class wraps
withdraw(): when calling code invokes
withdraw(), the AOP framework breaks the method call into its parts and encapsulates those parts into an Invocation object. The framework then calls any aspects that sit between the calling code and the actual method body.
When the AOP framework is done dissecting the method call, it calls
Metrics's invoke method at line 3. Line 8 wraps and delegates to the actual method and uses an enclosing
finally block to perform the timings. Line 13 obtains contextual information about the method call from the
Invocation object, while line 14 displays the method name and the calculated metrics.
Metrics code within its own object allows us to easily expand and capture additional measurements later on. Now that metrics are encapsulated into an aspect, let us see how to apply it.