Enum ClassLoadingStrategy.Default

    • Enum Constant Detail

      • WRAPPER

        public static final ClassLoadingStrategy.Default WRAPPER
        This strategy creates a new ByteArrayClassLoader with the given class loader as its parent. The byte array class loader is aware of a any dynamically created type and can natively load the given classes. This allows to load classes with cyclic load-time dependencies since the byte array class loader is queried on each encountered unknown class. Due to the encapsulation of the classes that were loaded by a byte array class loader, this strategy will lead to the unloading of these classes once this class loader, its classes or any instances of these classes become unreachable.
      • CHILD_FIRST

        public static final ClassLoadingStrategy.Default CHILD_FIRST

        The child-first class loading strategy is a modified version of the WRAPPER where the dynamic types are given priority over any types of a parent class loader with the same name.

        Important: This does not replace a type of the same name, but it makes the type invisible by the reach of this class loader.

      • INJECTION

        public static final ClassLoadingStrategy.Default INJECTION

        This strategy does not create a new class loader but injects all classes into the given ClassLoader by reflective access. This prevents the loading of classes with cyclic load-time dependencies but avoids the creation of an additional class loader. The advantage of this strategy is that the loaded classes will have package-private access to other classes within their package of the class loader into which they are injected what is not permitted when the wrapper class loader is used. This strategy is implemented using a ClassInjector.UsingReflection. Note that this strategy usually yields a better runtime performance.

        Important: Class injection requires access to JVM internal methods that are sealed by security managers and the Java Platform module system. Since Java 11, access to these methods is no longer feasible unless those packages are explicitly opened.

        Note: This class loader does not define packages for injected classes by default. Therefore, calls to Class.getPackage() might return null. Packages are only defined manually by a class loader prior to Java 9.

    • Method Detail

      • values

        public static ClassLoadingStrategy.Default[] values()
        Returns an array containing the constants of this enum type, in the order they are declared. This method may be used to iterate over the constants as follows:
        for (ClassLoadingStrategy.Default c : ClassLoadingStrategy.Default.values())
            System.out.println(c);
        
        Returns:
        an array containing the constants of this enum type, in the order they are declared
      • valueOf

        public static ClassLoadingStrategy.Default valueOf​(String name)
        Returns the enum constant of this type with the specified name. The string must match exactly an identifier used to declare an enum constant in this type. (Extraneous whitespace characters are not permitted.)
        Parameters:
        name - the name of the enum constant to be returned.
        Returns:
        the enum constant with the specified name
        Throws:
        IllegalArgumentException - if this enum type has no constant with the specified name
        NullPointerException - if the argument is null
      • load

        public Map<TypeDescription,​Class<?>> load​(ClassLoader classLoader,
                                                        Map<TypeDescription,​byte[]> types)
        Loads a given collection of classes given their binary representation.
        Specified by:
        load in interface ClassLoadingStrategy<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.
      • opened

        public ClassLoadingStrategy.Configurable<ClassLoader> opened()
        With an opened class loading strategy, it is assured that types can be added to the class loader, either by indirect injection using this strategy or by creating a class loader that explicitly supports injection.
        Specified by:
        opened in interface ClassLoadingStrategy.Configurable<ClassLoader>
        Returns:
        A version of this class loading strategy that opens for future injections into a class loader.