Runtime bytecode modification.
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.
The join point model supports advising of static and
member fields, static and member methods (public, private,
protected, and package protected). It also supports
advising of exceptions and caller side pointcuts.
Introductions (Mixins/Open Classes), i.e. the possibility
to add interfaces and implementations to existing classes.
Runtime attributes. You have the possibility to define
everything using runtime attributes (and skip the
XML definition completely).
Four different deployment models (scope) for both advices
and introductions: perJVM (singleton), perClass, perInstance
and perThread.
Hot deployment, advices and introductions can be
dynamically deployed, undeployed or rearranged (without
reloading or retransforming the target classes).
Very high-performant. An Advice or
Introduction adds an overhead of only
~0.00025 ms/call (on my Pentium 4 2.56 Mhz, 512 RAM).
Fine-grained pattern language for selecting the join points.
Uses the same semantics as AspectJ and AOP Alliance.
I.e. aspects, advices, pointcuts, join points and introductions.
"Offline" transformation (can be used as a post-processor).
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 ;-)
The target classes can be regular POJOs (Plain Old Java
Objects), i.e. do not need to have an interface.
Support for passing parameters to the advices through
the definition and for defining advice stacks which can
be reused.
Multiple AspectWerkz systems can be used in the same JVM concurrently.
Advice and Introduction container implementation is pluggable.
External configuration using an XML config file.
Meta-data additions to classes. Possibilities to add
meta-data to all loaded classes.