Annotation Type Super
Parameters that are annotated with this annotation are assigned an instance of an auxiliary proxy type that allows calling
any
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 whereconstructorParameters()
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'sReflectionFactory
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, theconstructorParameters()
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 annotated by #
Super
is not considered a possible delegation target.- See Also:
-
Nested Class Summary
Nested ClassesModifier and TypeClassDescriptionstatic enum
A binder for handling theSuper
annotation.static interface
A constructor resolver is responsible to specify the constructor to be used for creating a proxy.static enum
Determines the instantiation of the proxy type. -
Optional Element Summary
Optional ElementsModifier and TypeOptional ElementDescriptionClass<?>[]
Defines the parameter types of the constructor to be called for the createdsuper
-call proxy type.Class
<? extends Super.ConstructorResolver> Specifies a class to resolve a constructor of the proxied type to use for instantiation ifSuper.Instantiation.CONSTRUCTOR
is used.boolean
Iftrue
, the proxy type will not implementsuper
calls toObject.finalize()
or any overridden methods.Class
<?> Determines the type that is implemented by the proxy.boolean
Determines if the generated proxy should beSerializable
.Determines how thesuper
call proxy type is instantiated.
-
Element Details
-
strategy
Super.Instantiation strategyDetermines how thesuper
call proxy type is instantiated.- Returns:
- The instantiation strategy for this proxy.
- Default:
CONSTRUCTOR
-
ignoreFinalizer
boolean ignoreFinalizerIftrue
, the proxy type will not implementsuper
calls toObject.finalize()
or any overridden methods.- Returns:
false
if finalizer methods should be considered forsuper
-call proxy type delegation.
- Default:
true
-
serializableProxy
boolean serializableProxyDetermines if the generated proxy should beSerializable
. If the annotated type already is serializable, such an explicit specification is not required.- Returns:
true
if the generated proxy should beSerializable
.
- Default:
false
-
constructorParameters
Class<?>[] constructorParametersDefines the parameter types of the constructor to be called for the createdsuper
-call proxy type.- Returns:
- The parameter types of the constructor to be called.
- Default:
{}
-
constructorResolver
Class<? extends Super.ConstructorResolver> constructorResolverSpecifies a class to resolve a constructor of the proxied type to use for instantiation ifSuper.Instantiation.CONSTRUCTOR
is used. Note that the specified class will be loaded and instantiated by Byte Buddy in order to resolve the constructor. For this, the specified class requires a public default constructor.- Returns:
- The type of the
Super.ConstructorResolver
to use.
- Default:
net.bytebuddy.implementation.bind.annotation.Super.ConstructorResolver.Default.class
-
proxyType
Class<?> proxyTypeDetermines the type that is implemented by the proxy. When this value is set to its default valuevoid
, the proxy is created as an instance of the parameter's type. When it is set toTargetType
, it is created as an instance of the generated class. Otherwise, the proxy type is set to the given value.- Returns:
- The type of the proxy or an indicator type, i.e.
void
orTargetType
.
- Default:
void.class
-