AspectJ 5 defines a new per-clause type for aspect instantiation:
pertypewithin
. Unlike the other per-clauses,
pertypewithin
takes a type pattern:
PerTypeWithin := 'pertypewithin' '(' OptionalParensTypePattern ')'
When an aspect is declared using the pertypewithin
instantiation model, one new aspect instance will be created for each
type matched by the associated type pattern.
Pertypewithin aspects have aspectOf
and
hasAspect
methods with the following signatures:
/** * return true if this aspect has an instance associated with * the given type. */ public static boolean hasAspect(Class clazz) /** * return the instance associated with the given type. * Throws NoAspectBoundException if there is no such * aspect. */ public static P aspectOf(Class clazz)
Where P
is the type of the pertypewithin
aspect.
In addition, pertypewithin
aspects have a
getWithinTypeName
method that can be called
to return the package qualified name of the type for which the
aspect instance has been created.
/** * return the package qualified name (eg. com.foo.MyClass) of the type * for which the aspect instance has been instantiated. */ public String getWithinTypeName()
In common with the other per-clause instantiation models, the execution
of any advice declared within a pertypewithin
aspect
is conditional upon an implicit pointcut condition. In this case, that
any join point be within
the type that the executing
aspect is an aspectOf
. For example, given the aspect
definition
import java.util.*; public aspect InstanceTracking pertypewithin(org.xyz..*) { // use WeakHashMap for auto-garbage collection of keys private Map<Object,Boolean> instances = new WeakHashMap<Object,Boolean>(); after(Object o) returning() : execution(new(..)) && this(o) { instances.put(o,true); } public Set<?> getInstances() { return instances.keySet(); } }
Then one aspect instance will be created for each type within
org.xyz..*
. For each aspect instance, the
after returning advice will match only the execution of constructors
within the matched per-type-within type. The net result is that
the aspect tracks all known instances of each type within
org.xyz..*
. To get access to the instances, a
programmer can simply write
InstanceTracking.aspectOf(org.xyz.SomeType.class).getInstances()
.
The pertypewithin
aspect instantiation model should
be used when the implementation of a crosscutting concern requires that
some state be maintained for each type in a set of types. To maintain
state for a single type, it is easier to use a static inter-type declared
field. Examples of usage include instance tracking, profiling, and the
implementation of a common tracing idiom that uses one Logger per
traced class.