The tutorial will lead you thru a sample app using Hibernate, Spring and Tapestry. One first version is detailled to explain the purpose of the sample app (a blog webapp). This first version is not using AOP. Another version is then detailled where crosscutting concerns such as per request logging and profiling have been refactored using AspectWerkz 2.0.

It also gives an insight of the impacts and benefits of switching to the AspectJ 5 joint project.

This tutorial is mainly introductory and gradually brings AOP in the sample application, explaining each decision and trade-off. Mixin, execution pointcut, advice, and cflow pointcut are used.

Complete source code is available for download, including SQL scripts.

Read the tutorial
Look for other AspectWerkz tutorials
The HelloWorld tutorials

This version contains a few bug fix as compared to RC3 thanks to all who provided detailled feedback.
The AspectWerkz 2.0 development has been driven by a great community effort to provide an easy to use, Java 5 ready, plain Java, and well performant and truly dynamic AOP framework.

You can now use this final version while beeing on the starting block for the upcoming versions of AspectJ 5 that will include support for our annotation defined aspect as well as similar load time weaving capabilities, among others, making the transition as smooth as possible.

Last month, we have welcomed a new committer - Alexandru Popescu aka Mindstorm - which has already started to keep things going in a branch that will now be integrated in head so that new requirements can be addressed thru a 2.1 version. This is a great things to help us and ensure good support thru the mailing list while we are working on the AspectJ 5 joint effort.

Read the release notes.
Get it now.
Note: the release is bigger than usual since it contains the html docs.

Alex & Jonas]]> avasseur 2005-03-10T15:27:49+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000992_aspectwerkz_to_aspectj_5_survey.html As part of the AspectJ 5 effort between the AspectWerkz and AspectJ teams, we are inviting you to reply to a web based survey about the use you do of AOP, especially in Java.

This survey will help us to prioritize and to organize our milestones according to the community needs and requirements. The survey consists of 20 questions with answer choice, so it should require around 5 minutes to go through.

Take the survey now: http://aspectwerkz.codehaus.org/survey.html And pass it on!

The feature changes and fixes are:

• cflowbelow() is supported


• staticinitialization() pointcut (contributed by Alexandru Popescu / Mindstorm)


• patterns can be only annotation defined like within(@Foo), execution(@Tx) etc (contributed by Alexandru Popescu / Mindstorm)


• new -keepjp option in offline mode to keep internal statically compiled structure and speed up deployment time

• Aspects.aspectOf() fixed to support aspect reuse


• Advisable API fixed for call side pointcut

Read the release notes.
Get it now.

In the coming weeks, we will publish documents to help you getting started with the AspectJ 5 development snapshot, so that you can start thinking about future migration, as well as come with feedback as regards features you would like to have in.

The AspectJ and AspectWerkz projects have agreed to work together as one team to produce a single aspect-oriented programming platform building on their complementary strengths and expertise. The first release from this collaboration will be AspectJ 5, which extends the AspectJ language to support an annotation-based development style in addition to the familiar AspectJ code-based style. AspectJ 5 will also provide full AOP support for the new Java 5 language features. It will continue to be developed as an open-source project on eclipse.org.

Following the AspectWerkz 2.0 release, the AspectWerkz developers (Jonas Bonér, Alexandre Vasseur) will be joining the AspectJ project to bring the key features of AspectWerkz to the AspectJ platform.
This will begin with an extension to the AspectJ language to support an annotation-based style of development, and with tighter integration of load-time weaving for AspectJ in the J2EE environment. A smooth migration path for existing AspectWerkz users is a key priority in the development and release planning.

The combined strengths of the two teams will enable us to deliver a more comprehensive technology suite more quickly than either team could alone. We believe that the backing of two major vendors and an even larger open source community formed by bringing together existing AspectJ and AspectWerkz users will accelerate the adoption of AOP in the enterprise.

Please see the announce document at http://www.eclipse.org/aspectj for more details including outline development plans and an FAQ.

Jonas Boner (AspectJ 5, AspectWerkz), and Adrian Colyer (AspectJ 5, AspectJ)]]> avasseur 2005-01-19T08:59:36+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000917_aspectwerkz_20rc2_and_11_are_out.html I am pleased to announced the release of AspectWerkz 2.0.RC2

2.0.RC2 comes with feature completion as compared to 1.0:

• cflow() is supported


• handler() pointcut for use with before advice is supported

It comes with several bug fixes - thanks to all of you who provide feedback, test case and major fixes - many thanks to The Mindstorm, David Teare and the Summa team.

Aside, AspectWerkz 2.0.RC2 comes with new features:

• custom proceed() method, to easily change advised target argument values from within
  an around advice. Read more here.


• per instance interception framework, to programmatically configure advices for a given instance only at runtime. Read more here.


• AW Proxy aware of the underlying aspects. Our custom proxy framework allows to use proxy (AspectWerkz proxy or CGLIB proxy) and have them be aware of the aspects at no extra cost. The performance of the AWProxy is comparable to straight AOP, they can be used with per instance interception, but they do not require the use of the weaver. The main drawback is that only method and constructor execution of non private / non final method can be advised (as for all proxy based AOP out there).
  Read more here.
  Read AW Proxy announce here
  

Read the release notes.
Get it now.

We also release AspectWerkz 1.1, a maintenance release for AspectWerkz 1.x.
Access AspectWerkz 1.1 release notes.

We hope you will give a try to 2.x instead of upgrading to 1.1 !

Alex

Before we accessed the 'target instance' like this:

    Object target = invocation.getProxy().getProxyContext().unwrap();

    Object target = invocation.getProxy();

When correcting these mistakes dynaop performs up to 10 times better in the situations where we are accessing the 'target instance'.

The article has been updated with the new figures.

Thanks to Bob Lee who helped us discover this flaw.

/The AspectWerkz Team]]> jboner 2004-12-03T12:43:52+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000902_aop_and_java_5_annotations_with_aspectwerkz.html Our tutorial on AspectWerkz 2.x has been published on The Server Side.

In this tutorial, we are implementing a subset of the EJB 3 declarative transactions specification using AspectWerkz.

The aspect is written in plain Java with Java 5 annotations, and the sample application is running outside of any application server by using of ObjectWeb JOTM and we provide an easy way to use any JTA transaction manager.

@Aspect("perJVM")
public abstract class TransactionAttributeAwareTransactionProtocol {

    @Expression("execution(@javax.ejb.TransactionAttribute * *.*(..))")
    Pointcut transactedMethods;

    /**
     * Before advice that will initiate transaction management is bounded
	 		to the transactedMethods pointcut
     */
    @Before("transactedMethods")
    public void enterTransactedMethod(...) throws Throwable {
        ...
    }
}

To run the application, we are using Java 5 JVMTI ie you simply compile your applications and aspects with plain javac and run it with plain java.

Read more and practice.
Discuss the tutorial

AWbench project has been started for that purpose and the first results have been published today.

In this report we explain what AWbench microbenchmark is about, and provides element of comparison for performance of

• AspectWerkz 2.x and 1.0
• AspectJ
• JBoss AOP
• Spring
• DynAOP
• CGLib
• AspectJ, Spring and AOP Alliance aspects running in AspectWerkz 2.x extensible container

We will include any fix, new implementation, or hand written version of the microbenchmark that will be contributed.

Read the AOP benchmark report
Read more about AspectWerkz 2.x extensible AOP container

Here is a short summary of the new features and enhancements in this releases. For more details read the What is new in AspectWerkz 2? paper, or dive in into the online documentation.

New architecture

• Fast: Average 20x faster architecture as compared to AspectWerkz 1.0
• Open: Extensible AOP container allow to deploy Spring AOP, AspectJ aspects and virtually any aspects in the same runtime
• Dynamic: Hotdeployment and undeployment of aspects thru a simple atomic API
• Simpe: Aspects can be written in plain Java, using Java 5 annotations or equivalent doclets for Java 1.3/1.4

Richer semantics

• Support for after returning and after throwing advices
• Access advised instance and advised member arguments direclty without any casting or unboxing
• New mixin model
• New Java 1.3/1.4 annotations model to minimize the migration effort to Java 5 annotations
• Pay as you go model, the overhead of an advice is dependant upon the use or not of reflective information vs explicit binding

Higher reliability

• Fully based on ObjectWeb's ASM bytecode kit
• Weaved code is entirely statically compiled (no reflection or unsafe casting and object wrapping)

You can download the distribution here

Enjoy.

• Aspects, advices and mixins are plain Java
  
  • Before, Around, After advices
  • Method and interface introduction (mixin)
  • Aspect (singleton, perClass, perInstance, perThread)
• Pointcuts are composable
  
  • Method and constructor call and execution
  • Field read and write access
  • Matching on types and signatures
  • Matching on Annotations (Java 1.3/1.4 strongly typed annotations)
  • within(..), hasfield(..), hasmethod(..) and withincode(..) designators
  • cflow supports
  • args(..) designators to gain strongly typed access to advised member parameters
• Aspects definitions allows deployment modules
  
  • Aspects defined as annotated classes
  • Aspects defined and refined in XML
  • Deployment module with META-INF/aop.xml
• Annotation driven AOP
  
  • Custom annotation compiler for Java 1.3/1.4 which behave like Java 5 annotations, available thru Ant task and command line
  • Strongly typed annotations support for Java 1.3/1.4
  • Matching on annotations on target classes and members
  • Definining Aspects, advices and pointcuts with annotations
• Integration facilities
  
  • Post compilation thru Ant task and command line
  • Class load time weaving thru JVMTI/JSR-163 for Java 5, plain Java hooks for Java 1.3, 1.4, JMAPI API for BEA JRockit, specific native module for Java 1.4

Thanks to all of you who provide feedback and bug reports.

Download it.
Read the release note.

Thanks to all of you who provide feedback and bug reports.

Download it.
Read the release note.

• Support for args() in the pointcut expressions. As a consequence, support for direct access to arguments of advised method / constructor / field value set is possible and advices can have those parameters in their signature.
• hasmethod and hasfield pointcuts (contributed by Michael Nascimento Santos)
• J2SE 5 JVMTI (JSR-163) support updated for latest specification.
• bin/aspectwerkz command line tool now provides autodetection of BEA JRockit and J2SE 5.
• Support for pointcut expression defined in the XML body of the <pointcut> element.
• Bug fixes (Thanks to Allan Jones and all others)

Download it.
Read the release note.

So if you know portuguese, then enjoy.

Download it here]]> jboner 2004-08-20T14:49:44+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000817_aspectwerkz_10_beta2_released.html Many bug fixes.

Download it here.

Enjoy.

]]> jboner 2004-08-16T15:38:34+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000768_aspectwerkz_10beta1_is_out.html AspectWerkz 1.0-beta1 has been released.

Here are the release notes:

Amont many other things this release is shipped with a completely new pointcut grammar which is much more expressive and powerful, and rich annotation support for both typed and untyped annotations.

• Support for deploying several aop.xml Aspect defintion/deployment files alongside deployed application (WEB-INF/aop.xml , META-INF/aop.xml ) and have them following the classloader hierarchy.
• One single API to access both JavaDoc-style and Java 1.5 annotations, allows using them together seamlessly.
• Typed and untyped annotations for JavaDoc-style annotations. Supports the same parameters types as Java 1.5 annotations and has strongly typed compile time checking (using a new annotation compiler).
• within and withincode pointcuts
• More expressive cflow pointcuts that can take any pointcut expression as "parameter" and can be used to build arbitrary nested expressions.
• Matching on annotations.
• Matching on modifiers (including !public and NOT static etc.)
• Matching on subtypes for parameters and return values.
• System wide pointcuts (in the XML deployment descriptor).
• Pointcut references (refer to pointcuts defined in other aspects than the one you are using it in).
• JSR-163 JVMTI support for Java 1.5 class load time weaving with -javaagent:
• JoinPoint class is now serializable.
• JoinPoint instances can be "resetted", to start over a complete advice chain (useful for failover etc.).
• Documentation enhanced and refactored.
• Introductory tutorials.
• Some bug fixes.
• Please note that there are changes to the way annotations (formerly call attributes) are complied and retrieved. F.e. AspectC has been replaced by AnnontationC and has slightly different options, so to compile the aspects use AnnotationC from now on.

Enjoy.

]]> jboner 2004-06-24T12:53:35+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000755_aspectwerkz_010_final_released.html

AspectWerkz 0.10 final has been released.

Download it.

This release is mainly a bug-fix release one month after 0.10.RC2, but brings lot of change compared to 0.9.

The following is the list of main differences compared to 0.9:
Read 0.10.RC2 release notes and 0.10.RC1 release notes.

• JIT compilation of JoinPoint for better performance
• Expressiveness and orthogonality with a more complete grammar
• Runtime weaving capabilities, the low layer for the upcoming hotdeployement feature
• Aspects can be any Java class and extend anything they like
• Retrieval of information about the system, adding and reading of parameters and metadata etc. is done through the CrossCuttingInfo class. An aspect or mixin that is interested in accessing this info should have a constructor that takes a CrossCuttingInfo instance as its only parameter. See the docs for details.
• Pluggable aspect container - The possibility to provide your own aspect container implementation is back. Useful if you need to control how your aspects are instantiated for example if you want that to be handled by an IoC container (Spring, PicoContainer etc.))

The following is the list of bug fix in 0.10 that were affecting 0.10.RC2:

• A thread safe issue has been fixed in the join point execution model.


• IBM JRE support has been fixed.


• Unix/Linux comamnd line scripts has been fixed (was missing bcel.jar).


• Exception throwned by method of weaved classes are not wrapped anymore. Exception throwned by mixin implementation are not wrapped anymore.


• JIT JoinPoint compilation is now thread safe.


• serialVersionUID computation fixed.


• Due to a lack of within expression support in the pointcut grammar (addressed in 1.0), the handler pointcut are very expensive to match. Those are deactivated by default. If your system uses those handler pointcuts, you have to add the -Daspectwerkz.handler.pointcut=true JVM option when starting up your JVM.

Note that the CVS has been migrated.
Check the instructions and update your tools.

Enjoy.

In this article, you will learn the basic AOP concepts as well as how to apply AOP to your J2EE applications using AspectWerkz, a dynamic AOP framework. The hands-on tutorial explains how to use AOP to track EJB CMP's container generated JDBC queries.

You will learn how to integrate AOP in your BEA environment, using a standard offline class post-processing mechanism, class-load time integration in BEA WebLogic Server 8.1 and a dedicated BEA JRockit Management API module that delivers best performance with a minimal integration effort.

Many of you were asking for some tutorial so I hope this article will give you a quick start to AspectWerkz AOP.

The same tutorial could be replayed using Sun VM integration scheme we provide in AspectWerkz, and can probably be applied easily to some other container you like.

Enjoy and apologies for yet another tracing sample, but don't miss it, the goal is not to understand what is the tracing aspect, but to demonstrate the value of an efficient class load time architecture for AOP weaving.

Read tutorial on BEA dev2dev

Read about the AspectWerkz JRockit extension
Read about AspectWerkz integration schemes

• technical session TS-1391 Dynamic Aspect-Oriented Programming in Java™ 2 Platform, Enterprise Edition (J2EE™) Platform Environments
• BOF-1392 Dynamic Aspect-Oriented Programming with AspectWerkz
.

In case you miss it, drop a message at the BEA booth and we will try to answer as much question as we can. Don't miss the AOP panel discussion, as well as AspectJ' Ramnivas session on Metadata driven AOP.

Read more about our sessions.
Read more about JavaOne 2004.
AOP related session at JavaOne 2004 (follow this link and search for "aspect").

This release is mainly a bug-fix release, but we have added some new functionality (and changed some APIs) as well:

• Aspects does not have to extend the Aspect base class anymore, but can be any Java class and extend anything they like.


• The JoinPoint class has these two methods:
  • getSignature() - which is used to retrieve the static signature for the join point.
  • getRtti() - which is used to retrieve the RTTI (Runtime Type Information) about the join point.
  Both these methods returns a base interface that could be used, but is usually best to cast to a more fine-grained and specific type.


• Retrieval of information about the system, adding and reading of parameters and metadata etc. is done through the CrossCuttingInfo class. An aspect or mixin that is interested in accessing this info should have a constructor that takes a CrossCuttingInfo instance as its only parameter. See the docs for details.


• Pluggable aspect container - The possibility to provide your own aspect container implementation is back. Useful if you need to control how your aspects are instantiated for example if you want that to be handled by an IoC container (Spring, PicoContainer etc.))

AspectWerkz has gone through a lot of changes, the whole core engine has for example been thrown out and replaced by a much more flexible and performant one. The join point model is much more expressive and orthogonal we have also implemented a JIT compiler that is making AspectWerkz much more performant. On top of that we have a new implementation of true runtime weaving, which allows you to redefine your aspect model including adding new pointcuts at runtime.

Expressiveness and orthogonality

AspectWerkz currently supports the following join points:

• method (static and member) execution
• method (static and member) call
• constructor execution
• constructor call
• field (static and member) modification
• field (static and member) access
• catch clauses
• cflow

In the latest version we have reached a high level of orthogonality:

• All advice types (around, after and before) works with all poincut designators (except for the handler pointcut which is only possible to bind to the before advice).
• You can compose new pointcuts by mixing any types of pointcuts.

The syntax has changed slightly, both in the XML and attribute definition. However not more than that the migration should be fairly easy. See the docs for details on the new syntax.

Performance improvements and JIT compilation

Here are some simple but interesting benchmarks comparing the latest distribution of AspectWerkz, JBoss and AspectJ:

The overhead of one around advice applied to a method call join point:

AspectJ 1.1.1	0.000018 ms/call
AspectWerkz 0.10 RC1	0.000097 ms/call
JBoss AOP 1.0Beta	0.000181 ms/call

The overhead of five around advice applied to a method call join point:

AspectJ 1.1.1	0.000097 ms/call
AspectWerkz 0.10 RC1	0.000163 ms/call
JBoss AOP 1.0Beta	0.000263 ms/call

Runtime weaving

A simple API allows to refine the aspect definition to add new pointcuts and then trigger the activation of it. Prior to pointcuts addition, your programs are guaranteed to run without any overhead since the bytecode does not gets modified prior activation. Moreover the runtime weaving does not require to have a remote JVM to control the HotSwap API since we provide a dedicated in-process module.

Download the distribution

]]> jboner 2004-03-19T06:42:23+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000507_aspectwerkz_09rc1_is_released.html Today we (Jonas and Alex) released the 0.9 release candidate 1 version of AspectWerkz (0.9.RC1).

This new release brings a new innovative Aspect model whose orginal idea came from Ron Bodkin, one of the AspectJ brains. The new Aspects are defined in a single java class, with fields being the pointcuts, methods being the advices and inner classes being the introductions. The Aspects are marked with JSR-175 style metadata (for now as doclets, until java 1.5 is out), and the metadata is incorporated in class file bytecode. The XML deployment descriptor is thus reduced to a minimal piece, and brings Aspect packaging, abstraction and reuse to a new seamless integration state.

The new Aspect model supports all AspectWerkz dynamic AOP features: introduction replacements at runtime, advice replacements and removal. This release provides support for both XML centric model (0.8 style) and Self-defined Aspects.

The cross platform class-load time hooking has also been enhanced to support IBM JRE and BEA JRockit.

We did the choice of releasing a Release Candidate to give our community the ability to provide extensive feedback on all the new features that bring AOP for java a step ahead.

The documentation is all included, with several samples that can be run thru both Ant and Maven.

Jonas gave a talk at JavaPolis/BeJUG early december and the slides announcing this new Aspect model can be found here.

New features:

• Model 2 - self-defined Aspects are one single java class, with regular java inheritance and abstraction. Pointcuts and bindings are defined with doclet metadata that gives today AOP the JSR-175 metadata facilities.


• IBM JRE support IBM JRE bundles a specific class loader. This one is now supported in class-load time weaving hook architecture.


• BEA JRockit BEA JRockit (v7 and v8.1) comes with a JVM level ClassPreProcessor mechanism. AspectWerkz is a pioneer and allows the use class load time AOP on top of this JRockit feature.

Some of the other new things are:

• Fixed issues for field pointcuts, Pointcut algebra has been enhanced


• Documentation updated and reorganized. Many bug fixes.

The new release can be downloaded from here.
The BeJUG slides can be downloaded from here.
The self-defined Aspect model was presented in blogs here.

By using JRockit JMAPI capabilities, AspectWerkz brings AOP one step ahead by officially supporting all major JVM (Sun, IBM, BEA). This allows to hook AspectWerkz in a seamless way to provide dynamic on the fly weaving of Aspects no matter your environment.

JRockit could not be supported before due to lack of HotSwap support and a limitation that forbids overriding of java.lang.ClassLoader with a -Xbootclasspath option. Users had to use offline mode until there.

The extension will be core part of coming 0.9 AspectWerkz release, so that all VM are supported with the smallest integration cost (Sun, IBM, JRockit).

Tests have been made with

• JRockit 7SP4 (java 1.3.1)
• JRockit 8.1SP1 (java 1.4.1_03)

The JMAPI JRockit API (management API) allows to add a classPreProcessor mechanism using a java snip or a command line option.
A single VM is thus running at full speed, both under java 1.3 and 1.4, without having to use bootclasspath override.
The classPreProcessor instance is responsible to modify bytecode of the class at load time. AspectWerkz was already providing this classPreProcessor based architecture since summer 2003 for Sun VM and Q3 2003 for IBM VM.

It is possible to hook or unhook AspectWerkz programmatically using JMAPI:

JVMFactory.getJVM().getClassLibrary().setClassPreProcessor(
    new JRockitPreProcessor());

To launch a JVM with AspectWerkz hooked in for class load time weaving this consists of a single option:

/jrockit/bin/java
-Xmanagement:class=org.codehaus.aspectwerkz.extension.jrockit.JRockitPreProcessor ....

If you are a JRockit fan, please help us and give a try to AspectWerkz online mode by your own. We need your feedback to make it suits your needs.

We will provide extensive documentation with the 0.9 release, but for the impatient :

• grab a CVS snapshot
• check bin/aspectwerk scripts to adapt them for JRockit (one line is commented out - notice that AspectWerkz needs to be in bootclasspath due to JMAPI)
• have a look at org.codehaus.aspectwerkz.extension.jrockit.JRockitPreProcessor in src/extensions/
• compile extensions.jar with ant/maven aspectwerkz:extensions:compile
• give it a try

In this new definition model the aspects are regular Java classes and the advices and introductions are regular methods and inner classes in these classes. The aspects can be abstract and inheritance is used and treated like regular Java class inheritance. The meta-data (definitionis defined using runtime attributes and is currently compiled in into the class on bytecode level (not needed in Java 1.5.x and above).

This new approach makes it easy to create reusable self-contained aspect components and libraries. It simplifies both the implementation, maintainance and refactorings since everything is written in one single Java class.

This is an example of a testing aspect defining a virtual mock object mixin that will be introduced (along with its interfaces) on all the classes matching the pattern foo.baz.*.

/**
 * @Aspect perInstance
 */
public class MockObjectAspect extends Aspect {

    /**
     * @Introduce foo.baz.*
     */
    public class MockObject extends MyBase implements Traceable, Metered {
        // implementation of the mock object
    }
}

Here is another example showing a skeleton for an aspect implementing authentication and authorization.

/**
 * @Aspect perThread
 */
public class RoleBasedAccess extends Aspect {

     private Subject m_subject;

    /**
     * @Call * *..facade.*.*(..)
     */
    Pointcut facadeMethods;

    /**
     * @Execution * *..service.*.*(..)
     */
    Pointcut needsAuthorization;
   
    /**
     * @Before facadeMethods
     */
    public void authenticateUser(JoinPoint joinPoint) throws Throwable {
        Context context = ... // get principals and credentials
        boolean granted = SecurityManager.authenticateUser(context) // authenticate the user (f.e. using JAAS)
        if (granted) {
            m_subject = ... // set the subject 
        }
        else {
            throw new SecurityException("user not authenticated: " + context);
        }
    }

    /**
     * @Around needsAuthorization
     */
    public Object authorizeUser(JoinPoint joinPoint) throws Throwable {
        MethodJoinPoint jp = (MethodJoinPoint)joinPoint;
	boolean granted = SecurityManager.checkPermission(m_subject, jp.getTargetClass(), jp.getMethod());
        if (granted) {
            // proceed with normal method invocation
            return joinPoint.proceed();
        }
        else {
            throw new SecurityException("access denied at " + jp.getTargetClass() + "." + jp.getMethodName());
        }
    }
}

Currently the runtime attributes implementation is based on JavaDoc tags. These are parsed and inserted into the class on bytecode level, so no source files are needed once the classes have been compiled. This is something that will become obsolete when Java 1.5 and the JSR-175 is released, which will bring runtime attributes to the Java language. The extra compilation step needed to annotate the class files will then not be needed. This also means that pure Java refactorings of both implementation and definition in the aspects will be made possible (e.g. tool support).

The new release is scheduled to be released in the middle of end of november.

Stay tuned.

]]> jboner 2003-10-27T11:44:45+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000140_aspectwerkz_announces_support_for_ibm.html The latest snapshot of AspectWerkz is now supporting IBM JDKs for on the fly weaving.

IBM bundles an entire JRE (1.3 or 1.4) with its WSDK and WepSphere platform, which you are forced to use with IBM software.

Due to specific classloading scheme, we delayed the support for it and users had to use offline mode (class post compilation) to use AspectWerkz with WebSphere.

With the latest version, we have brought AspectWerkz a step further in AOP that now allow online mode to work with IBM custom JDK / JRE.

This change could only be achieved starting with the 0.8 released around august 2003, wich has brought the totaly new online architecture that allows to seamless hook AspectWerkz weaver in the JVM.

Tests have been made with

• IBM WSDK 5.0.1 on a win32 (Java 1.3.1)
• IBM JRE 1.3.1 on a linux 2.4

]]> avasseur 2003-09-03T16:16:05+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000124_aspectwerkz_08_is_released.html Today Jonas and Alex released the 0.8 version of AspectWerkz.

This new release have been tested and verified to work for servlets and all types of EJBs under WebLogic Server 7 and 8.1 using both online and offline mode.

JMangler has been thrown out for a completely new and customized solution that apart from solving some of the shortcomings and bugs in JMangler also provides completely new and interesting possibilities. Here are the options currently supported for online mode:

• HotSwap
  A first JVM launchs your target application in a second JVM. The first JVM hooks AspectWerkz in the second one just before the main class (and all dependencies) gets loaded, and then connects to the stdout / stderr / stdin stream ot the second JVM to make them appear as usual thru the first JVM.
  
• Transparent bootclasspath
  For JVM or java version like 1.3 which don't support class replacement at runtime (HotSwap), this option allows for same mechanism by putting an enhanced class loader in the target application VM bootclasspath.
  
• Native HotSwap
  A native C JVM extension running in the target application VM handles the replacement of the class loader by the enhanced one.
  
• Remote HotSwap
  The application VM is launched suspended. The replacement of the enhanced class loader is done thru a separate manual process, which can easily be scripted.
  
• Prepared bootclasspath
  The enhanced class loader is builded and packaged as a jar file in a first separate manual process, which can easily be scripted. The application VM is launched with options to use this enhanced class loader.
  
• Auto detection of java 1.3 and java 1.4

Some of the other new features are:

• JDK 1.3 compatibility.
• Runtime attributes -> XML compiler (no more metaData dir and meta-data compilers needed, one aspectwerkz.xml per application).
• Offline compiler refactored. Now support rollback on error facility.
• Released under a BSD-style license.
• Non-reentrancy option for join points.
• Definition validator.
• Documentation updated and reorganized.

The new release can be downloaded from here.

A more detailed paper describing the new online architecture can be downloaded from here

• A memory leak.
• Instrumentation of methods belonging to abstract classes was not possible.

]]> jboner 2003-07-11T19:16:12+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000088_aspectwerkz_07_is_released.html This release fixes many of the bugs that were introduced with the new join point model in the 0.6.x release (which was a complete rewrite).

It also has some new interesting features.

Here is a list of some of the changes and features:

• cflow (control flow) pointcuts.
• Uses new version of JMangler (3.0.2) which is released under LGPL.
• Performance improvement for advices by a factor of 2.
• Many, many bugfixes (introduced by the new pointcut model implementation in 0.6.x).
• The runtime attributes tag's syntax has changed. (They now have an aspectwerkz namespace and are using the same syntax as XDoclet.)
• Documentation and examples have been updated.

Enjoy.

]]> jboner 2003-07-09T13:55:22+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000077_jmangler_changes_its_license_back_to_lgpl.html JMangler will change its license back to LGPL (for some reason they changed to GPL for the 3.x release).

The change to GPL did of course cause a lot of problems for AspectWerkz (which is licensed under LGPL and uses JMangler) and I have since then tried to persuade the JMangler team to change its license back to LGPL.

Yesterday I recieved this letter from Michael Austermann, the creator of JMangler:

Hi Jonas, I've been to canda for the last weeks and was unable to read/reply any emails. We will change the the licence of JMangler back to LGPL within the next one or two weeks. Michael

]]> jboner 2003-06-30T10:52:21+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000064_aspectwerkz_063_has_been_released.html I have among other things rewritten the whole definition and weave model implementation to support a much more powerful join point model. The join point model now have the essence of the AspectJ model.

Here are some of the features/changes:

• Completely new definition model. Aspects, advices, introductions and pointcuts are now completely orthogonal and the model now has the essence of the AspectJ model. See the documentation for details.
• Abstract aspects definitions as well as pointcut expressions (e.g. ((pc1 OR pc2) AND !pc3) and similar).
• Multiple weave models.
• Multiple AspectWerkz system can run in the same JVM concurrently.
• setField and getField now works for get and set java.util.* collection fields (e.g. add/get/remove/size and so on).
• Advice and introduction container is now pluggable. I.e. the user can provide its own custom implementation (f.e. to enable persistence).
• The transparent persistence of advices and introductions have been moved to the sandbox.
• Many bug fixes.

<aspectwerkz>
    <!-- ============================================= -->
    <!--  Define the advices                           -->
    <!-- ============================================= -->
    <advice-def name="log"
                advice="advices.LoggingAdvice"
                deployment-model="perInstance"/>

    <advice-def name="cache"
                advice="advices.CachingAdvice"
                deployment-model="perClass"/>

    <advice-def name="persistent"
                advice="advices.PersistenceAdvice"
                deployment-model="perJVM"/>

    <advices-def name="log_and_cache">
        <advice-ref name="log"/>
        <advice-ref name="cache"/>
    </advices-def>

    <!-- ============================================= -->
    <!--  Define the introductions                     -->
    <!-- ============================================= -->
    <introduction-def name="serializable"
                      interface="java.io.Serializable"/>

    <introduction-def name="mixin"
                      interface="mixins.Mixin"
                      implementation="mixins.MixinImpl"
                      deployment-model="perInstance"/>

    <!-- ============================================= -->
    <!--  Define the abstract aspects                  -->
    <!-- ============================================= -->
    <abstract-aspect name="MyAbstractAspect">
        <advice pointcut="setters AND !getters">
            <advices-ref name="log_and_cache"/>
        </advice>

        <advice pointcut="persistentFields">
            <advice-ref name="persistent"/>
        </advice>
    </aspect>

    <!-- ============================================= -->
    <!--  Define the aspects                           -->
    <!-- ============================================= -->
    <aspect name="MyAspect" extends="MyAbstractAspect">
        <introduction class="domain.*">
            <introduction-ref name="serializable"/>
            <introduction-ref name="mixin"/>
        </introduction>

        <pointcut-def name="setters" type="method" pattern="String domain.*.set*(..)"/>
        <pointcut-def name="getters" type="method" pattern="String domain.*.get*(..)"/>
        <pointcut-def name="persistentFields" type="setField" pattern="* domain.*.*">
    </aspect>
</aspectwerkz>

Enjoy.

]]> jboner 2003-06-20T11:44:04+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000021_aspectwerkz_051_is_released.html The 0.5.1 release fixes some bugs in the new 0.5 release.

Download from it here.

]]> jboner 2003-05-16T17:42:58+00:00 http://blogs.codehaus.org/projects/aspectwerkz/archives/000015_aspectwerkz_05_has_been_released.html You can download the new release from the releases page.

New features:

• Caller side pointcuts. I.e. the possibility to advise a method invocation (caller side) apart from method execution (callee side).
• Fine-grained pattern language for picking out pointcuts. It is now possible to pick out method pointcuts by method name, parameter types and return type as well as field pointcuts by field name and field type. All these support regular expressions.
• Runtime attributes for advices (method/field/throws). I.e. add meta-data to your methods/field/classes as JavaDoc tags which are picked up by the weaver and used as rule set when doing the transformations.
• Class selectors for aspects. I.e. pick out classes using regular expressions.
• Advising of static fields.
• Parameters to advices. The possibility to pass parameters to advices through the XML definition.
• Advice stacks. The possibility to define stacks/chains of advices that can be reused throughout the XML definition.
• MethodAdvice has been renamed to AroundAdvice and the FieldAdvices has been renamed to PreAdvice and PostAdvice.
• Creation and registration of new advices at runtime (in previous releases you could only add/remove/reorder existing advices).
• Ant task for offline post-processing.
• More flexible startup and definition handling process.
• Multiple pattern declarations for pointcuts.
• More documentation and examples.
• Many many bugfixes.