@Documented @Retention(value=RUNTIME) @Target(value=PARAMETER) public @interface Super
super
methods of the instrumented type where the parameter type must be a super type of the instrumented type.
The proxy type will be a direct subclass of the parameter's type such as for example a specific interface.
Obviously, the proxy type must be instantiated before it is assigned to the intercepting method's parameter. For this purpose, two strategies are available which can be specified by setting the
strategy()
parameter which can
be assigned:
Super.Instantiation.CONSTRUCTOR
:
A constructor call is made where constructorParameters()
determines the constructor's signature. Any constructor
parameter is assigned the parameter's default value when the constructor is called. Calling the default constructor is the
preconfigured strategy.Super.Instantiation.UNSAFE
:
The proxy is created by making use of Java's ReflectionFactory
which is however not a public API which
is why it should be used with care. No constructor is called when this strategy is used. If this option is set, the
constructorParameters()
parameter is ignored.Foo
that implements some interface Bar
, the proxy type
will only implement Bar
and therefore extend Object
what allows for calling the default
constructor on the proxy. This implies that an interception by some method qux(@Super Baz baz, @Super Bar bar)
would cause the creation of two super call proxies, one extending Baz
, the other extending Bar
, give
that both types are super types of Foo
.
As an exception, no method calls to
Object.finalize()
are delegated by calling this method on the super
-call
proxy by default. If this is absolutely necessary, this can however be enabled by setting ignoreFinalizer()
to false
.
If a method parameter is not a super type of the instrumented type, the method with the parameter that is annoted by #
Super
is not considered a possible delegation target.Modifier and Type | Optional Element and Description |
---|---|
Class<?>[] |
constructorParameters
Defines the parameter types of the constructor to be called for the created
super -call proxy type. |
boolean |
ignoreFinalizer
If
true , the proxy type will not implement super calls to Object.finalize() or any overridden methods. |
Class<?> |
proxyType
Determines the type that is implemented by the proxy.
|
boolean |
serializableProxy
Determines if the generated proxy should be
Serializable . |
Super.Instantiation |
strategy
Determines how the
super call proxy type is instantiated. |
public abstract Super.Instantiation strategy
super
call proxy type is instantiated.public abstract boolean ignoreFinalizer
true
, the proxy type will not implement super
calls to Object.finalize()
or any overridden methods.false
if finalizer methods should be considered for super
-call proxy type delegation.public abstract boolean serializableProxy
Serializable
. If the annotated type
already is serializable, such an explicit specification is not required.true
if the generated proxy should be Serializable
.public abstract Class<?>[] constructorParameters
super
-call proxy type.public abstract Class<?> proxyType
void
, the proxy is created as an instance of the parameter's type. When it is set to
TargetType
, it is created as an instance of the generated class. Otherwise, the proxy type
is set to the given value.void
or TargetType
.Copyright © 2014–2016. All rights reserved.