Package net.bytebuddy.dynamic.loading

Class ClassReloadingStrategy

  • All Implemented Interfaces:
    ClassLoadingStrategy<java.lang.ClassLoader>
    @Enhance
public class ClassReloadingStrategy
extends java.lang.Object
implements ClassLoadingStrategy<java.lang.ClassLoader>

    The class reloading strategy allows to redefine loaded Classes. Note that this strategy will always attempt to load an existing class prior to its redefinition, even if this class is not yet loaded.

    Note: In order to redefine any type, neither its name or its modifiers must be changed. Furthermore, no fields or methods must be removed or added. This makes this strategy generally incompatible to applying it to a rebased class definition as by ByteBuddy.rebase(Class) which copies the original method implementations to additional methods. Furthermore, even the ByteBuddy.redefine(Class) adds a method if the original class contains an explicit class initializer. For these reasons, it is not recommended to use this ClassLoadingStrategy with arbitrary classes.

    • Field Detail

      • instrumentation

        private final java.lang.instrument.Instrumentation instrumentation
        This instance's instrumentation.

      • preregisteredTypes

        private final java.util.Map<java.lang.String,​java.lang.Class<?>> preregisteredTypes
        The preregistered types of this instance.

    • Constructor Detail

      • ClassReloadingStrategy

        public ClassReloadingStrategy​(java.lang.instrument.Instrumentation instrumentation,
                              ClassReloadingStrategy.Strategy strategy)
        Creates a class reloading strategy for the given instrumentation using an explicit transformation strategy which is represented by an ClassReloadingStrategy.Strategy. The given instrumentation must support the strategy's transformation type.
        Parameters:
        instrumentation - The instrumentation to be used by this reloading strategy.
        strategy - A strategy which performs the actual redefinition of a Class.

      • ClassReloadingStrategy

        protected ClassReloadingStrategy​(java.lang.instrument.Instrumentation instrumentation,
                                 ClassReloadingStrategy.Strategy strategy,
                                 ClassReloadingStrategy.BootstrapInjection bootstrapInjection,
                                 java.util.Map<java.lang.String,​java.lang.Class<?>> preregisteredTypes)
        Creates a new class reloading strategy.
        Parameters:
        instrumentation - The instrumentation to be used by this reloading strategy.
        strategy - An strategy which performs the actual redefinition of a Class.
        bootstrapInjection - The bootstrap class loader injection strategy to use.
        preregisteredTypes - The preregistered types of this instance.

    • Method Detail

      • doPrivileged

        @Enhance
private static <T> T doPrivileged​(java.security.PrivilegedAction<T> action)
        A proxy for java.security.AccessController#doPrivileged that is activated if available.
        Type Parameters:
        T - The type of the action's resolved value.
        Parameters:
        action - The action to execute from a privileged context.
        Returns:
        The action's resolved value.

      • of

        public static ClassReloadingStrategy of​(java.lang.instrument.Instrumentation instrumentation)
        Creates a class reloading strategy for the given instrumentation. The given instrumentation must either support Instrumentation.isRedefineClassesSupported() or Instrumentation.isRetransformClassesSupported(). If both modes are supported, classes will be transformed using a class retransformation.
        Parameters:
        instrumentation - The instrumentation to be used by this reloading strategy.
        Returns:
        A suitable class reloading strategy.

      • resolveByteBuddyAgentInstrumentation

        private static java.lang.instrument.Instrumentation resolveByteBuddyAgentInstrumentation()
        Resolves the instrumentation provided by net.bytebuddy.agent.Installer.
        Returns:
        The installed instrumentation instance.

      • fromInstalledAgent

        public static ClassReloadingStrategy fromInstalledAgent()

        Obtains a ClassReloadingStrategy from an installed Byte Buddy agent. This agent must be installed either by adding the byte-buddy-agent.jar when starting up the JVM by

        java -javaagent:byte-buddy-agent.jar -jar app.jar

        or after the start up using the Attach API. A convenience installer for the OpenJDK is provided by the ByteBuddyAgent within the byte-buddy-agent module. The strategy is determined by the agent's support for redefinition where are retransformation is preferred over a redefinition.
        Returns:
        A class reloading strategy which uses the Byte Buddy agent's Instrumentation.

      • fromInstalledAgent

        public static ClassReloadingStrategy fromInstalledAgent​(ClassReloadingStrategy.Strategy strategy)

        Obtains a ClassReloadingStrategy from an installed Byte Buddy agent. This agent must be installed either by adding the byte-buddy-agent.jar when starting up the JVM by

        java -javaagent:byte-buddy-agent.jar -jar app.jar

        or after the start up using the Attach API. A convenience installer for the OpenJDK is provided by the ByteBuddyAgent within the byte-buddy-agent module.
        Parameters:
        strategy - The strategy to use.
        Returns:
        A class reloading strategy which uses the Byte Buddy agent's Instrumentation.

      • load

        public java.util.Map<TypeDescription,​java.lang.Class<?>> load​(@MaybeNull
                                                                    java.lang.ClassLoader classLoader,
                                                                    java.util.Map<TypeDescription,​byte[]> types)
        Loads a given collection of classes given their binary representation.
        Specified by:
        load in interface ClassLoadingStrategy<java.lang.ClassLoader>
        Parameters:
        classLoader - The class loader to used for loading the classes.
        types - Byte array representations of the types to be loaded mapped by their descriptions, where an iteration order defines an order in which they are supposed to be loaded, if relevant.
        Returns:
        A collection of the loaded classes which will be initialized in the iteration order of the returned collection.

      • reset

        public ClassReloadingStrategy reset​(java.lang.Class<?>... type)
                             throws java.io.IOException
        Resets all classes to their original definition while using the first type's class loader as a class file locator.
        Parameters:
        type - The types to reset.
        Returns:
        This class reloading strategy.
        Throws:
        java.io.IOException - If a class file locator causes an IO exception.

      • reset

        public ClassReloadingStrategy reset​(ClassFileLocator classFileLocator,
                                    java.lang.Class<?>... type)
                             throws java.io.IOException
        Resets all classes to their original definition.
        Parameters:
        classFileLocator - The class file locator to use.
        type - The types to reset.
        Returns:
        This class reloading strategy.
        Throws:
        java.io.IOException - If a class file locator causes an IO exception.

      • enableBootstrapInjection

        public ClassReloadingStrategy enableBootstrapInjection​(java.io.File folder)
        Enables bootstrap injection for this class reloading strategy.
        Parameters:
        folder - The folder to save jar files in that are appended to the bootstrap class path.
        Returns:
        A class reloading strategy with bootstrap injection enabled.

      • preregistered

        public ClassReloadingStrategy preregistered​(java.lang.Class<?>... type)
        Registers a type to be explicitly available without explicit lookup.
        Parameters:
        type - The loaded types that are explicitly available.
        Returns:
        This class reloading strategy with the given types being explicitly available.