|
|||
|
|||
Make Your Apps Operations Friendly With AOP
Posted March 15, 2004
For This Solution: AspectJ 1.0.6, Jarkarta Tomcat 4.1.x, and Jakarta Commons Logging 1.0.x are required. All too often, organizations overlook operations management requirements until after applications are deployed. Then it's more difficult to address concerns. As a result, organizations are burdened with hard-to-manage applications. Imagine this scenario: After completing a new application, the development team moves onto another project. Now you must support what they built, a Web application with numerous Java classes. At first the application runs well. You have more tasks than hours in the day, so you don't examine the new application too closely. Suddenly, it stops processing requests. After a half-hour of unsuccessful diagnostics, you stop and start the server, and, thankfully, the application begins processing requests again. After reviewing the application source code, you realize its logging is poorly designed and coded. You notice that many exception handlers are defined with empty blocks like this: try {
// Code that throws Exception
} catch (Exception e) {
// Ignore Exception
}
Other exception handlers are defined like this: try {
// Code that throws Exception
} catch (Exception e) {
System.out.println("Exception:
" e.getMessage());
}
The latter example is better because it reports the exception. However, the output could be lost among all the other messages on the console, and it doesn't supply enough information to help diagnose the problem. You rightfully suspect that the application failure's root cause is an unreported or unnoticed What is Aspect-Oriented Programming? AOP is a programming technique that modularizes concerns (areas of interest or requirements) that cut across a system and are common to many modules. These modules, called aspects, associate pointcuts and advices. Pointcuts identify joinpoints, which are well-defined points in the flow of execution such as a method call or data variable access. Advices, which are associated with specific pointcuts, specify the code to execute at a joinpoint. Put another way, a pointcut declares an event and an advice declares an action to be performed when an event fires (see Table 1). The problem with crosscutting concerns such as logging is that they are tangled with the application's core concern and scattered over many modules, whether it's credit card processing, online insurance, or whatever. The result: applications that are harder to develop and maintain. AOP provides a mechanism to modularize these crosscutting concerns. AOP Implementations AspectJ Available at the Eclipse Web site, the AspectJ download includes the AspectJ Compiler, an aspect browser, Ant tasks, and documentation. The AspectJ Browser provides a point-and-click interface to compile the Java classes and aspects you've defined to a build configuration. It compiles Java classes and aspects using the ajc compiler, which contains a weaver that interleaves the pointcuts and advices in the aspect with the Java classes. AspectJ generates classfiles that can run on any Java virtual machine. It also supports several Integrated Development Environments (IDEs): Eclipse, Borland JBuilder, and SunOne Studio 4/NetBeans. All code and documentation is available under the Mozilla license, and the Ant tasks are released under the Apache license. In short, you can download everything you need to equip a professional development environment. Aspects are defined in a file that looks much like a Java class. The LogPoints aspect, for example, outputs a Jakarta Commons log entry before and after any class's // LogPoints Aspect
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
aspect LogPoints {
private static Log log =
LogFactory.getLog(EntryExitPoint.class);
before(): call(public * init(..)) {
log.info("Enter: " + thisJoinPoint);
}
after(): call(public * init(..)) {
log.info("Exit: " + thisJoinPoint);
}
before(): call(public * doGet(..)) {
log.info("Enter: " + thisJoinPoint);
}
after(): call(public * doGet(..)) {
log.info("Exit: " + thisJoinPoint);
}
}
Compiling and running this aspect in Jakarta Tomcat 4 together with the 2004-02-28 13:46:56,574 INFO EntryExitPoint : Enter: call(void HelloWorldServlet. init(ServletConfig)) 2004-02-28 13:46:56,574 INFO EntryExitPoint : Exit: call(void HelloWorldServlet. init(ServletConfig)) 2004-02-28 13:46:56,574 INFO EntryExitPoint : Enter: call(void HelloWorldServlet.doGet (HttpServletRequest, HttpServletResponse)) 2004-02-28 13:46:56,589 INFO EntryExitPoint : Exit: call(void HelloWorldServlet.doGet (HttpServletRequest, HttpServletResponse)) The important point is that even if there were 20 servlets executing, this aspect would output the same type of log entry for each one. This simple example shows you how it's possible to define a logging interface within a single module that cuts across an entire system. JBossAOP The JBoss server configures aspects like other software components. It uses a Java Management Extensions (JMX) MBean (see "Improve Application Management With JMX") to load aspects, which you can hot-deploy by dropping a file with the signature In JBossAOP, advices and pointcuts are declared in an XML file placed in the JBoss server's deploy directory. Here's an example of a JBossAOP advice, called an interceptor, and a method pointcut. Note that the pointcut refers to the name of the interceptor. The interceptor logic executes whenever a <aop>
<interceptor name="Logging"
class="LoggingInterceptor">
</interceptor>
<method-pointcut class="MyClass"
methodName="get.*">
<interceptors>
<interceptor-ref name="Logging"/>
</interceptors>
</method-pointcut>
</aop>
The declaration in the XML file names a Java class, which implements the JBossAOP // LoggingInterceptor class
public class LoggingInterceptor
implements Interceptor {
public String getName() { };
public InvocationResponse invoke
(Invocation invocation)
throws Throwable {
}
}
The JBossAOP example demonstrates a different approach to AOP. But in the next section, I'll use AspectJ to develop a solution to the problem I brought up at the beginning of this article. Add an Aspect to a Java Application
You can use AOP to improve the manageability of your existing applications. It allows you to add crosscutting behaviors to existing applications, making it well-suited to implementing operational concerns such as logging, security, authentication, and performance monitoring that cut across a system. These types of concerns are often overlooked during development because they are separate from an application's core concern. Using AOP, you can add these crosscutting concerns in separate modules so they aren't tangled and scattered throughout an application. With multiple production-quality, open-source implementations to choose from, AOP is worth considering as part of an application upgrade. About the Author |