ClassLoadingStrategy.Default (Byte Buddy (without dependencies) 1.0.1 API)

java.lang.Object
- java.lang.Enum<ClassLoadingStrategy.Default>
- - net.bytebuddy.dynamic.loading.ClassLoadingStrategy.Default

All Implemented Interfaces:

Serializable, Comparable<ClassLoadingStrategy.Default>, ClassLoadingStrategy, ClassLoadingStrategy.Configurable

Enclosing interface:

ClassLoadingStrategy
```
public static enum ClassLoadingStrategy.Default
extends Enum<ClassLoadingStrategy.Default>
implements ClassLoadingStrategy.Configurable
```
This class contains implementations of default class loading strategies.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`ClassLoadingStrategy.Default.InjectionDispatcher` A class loading strategy which applies a class loader injection while applying a given `ProtectionDomain` on class injection.
`protected static class`	`ClassLoadingStrategy.Default.WrappingDispatcher` A class loading strategy which creates a wrapping class loader while applying a given `ProtectionDomain` on class loading.

Nested classes/interfaces inherited from interface net.bytebuddy.dynamic.loading.ClassLoadingStrategy
ClassLoadingStrategy.Configurable, ClassLoadingStrategy.Default, ClassLoadingStrategy.ForBootstrapInjection

Enum Constant Summary

Enum Constants
Enum Constant and Description
`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.
`CHILD_FIRST_PERSISTENT` The strategy is identical to `CHILD_FIRST` but exposes the byte arrays that represent a class by `ClassLoader.getResourceAsStream(String)`.
`INJECTION` This strategy does not create a new class loader but injects all classes into the given `ClassLoader` by reflective access.
`WRAPPER` This strategy creates a new `ByteArrayClassLoader` with the given class loader as its parent.
`WRAPPER_PERSISTENT` The strategy is identical to `WRAPPER` but exposes the byte arrays that represent a class by `ClassLoader.getResourceAsStream(String)`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`ClassLoadingStrategy.Configurable`	`allowExistingTypes()` Determines if this class loading strategy should not throw an exception when attempting to load a class that was already loaded.
`Map<TypeDescription,Class<?>>`	`load(ClassLoader classLoader, Map<TypeDescription,byte[]> types)` Loads a given collection of classes given their binary representation.
`String`	`toString()`
`static ClassLoadingStrategy.Default`	`valueOf(String name)` Returns the enum constant of this type with the specified name.
`static ClassLoadingStrategy.Default[]`	`values()` Returns an array containing the constants of this enum type, in the order they are declared.
`ClassLoadingStrategy.Configurable`	`withAccessControlContext(AccessControlContext accessControlContext)` Defines the supplied access control context to be used for loading classes.
`ClassLoadingStrategy.Configurable`	`withPackageDefinitionStrategy(PackageDefinitionStrategy packageDefinitionStrategy)` Defines the supplied package definition strategy to be used for defining packages.
`ClassLoadingStrategy.Configurable`	`withProtectionDomain(ProtectionDomain protectionDomain)` Overrides the implicitly set default `ProtectionDomain` with an explicit one.

Methods inherited from class java.lang.Enum
clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, valueOf

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- 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.
  - WRAPPER_PERSISTENT
```
public static final ClassLoadingStrategy.Default WRAPPER_PERSISTENT
```
    The strategy is identical to WRAPPER but exposes the byte arrays that represent a class by ClassLoader.getResourceAsStream(String). For this purpose, all class files are persisted as byte arrays withing the wrapping class loader.
  - 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.
  - CHILD_FIRST_PERSISTENT
```
public static final ClassLoadingStrategy.Default CHILD_FIRST_PERSISTENT
```
    The strategy is identical to CHILD_FIRST but exposes the byte arrays that represent a class by ClassLoader.getResourceAsStream(String). For this purpose, all class files are persisted as byte arrays withing the wrapping 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: This class loader does not define packages for injected classes by default. Therefore, calls to Class.getPackage() might return null. Packages are only defined
- 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)
```
    Description copied from interface: ClassLoadingStrategy
    
    Loads a given collection of classes given their binary representation.
    
    Specified by:
    
    load in interface ClassLoadingStrategy
    
    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.
  - withProtectionDomain
```
public ClassLoadingStrategy.Configurable withProtectionDomain(ProtectionDomain protectionDomain)
```
    Description copied from interface: ClassLoadingStrategy.Configurable
    
    Overrides the implicitly set default ProtectionDomain with an explicit one.
    
    Specified by:
    
    withProtectionDomain in interface ClassLoadingStrategy.Configurable
    
    Parameters:
    
    protectionDomain - The protection domain to apply.
    
    Returns:
    
    This class loading strategy with an explicitly set ProtectionDomain.
  - withPackageDefinitionStrategy
```
public ClassLoadingStrategy.Configurable withPackageDefinitionStrategy(PackageDefinitionStrategy packageDefinitionStrategy)
```
    Description copied from interface: ClassLoadingStrategy.Configurable
    
    Defines the supplied package definition strategy to be used for defining packages.
    
    Specified by:
    
    withPackageDefinitionStrategy in interface ClassLoadingStrategy.Configurable
    
    Parameters:
    
    packageDefinitionStrategy - The package definer to be used.
    
    Returns:
    
    A version of this class loading strategy that applies the supplied package definition strategy.
  - withAccessControlContext
```
public ClassLoadingStrategy.Configurable withAccessControlContext(AccessControlContext accessControlContext)
```
    Description copied from interface: ClassLoadingStrategy.Configurable
    
    Defines the supplied access control context to be used for loading classes.
    
    Specified by:
    
    withAccessControlContext in interface ClassLoadingStrategy.Configurable
    
    Parameters:
    
    accessControlContext - The access control context to use for loading classes.
    
    Returns:
    
    A version of this class loading strategy that applies the supplied access control context.
  - allowExistingTypes
```
public ClassLoadingStrategy.Configurable allowExistingTypes()
```
    Description copied from interface: ClassLoadingStrategy.Configurable
    
    Determines if this class loading strategy should not throw an exception when attempting to load a class that was already loaded. In this case, the already loaded class is used instead of the generated class.
    
    Specified by:
    
    allowExistingTypes in interface ClassLoadingStrategy.Configurable
    
    Returns:
    
    A version of this class loading strategy that does not throw an exception when a class is already loaded.
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Enum<ClassLoadingStrategy.Default>

Enum ClassLoadingStrategy.Default

Nested Class Summary

Nested classes/interfaces inherited from interface net.bytebuddy.dynamic.loading.ClassLoadingStrategy

Enum Constant Summary

Method Summary

Methods inherited from class java.lang.Enum

Methods inherited from class java.lang.Object

Enum Constant Detail

WRAPPER

WRAPPER_PERSISTENT

CHILD_FIRST

CHILD_FIRST_PERSISTENT

INJECTION

Method Detail

values

valueOf

load

withProtectionDomain

withPackageDefinitionStrategy

withAccessControlContext

allowExistingTypes

toString