Package org.springframework.core

# Class OverridingClassLoader

java.lang.Object
java.lang.ClassLoader
org.springframework.core.DecoratingClassLoader
org.springframework.core.OverridingClassLoader

public class OverridingClassLoader extends DecoratingClassLoader
`ClassLoader` that does not always delegate to the parent loader as normal class loaders do. This enables, for example, instrumentation to be forced in the overriding ClassLoader, or a "throwaway" class loading behavior where selected application classes are temporarily loaded in the overriding `ClassLoader` for introspection purposes before eventually loading an instrumented version of the class in the given parent `ClassLoader`.

Since:
  2.0.1
Author:
  Rod Johnson, Juergen Hoeller

## Field Summary

Fields
Modifier and Type
Field
Description
`static final String[]`
`DEFAULT_EXCLUDED_PACKAGES`
Packages that are excluded by default.

## Constructor Summary

Constructors
Constructor
Description
`OverridingClassLoader(ClassLoader parent)`
Create a new OverridingClassLoader for the given ClassLoader.
`OverridingClassLoader(ClassLoader parent, ClassLoader overrideDelegate)`
Create a new OverridingClassLoader for the given ClassLoader.

## Method Summary

Modifier and Type
Method
Description
`protected boolean`
`isEligibleForOverriding(String className)`
Determine whether the specified class is eligible for overriding by this class loader.
`protected byte[]`
`loadBytesForClass(String name)`
Load the defining bytes for the given class, to be turned into a Class object through a `ClassLoader.defineClass(byte[], int, int)` call.
`Class<?>`
`loadClass(String name)`
`protected Class<?>`
`loadClass(String name, boolean resolve)`
`protected Class<?>`
`loadClassForOverriding(String name)`
Load the specified class for overriding purposes in this ClassLoader.
`protected InputStream`
`openStreamForClass(String name)`
Open an InputStream for the specified class.
`protected byte[]`
`transformIfNecessary(String name, byte[] bytes)`
Transformation hook to be implemented by subclasses.

### Methods inherited from class org.springframework.core.DecoratingClassLoader

`excludeClass, excludePackage, isExcluded`

### Methods inherited from class java.lang.ClassLoader

`clearAssertionStatus, defineClass, defineClass, defineClass, defineClass, definePackage, findClass, findClass, findLibrary, findLoadedClass, findResource, findResource, findResources, findSystemClass, getClassLoadingLock, getDefinedPackage, getDefinedPackages, getName, getPackage, getPackages, getParent, getPlatformClassLoader, getResource, getResourceAsStream, getResources, getSystemClassLoader, getSystemResource, getSystemResourceAsStream, getSystemResources, getUnnamedModule, isRegisteredAsParallelCapable, registerAsParallelCapable, resolveClass, resources, setClassAssertionStatus, setDefaultAssertionStatus, setPackageAssertionStatus, setSigners`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

## Field Details

### DEFAULT_EXCLUDED_PACKAGES

public static final String[] DEFAULT_EXCLUDED_PACKAGES
Packages that are excluded by default.

## Constructor Details

### OverridingClassLoader

public OverridingClassLoader(@Nullable ClassLoader parent)
Create a new OverridingClassLoader for the given ClassLoader.

Parameters:
  `parent` - the ClassLoader to build an overriding ClassLoader for

### OverridingClassLoader

public OverridingClassLoader(@Nullable ClassLoader parent, @Nullable ClassLoader overrideDelegate)
Create a new OverridingClassLoader for the given ClassLoader.

Parameters:
  `parent` - the ClassLoader to build an overriding ClassLoader for
  `overrideDelegate` - the ClassLoader to delegate to for overriding
Since:
  4.3

## Method Details

### loadClass

public Class<?> loadClass(String name) throws ClassNotFoundException

Overrides:
  `loadClass` in class `ClassLoader`
Throws:
  `ClassNotFoundException`

### loadClass

protected Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException

Overrides:
  `loadClass` in class `ClassLoader`
Throws:
  `ClassNotFoundException`

### isEligibleForOverriding

protected boolean isEligibleForOverriding(String className)
Determine whether the specified class is eligible for overriding by this class loader.

Parameters:
  `className` - the class name to check
Returns:
  whether the specified class is eligible
See Also:
  - `DecoratingClassLoader.isExcluded(java.lang.String)`

### loadClassForOverriding

@Nullable protected Class<?> loadClassForOverriding(String name) throws ClassNotFoundException
Load the specified class for overriding purposes in this ClassLoader.

The default implementation delegates to `ClassLoader.findLoadedClass(java.lang.String)`, `loadBytesForClass(java.lang.String)` and `ClassLoader.defineClass(byte[], int, int)`.

Parameters:
  `name` - the name of the class
Returns:
  the Class object, or `null` if no class defined for that name
Throws:
  `ClassNotFoundException` - if the class for the given name couldn't be loaded

### loadBytesForClass

@Nullable protected byte[] loadBytesForClass(String name) throws ClassNotFoundException
Load the defining bytes for the given class, to be turned into a Class object through a `ClassLoader.defineClass(byte[], int, int)` call.

The default implementation delegates to `openStreamForClass(java.lang.String)` and `transformIfNecessary(java.lang.String, byte[])`.

Parameters:
  `name` - the name of the class
Returns:
  the byte content (with transformers already applied), or `null` if no class defined for that name
Throws:
  `ClassNotFoundException` - if the class for the given name couldn't be loaded

### openStreamForClass

@Nullable protected InputStream openStreamForClass(String name)
Open an InputStream for the specified class.

The default implementation loads a standard class file through the parent ClassLoader's `getResourceAsStream` method.

Parameters:
  `name` - the name of the class
Returns:
  the InputStream containing the byte code for the specified class

### transformIfNecessary

protected byte[] transformIfNecessary(String name, byte[] bytes)
Transformation hook to be implemented by subclasses.

The default implementation simply returns the given bytes as-is.

Parameters:
  `name` - the fully-qualified name of the class being transformed
  `bytes` - the raw bytes of the class
Returns:
  the transformed bytes (never `null`; same as the input bytes if the transformation produced no changes)