Package | Description |
---|---|
net.bytebuddy |
Byte Buddy is a library for creating Java classes at runtime of a Java program.
|
net.bytebuddy.agent.builder |
An agent builder is used to easily implement load-time class-transformations using a Java agent.
|
net.bytebuddy.asm |
The ASM package contains classes that are meant for direct interaction with the ASM API.
|
net.bytebuddy.dynamic.scaffold |
This package contains helper types and implementations that are responsible for the actual writing of a byte array
representing a Java class.
|
net.bytebuddy.implementation |
The implementation package contains any logic for intercepting method calls.
|
net.bytebuddy.implementation.auxiliary |
Auxiliary types describe helper types that aid as a supplementary to a given
InstrumentedType . |
net.bytebuddy.implementation.bind.annotation |
This package contains annotations, types and classes that are responsible for binding a method to calling another
method by interpreting annotations that indicate how a method should be bound to another method.
|
Modifier and Type | Class and Description |
---|---|
protected static class |
ByteBuddy.EnumerationImplementation
An implementation fo the
values method of an enumeration type. |
Modifier and Type | Class and Description |
---|---|
class |
Advice
Advice wrappers copy the code of blueprint methods to be executed before and/or after a matched method.
|
Modifier and Type | Interface and Description |
---|---|
static interface |
MethodRegistry.Handler
A handler for implementing a method.
|
Modifier and Type | Class and Description |
---|---|
static class |
MethodRegistry.Handler.ForAbstractMethod
A handler for defining an abstract or native method.
|
static class |
MethodRegistry.Handler.ForAnnotationValue
A handler for defining a default annotation value for a method.
|
static class |
MethodRegistry.Handler.ForImplementation
A handler for a method that is implemented as byte code.
|
static class |
MethodRegistry.Handler.ForVisibilityBridge
A handler for implementing a visibility bridge.
|
Modifier and Type | Interface and Description |
---|---|
static interface |
FieldAccessor.AssignerConfigurable
A field accessor that can be configured to use a given assigner and runtime type use configuration.
|
static interface |
FieldAccessor.OwnerTypeLocatable
A field accessor that can be configured to locate a field in a specific manner.
|
static interface |
FieldAccessor.PropertyConfigurable
A field accessor that allows to define the access to be a field write of a given argument.
|
static interface |
FixedValue.AssignerConfigurable
Represents a fixed value implementation that is using a default assigner for attempting to assign
the fixed value to the return type of the instrumented method.
|
interface |
Implementation
An implementation is responsible for implementing methods of a dynamically created type as byte code.
|
static interface |
Implementation.Composable
Represents an implementation that can be chained together with another implementation.
|
static interface |
InvocationHandlerAdapter.AssignerConfigurable
Allows for the configuration of an
Assigner
of an InvocationHandlerAdapter . |
static interface |
InvocationHandlerAdapter.WithoutPrivilegeConfiguration
Allows the configuration of privileged lookup for the resolution of
Method
constants that are provided to the invocation handler. |
static interface |
MethodCall.ArgumentLoader.Factory
A factory that produces
MethodCall.ArgumentLoader s for a given instrumented method. |
protected static interface |
MethodCall.TargetHandler
A target handler is responsible for invoking a method for a
MethodCall . |
protected static interface |
MethodDelegation.ImplementationDelegate
An implementation delegate is responsible for executing the actual method delegation and for resolving the target methods.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultMethodCall
This
Implementation invokes a default method for the methods it instruments. |
class |
EqualsMethod
An implementation of
Object.equals(Object) that takes a class's declared fields into consideration. |
class |
ExceptionMethod
This implementation causes a
Throwable to be thrown when the instrumented method is invoked. |
class |
FieldAccessor
Defines a method to access a given field by following the Java bean conventions for getters and setters:
|
protected static class |
FieldAccessor.ForImplicitProperty
A field accessor for an implicit property where a getter or setter property is inferred from the signature.
|
protected static class |
FieldAccessor.ForSetter<T>
A field accessor for a field setter.
|
protected static class |
FieldAccessor.ForSetter.OfConstantValue
An instrumentation that sets a constant value to a field.
|
protected static class |
FieldAccessor.ForSetter.OfDefaultValue
A setter instrumentation that sets a
null or a primitive type's default value. |
protected static class |
FieldAccessor.ForSetter.OfFieldValue
A setter that reads a value of another field and sets this value.
|
protected static class |
FieldAccessor.ForSetter.OfParameterValue
A setter instrumentation for a parameter value.
|
protected static class |
FieldAccessor.ForSetter.OfReferenceValue
An instrumentation that sets a field to a reference value that is stored in a static field of the instrumented type.
|
class |
FixedValue
This implementation returns a fixed value for a method.
|
protected static class |
FixedValue.ForArgument
A fixed value implementation that returns a method's argument.
|
protected static class |
FixedValue.ForNullValue
A fixed value of
null . |
protected static class |
FixedValue.ForOriginType
A fixed value that appends the origin type of the instrumented type.
|
protected static class |
FixedValue.ForPoolValue
A fixed value implementation that represents its fixed value as a value that is written to the instrumented
class's constant pool.
|
protected static class |
FixedValue.ForThisValue
A fixed value of
this . |
protected static class |
FixedValue.ForValue
A fixed value implementation that represents its fixed value as a static field of the instrumented class.
|
class |
HashCodeMethod
An implementation of
Object.hashCode() that takes a class's declared fields into consideration. |
static class |
Implementation.Compound
A compound implementation that allows to combine several implementations.
|
static class |
Implementation.Compound.Composable
A compound implementation that allows to combine several implementations and that is
Implementation.Composable . |
static class |
Implementation.Simple
A simple implementation that does not register any members with the instrumented type.
|
class |
InvocationHandlerAdapter
An adapter for adapting an
InvocationHandler . |
protected static class |
InvocationHandlerAdapter.ForField
An implementation of an
InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in an instance field. |
protected static class |
InvocationHandlerAdapter.ForInstance
An implementation of an
InvocationHandlerAdapter that delegates method
invocations to an adapter that is stored in a static field. |
class |
InvokeDynamic
An implementation that applies a
dynamic method invocation.
|
protected static class |
InvokeDynamic.AbstractDelegator
An abstract delegator that allows to specify a configuration for any specification of an argument.
|
static class |
InvokeDynamic.WithImplicitArguments
Representation of an
InvokeDynamic implementation where the bootstrapped
method is passed a this reference, if available, and any arguments of the instrumented method. |
static class |
InvokeDynamic.WithImplicitTarget
Representation of an
InvokeDynamic implementation where the bootstrapped
method is passed a this reference, if available, and any arguments of the instrumented method and
where the invocation target is implicit. |
static class |
InvokeDynamic.WithImplicitType
An
InvokeDynamic invocation where the last argument is assigned its implicit type. |
protected static class |
InvokeDynamic.WithImplicitType.OfArgument
An invoke dynamic implementation where the last argument is an implicitly typed method argument.
|
protected static class |
InvokeDynamic.WithImplicitType.OfField
An invoke dynamic implementation where the last argument is an implicitly typed field value.
|
protected static class |
InvokeDynamic.WithImplicitType.OfInstance
A step in the invoke dynamic domain specific language that allows to explicitly specify a field type for a reference value.
|
class |
MethodCall
This
Implementation allows the invocation of a specified method while
providing explicit arguments to this method. |
protected static class |
MethodCall.ArgumentLoader.ForField.Factory
A factory for an argument loaded that loads the value of an existing field as an argument.
|
protected static class |
MethodCall.ArgumentLoader.ForInstance.Factory
A factory that supplies the value of a static field as an argument.
|
static class |
MethodCall.ArgumentLoader.ForInstrumentedType.Factory
A factory for an argument loader that supplies the instrumented type as an argument.
|
protected static class |
MethodCall.ArgumentLoader.ForMethodCall.Factory
A factory for an argument loaded that loads the return value of a method call as an argument.
|
protected static class |
MethodCall.ArgumentLoader.ForMethodParameter.Factory
A factory for an argument loader that supplies a method parameter as an argument.
|
protected static class |
MethodCall.ArgumentLoader.ForMethodParameter.OfInstrumentedMethod
A factory for argument loaders that supplies all arguments of the instrumented method as arguments.
|
static class |
MethodCall.ArgumentLoader.ForMethodParameterArray.ForInstrumentedMethod
A factory that creates an arguments loader that loads all parameters of the instrumented method contained in an array.
|
static class |
MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfInvokedMethod
An argument loader factory that loads an array element from a parameter for each argument of the invoked method.
|
protected static class |
MethodCall.ArgumentLoader.ForMethodParameterArrayElement.OfParameter
Creates an argument loader for an array element that of a specific parameter.
|
static class |
MethodCall.ArgumentLoader.ForNullConstant
An argument loader that loads the
null value onto the operand stack. |
static class |
MethodCall.ArgumentLoader.ForStackManipulation
Loads a stack manipulation resulting in a specific type as an argument.
|
static class |
MethodCall.ArgumentLoader.ForThisReference.Factory
A factory for an argument loader that supplies the
this value as an argument. |
static class |
MethodCall.FieldSetting
A
MethodCall that sets the call's result as the value of a field. |
static class |
MethodCall.TargetHandler.ForConstructingInvocation
Invokes a method in order to construct a new instance.
|
static class |
MethodCall.TargetHandler.ForField
Creates a target handler that stores the instance to invoke a method on in an instance field.
|
static class |
MethodCall.TargetHandler.ForMethodCall
A target handler that executes the method and uses it's return value as the target object.
|
static class |
MethodCall.TargetHandler.ForMethodParameter
A target handler that loads the parameter of the given index as the target object.
|
static class |
MethodCall.TargetHandler.ForSelfOrStaticInvocation
A target handler that invokes a method either on the instance of the instrumented
type or as a static method.
|
static class |
MethodCall.TargetHandler.ForValue
A target handler that invokes a method on an instance that is stored in a static field.
|
static class |
MethodCall.WithoutSpecifiedTarget
Represents a
MethodCall that invokes a method without specifying
an invocation method. |
class |
MethodDelegation
This implementation delegates an method call to another method which can either be
static by providing
a reference to a Class or an instance method when another object is provided. |
static class |
MethodDelegation.ImplementationDelegate.ForConstruction
An implementation delegate for constructing an instance.
|
static class |
MethodDelegation.ImplementationDelegate.ForField
An implementation delegate for invoking methods on a field that is declared by the instrumented type or a super type.
|
protected static class |
MethodDelegation.ImplementationDelegate.ForField.WithInstance
An implementation target for a static field that is declared by the instrumented type and that is assigned an instance.
|
protected static class |
MethodDelegation.ImplementationDelegate.ForField.WithLookup
An implementation target for a field that is declared by the instrumented type or a super type.
|
static class |
MethodDelegation.ImplementationDelegate.ForMethodReturn
An implementation delegate for invoking a delegation target on the another methods return value.
|
static class |
MethodDelegation.ImplementationDelegate.ForStaticMethod
An implementation delegate for a static method delegation.
|
class |
StubMethod
This implementation creates a method stub which does nothing but returning the default value of the return
type of the method.
|
class |
SuperMethodCall
This implementation will create a new method which simply calls its super method.
|
protected static class |
SuperMethodCall.WithoutReturn
A super method invocation where the return value is dropped instead of returning from the method.
|
class |
ToStringMethod
An implementation of
Object.toString() that concatenates the String representation of all fields that are declared by a class. |
Modifier and Type | Field and Description |
---|---|
protected List<InstrumentedType.Prepareable> |
MethodCall.preparables
A list of additional initializations for the instrumented type.
|
Constructor and Description |
---|
MethodCall(MethodCall.MethodLocator methodLocator,
MethodCall.TargetHandler targetHandler,
List<MethodCall.ArgumentLoader.Factory> argumentLoaders,
List<InstrumentedType.Prepareable> preparables,
MethodCall.MethodInvoker methodInvoker,
MethodCall.TerminationHandler.Factory terminationHandler,
Assigner assigner,
Assigner.Typing typing)
Creates a new method call implementation.
|
Modifier and Type | Class and Description |
---|---|
protected static class |
MethodCallProxy.ConstructorCall
An implementation for a constructor of a
MethodCallProxy . |
protected static class |
MethodCallProxy.MethodCall
An implementation for a method of a
MethodCallProxy . |
protected class |
TypeProxy.MethodCall
An implementation for a method call of a
TypeProxy . |
protected static class |
TypeProxy.SilentConstruction
An implementation of a silent construction of a given type by using the non-standardized
ReflectionFactory . |
Modifier and Type | Class and Description |
---|---|
protected static class |
FieldProxy.Binder.FieldGetter
Implementation for a getter method.
|
protected static class |
FieldProxy.Binder.FieldSetter
Implementation for a setter method.
|
protected static class |
FieldProxy.Binder.InstanceFieldConstructor
Represents an implementation for implementing a proxy type constructor when a non-static field is accessed.
|
protected static class |
FieldProxy.Binder.StaticFieldConstructor
Represents an implementation for implementing a proxy type constructor when a static field is accessed.
|
protected static class |
Morph.Binder.RedirectionProxy.InstanceFieldConstructor
Creates an instance of the proxy when instrumenting an instance method.
|
protected static class |
Morph.Binder.RedirectionProxy.MethodCall
Implements a the method call of the morphing method.
|
protected static class |
Morph.Binder.RedirectionProxy.StaticFieldConstructor
Creates an instance of the proxy when instrumenting a static method.
|
protected static class |
Pipe.Binder.Redirection.ConstructorCall
The implementation to implement a
Pipe.Binder.Redirection 's
constructor. |
protected static class |
Pipe.Binder.Redirection.MethodCall
The implementation to implement a
Pipe.Binder.Redirection 's
forwarding method. |
Copyright © 2014–2019. All rights reserved.