net.bytebuddy.implementation

Interface Implementation

All Known Subinterfaces:

FieldAccessor.AssignerConfigurable, FieldAccessor.FieldDefinable, FieldAccessor.OwnerTypeLocatable, FixedValue.AssignerConfigurable, InvocationHandlerAdapter.AssignerConfigurable

All Known Implementing Classes:

AgentBuilder.Default.InitializationStrategy.SelfInjection, ByteBuddy.EnumerationImplementation, DefaultMethodCall, ExceptionMethod, FieldAccessor, FieldAccessor.ForNamedField, FieldAccessor.ForUnnamedField, FieldProxy.Binder.AccessType.Getter, FieldProxy.Binder.AccessType.Setter, FieldProxy.Binder.InstanceFieldConstructor, FieldProxy.Binder.StaticFieldConstructor, FixedValue, FixedValue.ForPoolValue, FixedValue.ForStaticField, Forwarding, Implementation.Compound, Implementation.Simple, InvocationHandlerAdapter, InvocationHandlerAdapter.ForInstanceDelegation, InvocationHandlerAdapter.ForStaticDelegation, InvokeDynamic, InvokeDynamic.AbstractDelegator, InvokeDynamic.WithImplicitArguments, InvokeDynamic.WithImplicitArgumentType, InvokeDynamic.WithImplicitFieldType, InvokeDynamic.WithImplicitTarget, MethodCall, MethodCall.WithoutSpecifiedTarget, MethodCallProxy.ConstructorCall, MethodCallProxy.MethodCall, MethodDelegation, Morph.Binder.RedirectionProxy.InstanceFieldConstructor, Morph.Binder.RedirectionProxy.MethodCall, Morph.Binder.RedirectionProxy.StaticFieldConstructor, Pipe.Binder.Redirection.ConstructorCall, Pipe.Binder.Redirection.MethodCall, StubMethod, SuperMethodCall, SuperMethodCall.WithoutReturn, TypeProxy.MethodCall, TypeProxy.SilentConstruction

public interface Implementation

An implementation is responsible for implementing methods of a dynamically created type as byte code. An implementation is applied in two stages:

1. The implementation is able to prepare an instrumented type by adding fields and/or helper methods that are required for the methods implemented by this implementation. Furthermore, LoadedTypeInitializers and byte code for the type initializer can be registered for the instrumented type.
2. Any implementation is required to supply a byte code appender that is responsible for providing the byte code to the instrumented methods that were delegated to this implementation. This byte code appender is also be responsible for providing implementations for the methods added in step 1.

An implementation should provide meaningful implementations of both Object.equals(Object) and Object.hashCode() if it wants to avoid to be used twice within the creation of a dynamic type. For two equal implementations only one will be applied on the creation of a dynamic type.

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Implementation.Compound A compound implementation that allows to combine several implementations.
static interface	Implementation.Context The context for an implementation application.
static class	Implementation.Simple A simple implementation that does not register any members with the instrumented type.
static interface	Implementation.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.
static interface	Implementation.Target The target of an implementation.

Method Summary

Modifier and Type	Method and Description
ByteCodeAppender	appender(Implementation.Target implementationTarget) Creates a byte code appender that determines the implementation of the instrumented type's methods.
InstrumentedType	prepare(InstrumentedType instrumentedType) During the preparation phase of an implementation, implementations are eligible to adding fields or methods to the currently instrumented type.

Method Detail

prepare

InstrumentedType prepare(InstrumentedType instrumentedType)

During the preparation phase of an implementation, implementations are eligible to adding fields or methods to the currently instrumented type. All methods that are added by this implementation are required to be implemented by the ByteCodeAppender that is emitted on the call to appender(Implementation.Target) call. On this method call, loaded type initializers can also be added to the instrumented type.

Parameters:

instrumentedType - The instrumented type that is the basis of the ongoing instrumentation.

Returns:

The instrumented type with any applied changes, if any.

appender

ByteCodeAppender appender(Implementation.Target implementationTarget)

Creates a byte code appender that determines the implementation of the instrumented type's methods.

Parameters:

implementationTarget - The target of the current implementation.

Returns:

A byte code appender for implementing methods delegated to this implementation. This byte code appender is also responsible for handling methods that were added by this implementation on the call to prepare(InstrumentedType).