Class TypeProxy

  • All Implemented Interfaces:
    AuxiliaryType

    public class TypeProxy
    extends java.lang.Object
    implements AuxiliaryType
    A type proxy creates accessor methods for all overridable methods of a given type by subclassing the given type and delegating all method calls to accessor methods of the instrumented type it was created for.
    • Nested Class Summary

      Nested Classes 
      Modifier and Type Class Description
      protected static class  TypeProxy.AbstractMethodErrorThrow
      A stack manipulation that throws an abstract method error in case that a given super method cannot be invoked.
      static class  TypeProxy.ForDefaultMethod
      Creates a type proxy which delegates its super method calls to any invokable default method of a given interface and loads an instance of this proxy onto the operand stack.
      static class  TypeProxy.ForSuperMethodByConstructor
      Loads a type proxy onto the operand stack which is created by calling one of its constructors.
      static class  TypeProxy.ForSuperMethodByReflectionFactory
      Loads a type proxy onto the operand stack which is created by constructing a serialization constructor using the Oracle JDK's ReflectionFactory.newConstructorForSerialization(Class, java.lang.reflect.Constructor) method which might not be available in any Java runtime.
      static interface  TypeProxy.InvocationFactory
      An invocation factory is responsible for creating a special method invocation for any method that is to be invoked.
      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.
    • Field Summary

      Fields 
      Modifier and Type Field Description
      static java.lang.String INSTANCE_FIELD
      The name of the field that stores the delegation instance.
      static java.lang.String REFLECTION_METHOD
      The name of the static method that is added to this auxiliary type for creating instances by using the Oracle JDK's ReflectionFactory.
    • Field Detail

      • REFLECTION_METHOD

        public static final java.lang.String REFLECTION_METHOD
        The name of the static method that is added to this auxiliary type for creating instances by using the Oracle JDK's ReflectionFactory.
        See Also:
        Constant Field Values
      • INSTANCE_FIELD

        public static final java.lang.String INSTANCE_FIELD
        The name of the field that stores the delegation instance.
        See Also:
        Constant Field Values
    • Constructor Detail

      • TypeProxy

        public TypeProxy​(TypeDescription proxiedType,
                         Implementation.Target implementationTarget,
                         TypeProxy.InvocationFactory invocationFactory,
                         boolean ignoreFinalizer,
                         boolean serializableProxy)
        Creates a new type proxy.
        Parameters:
        proxiedType - The type this proxy should implement which can either be a non-final class or an interface.
        implementationTarget - The implementation target this type proxy is created for.
        invocationFactory - The invocation factory for creating special method invocations.
        ignoreFinalizer - true if any finalizer methods should be ignored for proxying.
        serializableProxy - Determines if the proxy should be serializable.
    • Method Detail

      • make

        public DynamicType make​(java.lang.String auxiliaryTypeName,
                                ClassFileVersion classFileVersion,
                                MethodAccessorFactory methodAccessorFactory)
        Description copied from interface: AuxiliaryType
        Creates a new auxiliary type.
        Specified by:
        make in interface AuxiliaryType
        Parameters:
        auxiliaryTypeName - The fully qualified binary name for this auxiliary type. The type should be in the same package than the instrumented type this auxiliary type is providing services to in order to allow package-private access.
        classFileVersion - The class file version the auxiliary class should be written in.
        methodAccessorFactory - A factory for accessor methods.
        Returns:
        A dynamically created type representing this auxiliary type.