net.bytebuddy.dynamic

Interface DynamicType.Builder<T>

Type Parameters:

T - The most specific known loaded type that is implemented by the created dynamic type, usually the type itself, an interface or the direct super class.

All Known Subinterfaces:

DynamicType.Builder.FieldAnnotationTarget<S>, DynamicType.Builder.FieldValueTarget<S>, DynamicType.Builder.MethodAnnotationTarget<S>, DynamicType.Builder.OptionalMatchedMethodInterception<S>

All Known Implementing Classes:

DynamicType.Builder.AbstractBase, DynamicType.Builder.AbstractBase.AbstractDelegatingBuilder, DynamicType.Builder.AbstractBase.DefaultFieldValueTarget, DynamicType.Builder.AbstractBase.DefaultMethodAnnotationTarget, DynamicType.Builder.AbstractBase.DefaultOptionalMatchedMethodInterception, RebaseDynamicTypeBuilder, RedefinitionDynamicTypeBuilder, SubclassDynamicTypeBuilder

Enclosing interface:

DynamicType

public static interface DynamicType.Builder<T>

A builder for defining a dynamic type. Implementations of such builders are fully immutable and return modified instances.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	DynamicType.Builder.AbstractBase<S> An abstract base implementation for a dynamic type builder.
static interface	DynamicType.Builder.ExceptionDeclarableMethodInterception<S> Defines an implementation for a method that was added to this instrumentation and allows to include exception declarations for the newly defined method.
static interface	DynamicType.Builder.FieldAnnotationTarget<S> A builder to which a field was just added such that attribute changes can be applied to this field.
static interface	DynamicType.Builder.FieldValueTarget<S> A builder to which a field was just added such that default values can be defined for the field.
static interface	DynamicType.Builder.MatchedMethodInterception<S> Defines an implementation for a method that was added to this instrumentation or a to method selection of existing methods.
static interface	DynamicType.Builder.MethodAnnotationTarget<S> A builder to which a method was just added or an interception for existing methods was specified such that attribute changes can be applied to these methods.
static interface	DynamicType.Builder.OptionalMatchedMethodInterception<S> An optional matched method interception allows to define an interception without requiring the definition of an implementation.

Method Summary

Modifier and Type	Method and Description
DynamicType.Builder<T>	annotateType(Annotation... annotation) Adds annotations to the currently constructed type.
DynamicType.Builder<T>	annotateType(AnnotationDescription... annotation) Adds annotations to the currently constructed type.
DynamicType.Builder<T>	annotateType(Collection<? extends AnnotationDescription> annotations) Adds annotations to the currently constructed type.
DynamicType.Builder<T>	annotateType(Iterable<? extends Annotation> annotations) Adds annotations to the currently constructed type.
DynamicType.Builder<T>	attribute(TypeAttributeAppender attributeAppender) Adds an attribute appender to the currently constructed type which will be applied on the creation of the type.
DynamicType.Builder<T>	classFileVersion(ClassFileVersion classFileVersion) Defines a class file format version for this builder for which the dynamic types should be created.
DynamicType.Builder<T>	classVisitor(ClassVisitorWrapper classVisitorWrapper) Adds an additional ASM ClassVisitor to this builder which will be applied in the construction process of this dynamic type.
DynamicType.Builder.MatchedMethodInterception<T>	constructor(ElementMatcher<? super MethodDescription> methodMatcher) Selects a set of constructors of this type for implementation.
DynamicType.Builder<T>	context(Implementation.Context.Factory implementationContextFactory) Defines a factory for creating an implementation context.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	define(MethodDescription methodDescription) Defines a new method or constructor for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineConstructor(Constructor<?> constructor) Defines a new constructor for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineConstructor(Iterable<? extends Class<?>> parameterTypes, int modifiers) Defines a new constructor for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineConstructor(Iterable<? extends Class<?>> parameterTypes, ModifierContributor.ForMethod... modifier) Defines a new constructor for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineConstructor(List<? extends TypeDescription> parameterTypes, int modifiers) Defines a new constructor for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineConstructor(List<? extends TypeDescription> parameterTypes, ModifierContributor.ForMethod... modifier) Defines a new constructor for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineConstructor(MethodDescription methodDescription) Defines a new constructor for this type.
DynamicType.Builder.FieldValueTarget<T>	defineField(Field field) Defines a new field for this type.
DynamicType.Builder.FieldValueTarget<T>	defineField(FieldDescription fieldDescription) Defines a new field for this type.
DynamicType.Builder.FieldValueTarget<T>	defineField(String name, Class<?> fieldType, int modifiers) Defines a new field for this type.
DynamicType.Builder.FieldValueTarget<T>	defineField(String name, Class<?> fieldType, ModifierContributor.ForField... modifier) Defines a new field for this type.
DynamicType.Builder.FieldValueTarget<T>	defineField(String name, TypeDescription fieldTypeDescription, int modifiers) Defines a new field for this type.
DynamicType.Builder.FieldValueTarget<T>	defineField(String name, TypeDescription fieldTypeDescription, ModifierContributor.ForField... modifier) Defines a new field for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineMethod(Method method) Defines a new method for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineMethod(MethodDescription methodDescription) Defines a new method for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineMethod(String name, Class<?> returnType, List<? extends Class<?>> parameterTypes, int modifiers) Defines a new method for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineMethod(String name, Class<?> returnType, List<? extends Class<?>> parameterTypes, ModifierContributor.ForMethod... modifier) Defines a new method for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineMethod(String name, TypeDescription returnType, List<? extends TypeDescription> parameterTypes, int modifiers) Defines a new method for this type.
DynamicType.Builder.ExceptionDeclarableMethodInterception<T>	defineMethod(String name, TypeDescription returnType, List<? extends TypeDescription> parameterTypes, ModifierContributor.ForMethod... modifier) Defines a new method for this type.
DynamicType.Builder<T>	ignoreMethods(ElementMatcher<? super MethodDescription> ignoredMethods) Defines a matcher for methods that will be ignored for any interception attempt.
DynamicType.Builder.OptionalMatchedMethodInterception<T>	implement(Class<?>... interfaceType) Adds the given interfaces to be implemented by the created type.
DynamicType.Builder.OptionalMatchedMethodInterception<T>	implement(Collection<? extends TypeDescription> interfaceTypes) Adds the given interfaces to be implemented by the created type.
DynamicType.Builder.OptionalMatchedMethodInterception<T>	implement(Iterable<? extends Class<?>> interfaceTypes) Adds the given interfaces to be implemented by the created type.
DynamicType.Builder.OptionalMatchedMethodInterception<T>	implement(TypeDescription... interfaceType) Adds the given interfaces to be implemented by the created type.
DynamicType.Builder<T>	initialize(ByteCodeAppender byteCodeAppender) Defines an explicit type initialization block that is appended to any potentially existing type initializer.
DynamicType.Builder.MatchedMethodInterception<T>	invokable(ElementMatcher<? super MethodDescription> methodMatcher) Selects a set of byte code level methods, i.e.
DynamicType.Builder.MatchedMethodInterception<T>	invokable(LatentMethodMatcher methodMatcher) Selects a set of byte code level methods, i.e.
DynamicType.Unloaded<T>	make() Creates the dynamic type without loading it.
DynamicType.Builder.MatchedMethodInterception<T>	method(ElementMatcher<? super MethodDescription> methodMatcher) Selects a set of methods of this type for instrumentation.
DynamicType.Builder<T>	methodGraphCompiler(MethodGraph.Compiler methodGraphCompiler) Defines the given method graph compiler to be used for analyzing the structure of types.
DynamicType.Builder<T>	modifiers(int modifiers) Defines modifiers for the created dynamic type.
DynamicType.Builder<T>	modifiers(ModifierContributor.ForType... modifier) Defines modifiers for the created dynamic type.
DynamicType.Builder<T>	name(AuxiliaryType.NamingStrategy namingStrategy) Defines a naming strategy for naming auxiliary types.
DynamicType.Builder<T>	name(NamingStrategy namingStrategy) Names the currently created dynamic type by the given naming strategy.
DynamicType.Builder<T>	name(String name) Names the currently created dynamic type by a fixed name.

Method Detail

classFileVersion

DynamicType.Builder<T> classFileVersion(ClassFileVersion classFileVersion)

Defines a class file format version for this builder for which the dynamic types should be created.

Parameters:

classFileVersion - The class format version for the dynamic type to implement.

Returns:

A builder that writes its classes in a given class format version.

implement

DynamicType.Builder.OptionalMatchedMethodInterception<T> implement(Class<?>... interfaceType)

Adds the given interfaces to be implemented by the created type.

Parameters:

interfaceType - The interfaces to implement.

Returns:

A builder which will create a dynamic type that implements the given interfaces.

implement

DynamicType.Builder.OptionalMatchedMethodInterception<T> implement(Iterable<? extends Class<?>> interfaceTypes)

Adds the given interfaces to be implemented by the created type.

Parameters:

interfaceTypes - The interfaces to implement.

Returns:

A builder which will create a dynamic type that implements the given interfaces.

implement

DynamicType.Builder.OptionalMatchedMethodInterception<T> implement(TypeDescription... interfaceType)

Adds the given interfaces to be implemented by the created type.

Parameters:

interfaceType - A description of the interfaces to implement.

Returns:

A builder which will create a dynamic type that implements the given interfaces.

implement

DynamicType.Builder.OptionalMatchedMethodInterception<T> implement(Collection<? extends TypeDescription> interfaceTypes)

Adds the given interfaces to be implemented by the created type.

Parameters:

interfaceTypes - A description of the interfaces to implement.

Returns:

A builder which will create a dynamic type that implements the given interfaces.

name

DynamicType.Builder<T> name(String name)

Names the currently created dynamic type by a fixed name.

Parameters:

name - A fully qualified name to give to the created dynamic type.

Returns:

A builder that will name its dynamic type by the given name.

name

DynamicType.Builder<T> name(NamingStrategy namingStrategy)

Names the currently created dynamic type by the given naming strategy.

Parameters:

namingStrategy - The naming strategy to apply.

Returns:

A builder that creates a type by applying the given naming strategy.

name

DynamicType.Builder<T> name(AuxiliaryType.NamingStrategy namingStrategy)

Defines a naming strategy for naming auxiliary types.

Parameters:

namingStrategy - The naming strategy to use.

Returns:

This builder where the auxiliary naming strategy was set to be used.

context

DynamicType.Builder<T> context(Implementation.Context.Factory implementationContextFactory)

Defines a factory for creating an implementation context.

Parameters:

implementationContextFactory - The implementation context factory to use.

Returns:

This builder where the implementation context factory was set to be used.

initialize

DynamicType.Builder<T> initialize(ByteCodeAppender byteCodeAppender)

Defines an explicit type initialization block that is appended to any potentially existing type initializer. This initializer is run before any other code.

Parameters:

byteCodeAppender - The byte code appender that represents the code. This initializer must not return.

Returns:

A version of this builder with the supplied appender added as a type initilaization block.

modifiers

DynamicType.Builder<T> modifiers(ModifierContributor.ForType... modifier)

Defines modifiers for the created dynamic type.

Parameters:

modifier - A collection of modifiers to be reflected by the created dynamic type.

Returns:

A builder that will create a dynamic type that reflects the given modifiers.

modifiers

DynamicType.Builder<T> modifiers(int modifiers)

Defines modifiers for the created dynamic type.

Parameters:

modifiers - The modifiers to be reflected by the created dynamic type.

Returns:

A builder that will create a dynamic type that reflects the given modifiers.

ignoreMethods

DynamicType.Builder<T> ignoreMethods(ElementMatcher<? super MethodDescription> ignoredMethods)

Defines a matcher for methods that will be ignored for any interception attempt. Any methods that were directly declared on an instrumented type will never be ignored, i.e. ignored methods only represent a filter for methods that are declared in super types that should never be overriden.

Parameters:

ignoredMethods - A method matcher characterizing the methods to be ignored.

Returns:

A builder that will always ignore the methods matched by the given method matcher.

attribute

DynamicType.Builder<T> attribute(TypeAttributeAppender attributeAppender)

Adds an attribute appender to the currently constructed type which will be applied on the creation of the type.

Parameters:

attributeAppender - An attribute appender to be applied onto the currently created type.

Returns:

A builder that will apply the given attribute appender onto the currently created type.

annotateType

DynamicType.Builder<T> annotateType(Annotation... annotation)

Adds annotations to the currently constructed type.

Note: The annotations will not be visible to Implementations.

Parameters:

annotation - The annotations to be added to the currently constructed type.

Returns:

A builder that will add the given annotation to the created type.

annotateType

DynamicType.Builder<T> annotateType(Iterable<? extends Annotation> annotations)

Adds annotations to the currently constructed type.

Note: The annotations will not be visible to Implementations.

Parameters:

annotations - The annotations to be added to the currently constructed type.

Returns:

A builder that will add the given annotation to the created type.

annotateType

DynamicType.Builder<T> annotateType(AnnotationDescription... annotation)

Adds annotations to the currently constructed type.

Note: The annotations will not be visible to Implementations.

Parameters:

annotation - The annotations to be added to the currently constructed type.

Returns:

A builder that will add the given annotation to the created type.

annotateType

DynamicType.Builder<T> annotateType(Collection<? extends AnnotationDescription> annotations)

Adds annotations to the currently constructed type.

Note: The annotations will not be visible to Implementations.

Parameters:

annotations - The annotations to be added to the currently constructed type.

Returns:

A builder that will add the given annotation to the created type.

classVisitor

DynamicType.Builder<T> classVisitor(ClassVisitorWrapper classVisitorWrapper)

Adds an additional ASM ClassVisitor to this builder which will be applied in the construction process of this dynamic type.

Parameters:

classVisitorWrapper - The wrapper delegate for the ASM class visitor.

Returns:

A builder that will apply the given ASM class visitor.

methodGraphCompiler

DynamicType.Builder<T> methodGraphCompiler(MethodGraph.Compiler methodGraphCompiler)

Defines the given method graph compiler to be used for analyzing the structure of types.

Parameters:

methodGraphCompiler - The method graph compiler to be used.

Returns:

A builder that will apply the given method graph compiler.

defineField

DynamicType.Builder.FieldValueTarget<T> defineField(String name,
                                                    Class<?> fieldType,
                                                    ModifierContributor.ForField... modifier)

Defines a new field for this type.

Parameters:

name - The name of the method.

fieldType - The type of this field where the current type can be represented by TargetType.

modifier - The modifiers for this method.

Returns:

An interception delegate that exclusively matches the new method.

defineField

DynamicType.Builder.FieldValueTarget<T> defineField(String name,
                                                    TypeDescription fieldTypeDescription,
                                                    ModifierContributor.ForField... modifier)

Defines a new field for this type.

Parameters:

name - The name of the method.

fieldTypeDescription - The type of this field where the current type can be represented by TargetType.

modifier - The modifiers for this method.

Returns:

An interception delegate that exclusively matches the new method.

defineField

DynamicType.Builder.FieldValueTarget<T> defineField(String name,
                                                    Class<?> fieldType,
                                                    int modifiers)

Defines a new field for this type.

Parameters:

name - The name of the method.

fieldType - The type of this field where the current type can be represented by TargetType.

modifiers - The modifiers for this method.

Returns:

An interception delegate that exclusively matches the new method.

defineField

DynamicType.Builder.FieldValueTarget<T> defineField(String name,
                                                    TypeDescription fieldTypeDescription,
                                                    int modifiers)

Defines a new field for this type.

Parameters:

name - The name of the method.

fieldTypeDescription - The type of this field where the current type can be represented by TargetType.

modifiers - The modifiers for this method.

Returns:

An interception delegate that exclusively matches the new method.

defineField

DynamicType.Builder.FieldValueTarget<T> defineField(Field field)

Defines a new field for this type. The annotations of the given field are not copied and must be added manually if they are required.

Parameters:

field - The field that the generated type should imitate.

Returns:

An interception delegate that exclusively matches the new method.

defineField

DynamicType.Builder.FieldValueTarget<T> defineField(FieldDescription fieldDescription)

Defines a new field for this type. The annotations of the given field are not copied and must be added manually if they are required.

Parameters:

fieldDescription - The field that the generated type should imitate.

Returns:

An interception delegate that exclusively matches the new method.

defineMethod

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineMethod(String name,
                                                                          Class<?> returnType,
                                                                          List<? extends Class<?>> parameterTypes,
                                                                          ModifierContributor.ForMethod... modifier)

Defines a new method for this type.

Note that a method definition overrides any method of identical signature that was defined in a super type what is only valid if the method is of at least broader visibility and if the overridden method is not final.

Parameters:

name - The name of the method.

returnType - The return type of the method where the current type can be represented by TargetType.

parameterTypes - The parameter types of this method where the current type can be represented by TargetType.

modifier - The modifiers for this method.

Returns:

An interception delegate that exclusively matches the new method.

defineMethod

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineMethod(String name,
                                                                          TypeDescription returnType,
                                                                          List<? extends TypeDescription> parameterTypes,
                                                                          ModifierContributor.ForMethod... modifier)

Defines a new method for this type.

Note that a method definition overrides any method of identical signature that was defined in a super type what is only valid if the method is of at least broader visibility and if the overridden method is not final.

Parameters:

name - The name of the method.

returnType - A description of the return type of the method where the current type can be represented by TargetType.

parameterTypes - Descriptions of the parameter types of this method where the current type can be represented by TargetType.

modifier - The modifiers for this method.

Returns:

An interception delegate that exclusively matches the new method.

defineMethod

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineMethod(String name,
                                                                          Class<?> returnType,
                                                                          List<? extends Class<?>> parameterTypes,
                                                                          int modifiers)

Defines a new method for this type.

Note that a method definition overrides any method of identical signature that was defined in a super type what is only valid if the method is of at least broader visibility and if the overridden method is not final.

Parameters:

name - The name of the method.

returnType - The return type of the method where the current type can be represented by TargetType.

parameterTypes - The parameter types of this method where the current type can be represented by TargetType.

modifiers - The modifiers for this method.

Returns:

An interception delegate that exclusively matches the new method.

defineMethod

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineMethod(String name,
                                                                          TypeDescription returnType,
                                                                          List<? extends TypeDescription> parameterTypes,
                                                                          int modifiers)

Defines a new method for this type.

Note that a method definition overrides any method of identical signature that was defined in a super type what is only valid if the method is of at least broader visibility and if the overridden method is not final.

Parameters:

name - The name of the method.

returnType - A description of the return type of the method where the current type can be represented by TargetType.

parameterTypes - Descriptions of the parameter types of this method where the current type can be represented by TargetType.

modifiers - The modifiers for this method.

Returns:

An interception delegate that exclusively matches the new method.

defineMethod

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineMethod(Method method)

Defines a new method for this type. Declared exceptions or annotations of the method are not copied and must be added manually.

Note that a method definition overrides any method of identical signature that was defined in a super type what is only valid if the method is of at least broader visibility and if the overridden method is not final.

Parameters:

method - The method that the generated type should imitate.

Returns:

An interception delegate that exclusively matches the new method.

defineMethod

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineMethod(MethodDescription methodDescription)

Defines a new method for this type. Declared exceptions or annotations of the method are not copied and must be added manually.

Note that a method definition overrides any method of identical signature that was defined in a super type what is only valid if the method is of at least broader visibility and if the overridden method is not final.

Parameters:

methodDescription - The method that the generated type should imitate.

Returns:

An interception delegate that exclusively matches the new method.

defineConstructor

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineConstructor(Iterable<? extends Class<?>> parameterTypes,
                                                                               ModifierContributor.ForMethod... modifier)

Defines a new constructor for this type. A constructor must not be static. Instead, a static type initializer is added automatically if such an initializer is required. See ElementMatchers.isTypeInitializer() for a matcher for this initializer which can be intercepted using invokable(net.bytebuddy.matcher.ElementMatcher).

Note that a constructor's implementation must call another constructor of the same class or a constructor of its super class. This constructor call must be hardcoded inside of the constructor's method body. Before this constructor call is made, it is not legal to call any methods or to read any fields of the instance under construction.

Parameters:

parameterTypes - The parameter types of this constructor where the current type can be represented by TargetType.

modifier - The modifiers for this constructor.

Returns:

An interception delegate that exclusively matches the new constructor.

defineConstructor

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineConstructor(List<? extends TypeDescription> parameterTypes,
                                                                               ModifierContributor.ForMethod... modifier)

Defines a new constructor for this type. A constructor must not be static. Instead, a static type initializer is added automatically if such an initializer is required. See ElementMatchers.isTypeInitializer() for a matcher for this initializer which can be intercepted using invokable(net.bytebuddy.matcher.ElementMatcher).

Note that a constructor's implementation must call another constructor of the same class or a constructor of its super class. This constructor call must be hardcoded inside of the constructor's method body. Before this constructor call is made, it is not legal to call any methods or to read any fields of the instance under construction.

Parameters:

parameterTypes - The parameter types of this constructor where the current type can be represented by TargetType.

modifier - The modifiers for this constructor.

Returns:

An interception delegate that exclusively matches the new constructor.

defineConstructor

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineConstructor(Iterable<? extends Class<?>> parameterTypes,
                                                                               int modifiers)

Defines a new constructor for this type. A constructor must not be static. Instead, a static type initializer is added automatically if such an initializer is required. See ElementMatchers.isTypeInitializer() for a matcher for this initializer which can be intercepted using invokable(net.bytebuddy.matcher.ElementMatcher).

Note that a constructor's implementation must call another constructor of the same class or a constructor of its super class. This constructor call must be hardcoded inside of the constructor's method body. Before this constructor call is made, it is not legal to call any methods or to read any fields of the instance under construction.

Parameters:

parameterTypes - The parameter types of this constructor where the current type can be represented by TargetType.

modifiers - The modifiers for this constructor.

Returns:

An interception delegate that exclusively matches the new constructor.

defineConstructor

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineConstructor(List<? extends TypeDescription> parameterTypes,
                                                                               int modifiers)

Defines a new constructor for this type. A constructor must not be static. Instead, a static type initializer is added automatically if such an initializer is required. See ElementMatchers.isTypeInitializer() for a matcher for this initializer which can be intercepted using invokable(net.bytebuddy.matcher.ElementMatcher).

Note that a constructor's implementation must call another constructor of the same class or a constructor of its super class. This constructor call must be hardcoded inside of the constructor's method body. Before this constructor call is made, it is not legal to call any methods or to read any fields of the instance under construction.

Parameters:

parameterTypes - The parameter types of this constructor where the current type can be represented by TargetType.

modifiers - The modifiers for this constructor.

Returns:

An interception delegate that exclusively matches the new constructor.

defineConstructor

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineConstructor(Constructor<?> constructor)

Defines a new constructor for this type. A constructor must not be static. Instead, a static type initializer is added automatically if such an initializer is required. See ElementMatchers.isTypeInitializer() for a matcher for this initializer which can be intercepted using invokable(net.bytebuddy.matcher.ElementMatcher). Declared exceptions or annotations of the method are not copied and must be added manually.

Note that a constructor's implementation must call another constructor of the same class or a constructor of its super class. This constructor call must be hardcoded inside of the constructor's method body. Before this constructor call is made, it is not legal to call any methods or to read any fields of the instance under construction.

Parameters:

constructor - The constructor for the generated type to imitate.

Returns:

An interception delegate that exclusively matches the new constructor.

defineConstructor

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> defineConstructor(MethodDescription methodDescription)

Defines a new constructor for this type. A constructor must not be static. Instead, a static type initializer is added automatically if such an initializer is required. See ElementMatchers.isTypeInitializer() for a matcher for this initializer which can be intercepted using invokable(net.bytebuddy.matcher.ElementMatcher). Declared exceptions or annotations of the method are not copied and must be added manually.

Note that a constructor's implementation must call another constructor of the same class or a constructor of its super class. This constructor call must be hardcoded inside of the constructor's method body. Before this constructor call is made, it is not legal to call any methods or to read any fields of the instance under construction.

Parameters:

methodDescription - The constructor for the generated type to imitate.

Returns:

An interception delegate that exclusively matches the new constructor.

define

DynamicType.Builder.ExceptionDeclarableMethodInterception<T> define(MethodDescription methodDescription)

Defines a new method or constructor for this type. Declared exceptions or annotations of the method are not copied and must be added manually.

Note that a method definition overrides any method of identical signature that was defined in a super type what is only valid if the method is of at least broader visibility and if the overridden method is not final.

Parameters:

methodDescription - The method tor constructor hat the generated type should imitate.

Returns:

An interception delegate that exclusively matches the new method or constructor.

method

DynamicType.Builder.MatchedMethodInterception<T> method(ElementMatcher<? super MethodDescription> methodMatcher)

Selects a set of methods of this type for instrumentation.

Parameters:

methodMatcher - A matcher describing the methods to be intercepted by this instrumentation.

Returns:

An interception delegate for methods matching the given method matcher.

constructor

DynamicType.Builder.MatchedMethodInterception<T> constructor(ElementMatcher<? super MethodDescription> methodMatcher)

Selects a set of constructors of this type for implementation.

Parameters:

methodMatcher - A matcher describing the constructors to be intercepted by this implementation.

Returns:

An interception delegate for constructors matching the given method matcher.

invokable

DynamicType.Builder.MatchedMethodInterception<T> invokable(ElementMatcher<? super MethodDescription> methodMatcher)

Selects a set of byte code level methods, i.e. methods, constructors and the type initializer of this type for implementation.

Parameters:

methodMatcher - A matcher describing the byte code methods to be intercepted by this implementation.

Returns:

An interception delegate for byte code methods matching the given method matcher.

invokable

DynamicType.Builder.MatchedMethodInterception<T> invokable(LatentMethodMatcher methodMatcher)

Selects a set of byte code level methods, i.e. methods, construcors and the type initializer of this type for implementation.

Parameters:

methodMatcher - A latent matcher describing the byte code methods to be intercepted by this implementation.

Returns:

An interception delegate for byte code methods matching the given method matcher.

make

DynamicType.Unloaded<T> make()

Creates the dynamic type without loading it.

Returns:

An unloaded representation of the dynamic type.