Skip to end of metadata
Go to start of metadata

You are viewing an old version of this page. View the current version.

Compare with Current View Page History

« Previous Version 4 Next »

Authors: Alexandre Vasseur

This page is under construction - it will be ready before July 14th with 1.0 beta 1 release


This tutorial tries to walk you through the idea of Aspects deployment we have introduced in AspectWerkz 1.0.
You will learn how to integrate aspects and aspects libraries as regular components in your J2EE environment thru the help of META-INF/aop.xml and WEB-INF/aop.xml files.

It won't give a lot of detail on what is AOP, how the aspects are implemented using AspectWerkz, etc.
If you want to read more about that first, you can read and practice the


Download the latest release (1.0 something) and unzip it into a relevant location. This tutorial is based on the 1.0 beta1 version of AspectWerkz.

The latest distribution can be found here.

After installation you need to set the ASPECTWERKZ_HOME environment variable to point to the installation directory.
This is because quite a few of the scripts use this to find the required libraries and those scripts aims at making this tutorial
simpler to understand by focussing on the topic to cover.

Below is some samples (for Windows - adapt for Unix/Linux and do an export ASPECTWERKZ_HOME)
You should check that your JAVA_HOME is properly configured as well.

Then you need to install Tomcat 5, since we will deploy our aspects in Tomcat samples applications.
The distribution can be found here. Download and extract it to somewhere relevant.

After installation, it is wise to check the Tomcat installation by launching

and open your browser to (this link should work) http://localhost:8080/ to access the main Tomcat page.

In the next parts of the tutorial, we will go thru some Tomcat servlet samples http://localhost:8080/servlets-examples/.
Especially the TODO.
When you click on this link, you should see some messages in the Tomcat stdout window TODO true?.

Shutdown Tomcat by closing the MSDos window or doing some CTRL-C twice.

The reusable Aspect

Since Tomcat provides several sample applications, we have to provide a test Aspect that we can use and reuse to understand the different aspect deployment schemes.
To make things easy to understand, we will not go into the details.
Just notice that it is yet another tracing aspect, and that the aspect method named "trace" will be our around advice.

We will pack this Aspect in different ways in the next parts of the tutorial, but we can already compile it as a regular Java class.
I will write this Aspect in "C:\aw", in the package "demoAOP"

This is a standard Java class, and can be compiled with javac -d target demoAOP\ to produce the regular ".class" file in the "target" directory.

From there we have several options if we are using online mode (class load time weaving), which is now standardized with JSR-163:

  • drop the aspect ".class" file in the WEB-INF/classes directory and write a WEB-INF/aop.xml XML descriptor to define the aspect pointcut within the web application scope
  • package the aspect ".class" file in a jar file, and add a META-INF/aop.xml in this jar file. Drop this jar in the WEB-INF/lib directory.
  • instead of deploying our aspect within a web application, we could drop the class at the system classpath level. This won't have any different behavior than for any regular java class.
  • the interesting thing to understand is that we can have a system wide META-INF/aop.xml file to trace several web application at a time
  • and of course we could have both: some aspects at the application level with a WEB-INF/aop.xml and some aspects at the system wide level with a META-INF/aop.xml

When using offline mode, the same results can be achieved, though it can be sometimes a bit tricky to remember to weave the application both for its own aspects and for the system level aspects.
We will not go thru offline mode in this tutorial.

To keep things simple, we will always use the following pointcut that will allow to pick out all public method execution:

Some of you will have already understand that when the aspect is deployed along the application, its weaving scope will not be the same: the
pointcut will pick out public method from classes really "loaded" by the web application (e.g. not javax.servlet.http.HttpServlet TODO class/interface? exists?)

Enabling online mode in Tomcat

Since we will use online mode, we need to alter some of the Tomcat startup scripts. If we were using BEA JRockit or Java 1.5, it would be a matter of adding a single JVM option.
Since I will not make any assumption on your JVM environment, I will skip the interesting details in this part and we will use a non-optimized but out-of-the-box solution that ships with
the AspectWerkz distribution: the command line tool bin/aspectwerkz.

Open the Tomcat startup script bin/catalina.bat. The main idea is to set ASPECTWERKZ_HOME in this script and replace JAVA_HOME/bin/java with ASPECTWERKZ_HOME/bin/aspectwerkz.

Locate at the end of the script (below is a Tomcat 5.0.25 script, but all Tomcat 5.x should looks the same)

and alter it as follows:

For a complete understanding of the different options and other modes, refer to the AspectWerkz integration schemes documentation.

Aspect deployed in the application with a WEB-INF/aop.xml

In this section we decide to package our aspect as a regular class of the web application, and we define the pointcut and activate the aspect
thru the help of the WEB-INF/aop.xml file.
As a consequence, only the classes of the web application will be eventually weaved (if the pointcut match), even if the po

Aspect deployed in the application with an Aspect jar file

Aspect jar file at the system classpath


Now we have:

  1. learned how to package and deploy our aspect along our web application
  2. understood the consequence of doing so
  3. understood the difference with an Aspect jar that would belong to the system classpath
  4. practice class load time integration using the command line tool
  • No labels