Package net.bytebuddy.instrumentation

The instrumentation package contains any logic for intercepting method calls.

See: Description

Interface Summary

Interface	Description
ByteCodeElement	Implementations describe an element represented in byte code, i.e.
ExceptionMethod.ConstructionDelegate	A construction delegate is responsible for calling a isThrowable's constructor.
FieldAccessor.AssignerConfigurable	A field accessor that can be configured to use a given assigner and runtime type use configuration.
FieldAccessor.FieldDefinable	Determines a field accessor that accesses a field of a given name which might not yet be defined.
FieldAccessor.FieldLocator	A field locator allows to determine a field name for a given method.
FieldAccessor.FieldLocator.Factory	A factory for creating a FieldAccessor.FieldLocator.
FieldAccessor.FieldNameExtractor	A field name extractor is responsible for determining a field name to a method that is implemented to access this method.
FieldAccessor.OwnerTypeLocatable	A field accessor that can be configured to locate a field in a specific manner.
FixedValue.AssignerConfigurable	Represents a fixed value instrumentation that is using a default assigner for attempting to assign the fixed value to the return type of the instrumented method.
Forwarding.PreparationHandler	A handler for preparing a Forwarding instrumentation.
Instrumentation	An instrumentation is responsible for implementing (or not implementing) methods of a dynamically created type.
Instrumentation.Context	The context for an instrumentation application.
Instrumentation.Context.Default.AuxiliaryTypeNamingStrategy	Representation of a naming strategy for an auxiliary type.
Instrumentation.Context.ExtractableView	Represents an extractable view of an Instrumentation.Context which allows the retrieval of any registered auxiliary type.
Instrumentation.Context.ExtractableView.InjectedCode	When draining an instrumentation context, a type initializer might be written to the created class file.
Instrumentation.SpecialMethodInvocation	Represents an type-specific method invocation on the current instrumented type which is not legal from outside the type such as a super method or default method invocation.
Instrumentation.Target	The target of an instrumentation.
Instrumentation.Target.Factory	A factory for creating an Instrumentation.Target.
Instrumentation.Target.MethodLookup	A strategy for looking up a method.
InvocationHandlerAdapter.AssignerConfigurable	Allows for the configuration of an Assigner of an InvocationHandlerAdapter.
LoadedTypeInitializer	Implementations of this interface explicitly initialize a loaded type.
MethodDelegation.InstrumentationDelegate	An instrumentation delegate is responsible for executing the actual method delegation.
ModifierContributor	An element that describes a type modifier as described in the JVMS.
ModifierContributor.ForField	A marker interface for modifiers that can be applied to fields.
ModifierContributor.ForMethod	A marker interface for modifiers that can be applied to methods.
ModifierContributor.ForType	A marker interface for modifiers that can be applied to types.
ModifierReviewable	Implementations of this interface can be described in terms of a Java modifier.
NamedElement	Represents a Java element with a name.

Class Summary

Class	Description
DefaultMethodCall	This Instrumentation invokes a default method for the methods it instruments.
DefaultMethodCall.Appender	The appender for implementing a DefaultMethodCall.
ExceptionMethod	This instrumentation causes a Throwable to be thrown when the instrumented method is invoked.
ExceptionMethod.ConstructionDelegate.ForDefaultConstructor	A construction delegate that calls the default constructor.
ExceptionMethod.ConstructionDelegate.ForStringConstructor	A construction delegate that calls a constructor that takes a single string as its argument.
FieldAccessor	Defines a method to access a given field by following the Java bean conventions for getters and setters: Getter: A method named getFoo() will be instrumented to read and return the value of a field foo or another field if one was specified explicitly.
FieldAccessor.FieldLocator.ForGivenType	A field locator that only looks up fields that are defined for a given type.
FieldAccessor.FieldLocator.ForGivenType.Factory	A factory for a field locator locating given type.
FieldAccessor.FieldLocator.ForInstrumentedTypeHierarchy	A field locator that finds a type by traversing the type hierarchy beginning with fields defined in the most specific subclass traversing the class hierarchy down to the least specific type.
FieldAccessor.ForNamedField	Implementation of a field accessor instrumentation where the field name is given explicitly.
FieldAccessor.ForUnnamedField	Implementation of a field accessor instrumentation where a field is identified by a method's name following the Java specification for bean properties.
FixedValue	This instrumentation returns a fixed value for a method.
FixedValue.ForPoolValue	A fixed value instrumentation that represents its fixed value as a value that is written to the instrumented class's constant pool.
FixedValue.ForStaticField	A fixed value instrumentation that represents its fixed value as a static field of the instrumented class.
Forwarding	This instrumentation forwards method invocations to another instance.
Forwarding.PreparationHandler.ForStaticInstance	A preparation handler for an explicit instance that is stored in a static field.
Instrumentation.Compound	A compound instrumentation that allows to combine several instrumentations.
Instrumentation.Context.Default	A default implementation of an Instrumentation.Context.ExtractableView which serves as its own AuxiliaryType.MethodAccessorFactory.
Instrumentation.Context.Default.AccessorMethodDelegation	An implementation of a TypeWriter.MethodPool.Entry for implementing an accessor method.
Instrumentation.Context.Default.AuxiliaryTypeNamingStrategy.SuffixingRandom	A naming strategy for an auxiliary type which returns the instrumented type's name with a fixed extension and a random number as a suffix.
Instrumentation.Context.Default.FieldCacheAppender	A byte code appender that writes the field cache entries to a given MethodVisitor.
Instrumentation.Context.Default.FieldCacheEntry	A field cache entry for uniquely identifying a cached field.
Instrumentation.Context.Default.FieldGetter	An implementation for a field getter.
Instrumentation.Context.Default.FieldSetter	An implementation for a field setter.
Instrumentation.Simple	A simple implementation of an instrumentation that does not register any members with the instrumented type.
Instrumentation.SpecialMethodInvocation.Simple	A canonical implementation of a Instrumentation.SpecialMethodInvocation.
Instrumentation.Target.AbstractBase	An abstract base implementation for an Instrumentation.Target.
InvocationHandlerAdapter	An adapter for adapting an InvocationHandler.
InvocationHandlerAdapter.ForInstanceDelegation	An implementation of an InvocationHandlerAdapter that delegates method invocations to an adapter that is stored in an instance field.
InvocationHandlerAdapter.ForStaticDelegation	An implementation of an InvocationHandlerAdapter that delegates method invocations to an adapter that is stored in a static field.
LoadedTypeInitializer.Compound	A compound loaded type initializer that combines several type initializers.
LoadedTypeInitializer.ForStaticField<T>	A type initializer for setting a value for a static field.
MethodDelegation	This instrumentation 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.
MethodDelegation.Appender	The appender for implementing a MethodDelegation.
MethodDelegation.InstrumentationDelegate.ForConstruction	An instrumentation that creates new instances of a given type.
MethodDelegation.InstrumentationDelegate.ForInstanceField	An instrumentation applied on an instance field.
MethodDelegation.InstrumentationDelegate.ForStaticField	An instrumentation applied on a static field.
ModifierReviewable.AbstractModifierReviewable	An abstract base implementation of a ModifierReviewable class.
SuperMethodCall.Appender	An appender for implementing a SuperMethodCall.

Enum Summary

Enum	Description
FieldAccessor.FieldLocator.ForInstrumentedType	A factory that only looks up fields in the instrumented type.
FieldAccessor.FieldLocator.ForInstrumentedTypeHierarchy.Factory	A field locator factory creating a FieldAccessor.FieldLocator.ForInstrumentedTypeHierarchy.
FieldAccessor.FieldNameExtractor.ForBeanProperty	A FieldAccessor.FieldNameExtractor that determines a field name according to the rules of Java bean naming conventions.
Forwarding.PreparationHandler.ForInstanceField	A preparation handler for an unset instance that is stored in an instance field.
Forwarding.PreparationHandler.ForStaticField	A preparation handler for an unset instance that is stored in a static field.
Instrumentation.Context.ExtractableView.InjectedCode.None	A canonical implementation of non-applicable injected code.
Instrumentation.ForAbstractMethod	An instrumentation for an abstract method that does not append any code and will throw an exception if it is attempted to be composed with other methods that do provide an implementation.
Instrumentation.SpecialMethodInvocation.Illegal	A canonical implementation of an illegal Instrumentation.SpecialMethodInvocation.
Instrumentation.Target.MethodLookup.Default	Default implementations of a Instrumentation.Target.MethodLookup.
LoadedTypeInitializer.NoOp	A loaded type initializer that does not do anything.
MethodDelegation.InstrumentationDelegate.ForStaticMethod	An instrumentation applied to a static method.
StubMethod	This instrumentation creates a method stub which does nothing but returning the default value of the return type of the method.
SuperMethodCall	This instrumentation will create a new method which simply calls its super method.

Package net.bytebuddy.instrumentation Description

The instrumentation package contains any logic for intercepting method calls. The following instrumentations ship with Byte Buddy:

1. ExceptionMethod: This interception allows to throw Throwable instances on a method call.
2. FieldAccessor: A field accessor allows to read or write a class's field value according to the Java bean specification, i.e. implements setter and getter methods.
3. InvocationHandlerAdapter: An adapter for instrumenting methods by delegating method calls to a InvocationHandler which is already used for Java proxies.
4. MethodDelegation: Allows to delegate a method call to either a static or to an instance method. The method delegation is determined by annotations on the target method.
5. StubMethod: A stub method overrides a method by an empty implementation that only returns the method's return type's default value.
6. SuperMethodCall: This instrumentation calls a method's super implementation. This instrumentation is handy when annotations should be added to a method without changing the method's implementation.