AspectWerkz is a dynamic, lightweight and high-performant AOP framework for Java.
AspectWerkz offers both power and simplicity and will help you to easily integrate AOP in both new and existing projects.
AspectWerkz utilizes bytecode modification to weave your classes at project build-time, class load time or runtime. It hooks in using standardized JVM level APIs. It has a rich and highly orthogonal join point model. Aspects, advices and introductions are written in plain Java and your target classes can be regular POJOs. You have the possibility to add, remove and re-structure advice as well as swapping the implementation of your introductions at runtime. Your aspects can be defined using either Java 5 annotations, Java 1.3/1.4 custom doclets or a simple XML definition file.
AspectWerkz provides an API to use the very same aspects for proxies, hence providing a transparent experience, allowing a smooth transition for users familiar with proxies.
AspectWerkz performance is reported in this separate project.
AspectWerkz is Free Software. The LGPL-style license allows the use of AspectWerkz 2.0 in both commercial and open source projects.
AspectWerkz Features
This is a very incomplete list, see the documentation for all features.
* Very high-performant. Weaved code is entirely statically compiled. AspectWerkz ranks 1st or 2nd in most of the benchmarks. Read more about the figures on the AspectWerkz Bench project pages.
* Annotation support: Matching on annotations (both JavaDoc and JSR-175). Supports user-defined annotations, retrieval of annotations. Both JavaDoc and JSR-175 annotations are accessed through one single API and both schemes are strongly typed.
* Aspects, advices and introductions are written in plain old Java code. I.e. no new language to learn, no new compilation phases, no need to tell your manager ;-). Will work seamlessly in any IDE, debugger, refactoring tool and test framework.
* The target classes can be regular POJOs (Plain Old Java Objects), i.e. do not require to have an interface.
* Weaving (bytecode modification) at compile time, load time and runtime. Hooks in and transforms classes loaded by any class loader except the bootstrap class loader. Which basically means that you can easily transform any (legacy) application or external library apart from rt.jar both at runtime and compile time.
JSR-163 JVMTI is supported for Java 1.5 usage as well.
* The join point model supports: staticinitialization, method execution and call, constructor execution and call, field access, field modification, catch handlers, cflow, within and withincode, hasmethod and hasfield. All advice works with all join points.
* Rich semantics allow to access runtime information about the join point within the advice using regular types without any casting or object array access. Reflective access to runtime information is also possible.
* Introductions/Inter type declarations (also called Mixins), i.e. the possibility to add interfaces and implementations to existing classes.
* META-INF/aop.xml container: 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.
* Annotation definition. Define your aspects and mixins using annotations using wether standardized Java 5 Annotations (JSR-175) or Java 1.3/1.4 custom doclet with strongly typed access.
* XML definition. Define your aspects and mixins using XML. The XML definition can also be used to refine, override and resolve the annotation definition.
* Pluggable aspect manager that can make it work seamlessly with IoC frameworks like Spring or PicoContainer.
* Support several different deployment models (scope) for aspects (perJVM(singleton), perClass, perInstance) and for mixin (perInstance, perClass, perJVM(singleton)).
* Hot deployment, aspects can be deployed and undeployed at runtime using a simple API.
* Fine-grained pattern language for selecting the join points.
* Highly orthogonal underlying model. All advice works with all join points and pointcut composition supports mixing all kinds of pointcuts.
* "Offline" transformation (can be used as a post-processor).
* Support for passing configuration parameters to the advices through the definition.
* Simple usage and configuration.
* Extensible container architecture allows to run any Aspects (AspectWerkz, Spring AOP, AOP Alliance, subset of AspectJ) within the AspectWerkz runtime.
AspectWerkz Downloads
http://aspectwerkz.codehaus.org/releases.html
Documentation & Tutorials for AspectWerkz
http://aspectwerkz.codehaus.org/introduction.html
http://docs.codehaus.org/display/AW/Tutorials