See: Description
| Interface | Description | 
|---|---|
| AliasRegistry | Common interface for managing aliases. | 
| AttributeAccessor | Interface defining a generic contract for attaching and accessing metadata
 to/from arbitrary objects. | 
| DecoratingProxy | Interface to be implemented by decorating proxies, in particular Spring AOP
 proxies but potentially also custom proxies with decorator semantics. | 
| InfrastructureProxy | Interface to be implemented by transparent resource proxies that need to be
 considered as equal to the underlying resource, for example for consistent
 lookup key comparisons. | 
| MethodIntrospector.MetadataLookup<T> | A callback interface for metadata lookup on a given method. | 
| OrderComparator.OrderSourceProvider | Strategy interface to provide an order source for a given object. | 
| Ordered | Orderedis an interface that can be implemented by objects that
 should be orderable, for example in aCollection. | 
| ParameterNameDiscoverer | Interface to discover parameter names for methods and constructors. | 
| PriorityOrdered | |
| ResolvableTypeProvider | Any object can implement this interface to provide its actual  ResolvableType. | 
| SmartClassLoader | Interface to be implemented by a reloading-aware ClassLoader
 (e.g. | 
| Class | Description | 
|---|---|
| AttributeAccessorSupport | Support class for  AttributeAccessors, providing
 a base implementation of all methods. | 
| BridgeMethodResolver | Helper for resolving synthetic  bridge Methodsto theMethodbeing bridged. | 
| CollectionFactory | Factory for collections that is aware of common Java and Spring collection types. | 
| ConfigurableObjectInputStream | Special ObjectInputStream subclass that resolves class names
 against a specific ClassLoader. | 
| Constants | This class can be used to parse other classes containing constant definitions
 in public static final members. | 
| Conventions | Provides methods to support various naming and other conventions used
 throughout the framework. | 
| DecoratingClassLoader | Base class for decorating ClassLoaders such as  OverridingClassLoaderandorg.springframework.instrument.classloading.ShadowingClassLoader,
 providing common handling of excluded packages and classes. | 
| DefaultParameterNameDiscoverer | Default implementation of the  ParameterNameDiscovererstrategy interface,
 using the Java 8 standard reflection mechanism (if available), and falling back
 to the ASM-basedLocalVariableTableParameterNameDiscovererfor checking
 debug information in the class file. | 
| ExceptionDepthComparator | Comparator capable of sorting exceptions based on their depth from the thrown exception type. | 
| GenericTypeResolver | Helper class for resolving generic types against type variables. | 
| KotlinDetector | A common delegate for detecting Kotlin's presence and for identifying Kotlin types. | 
| KotlinReflectionParameterNameDiscoverer | ParameterNameDiscovererimplementation which uses Kotlin's reflection facilities
 for introspecting parameter names. | 
| LocalVariableTableParameterNameDiscoverer | Implementation of  ParameterNameDiscovererthat uses the LocalVariableTable
 information in the method attributes to discover parameter names. | 
| MethodClassKey | A common key class for a method against a specific target class,
 including  MethodClassKey.toString()representation andComparablesupport (as suggested for customHashMapkeys as of Java 8). | 
| MethodIntrospector | Defines the algorithm for searching for metadata-associated methods exhaustively
 including interfaces and parent classes while also dealing with parameterized methods
 as well as common scenarios encountered with interface and class-based proxies. | 
| MethodParameter | Helper class that encapsulates the specification of a method parameter, i.e. | 
| NamedInheritableThreadLocal<T> | InheritableThreadLocalsubclass that exposes a specified name
 asNamedInheritableThreadLocal.toString()result (allowing for introspection). | 
| NamedThreadLocal<T> | ThreadLocalsubclass that exposes a specified name
 asNamedThreadLocal.toString()result (allowing for introspection). | 
| NestedExceptionUtils | Helper class for implementing exception classes which are capable of
 holding nested exceptions. | 
| OrderComparator | Comparatorimplementation forOrderedobjects, sorting
 by order value ascending, respectively by priority descending. | 
| OverridingClassLoader | ClassLoaderthat does not always delegate to the parent loader
 as normal class loaders do. | 
| ParameterizedTypeReference<T> | The purpose of this class is to enable capturing and passing a generic
  Type. | 
| PrioritizedParameterNameDiscoverer | ParameterNameDiscovererimplementation that tries several discoverer
 delegates in succession. | 
| ReactiveAdapter | Adapter for a Reactive Streams  Publisherto and from an async/reactive
 type such asCompletableFuture, RxJavaObservable, and others. | 
| ReactiveAdapterRegistry | A registry of adapters to adapt Reactive Streams  Publisherto/from
 various async/reactive types such asCompletableFuture, RxJavaObservable, and others. | 
| ReactiveTypeDescriptor | Describes the semantics of a reactive type including boolean checks for
  ReactiveTypeDescriptor.isMultiValue(),ReactiveTypeDescriptor.isNoValue(), andReactiveTypeDescriptor.supportsEmpty(). | 
| ResolvableType | Encapsulates a Java  Type, providing access tosupertypes,interfaces, andgeneric parametersalong with the ability to ultimatelyresolveto aClass. | 
| SimpleAliasRegistry | Simple implementation of the  AliasRegistryinterface. | 
| SpringProperties | Static holder for local Spring properties, i.e. | 
| SpringVersion | Class that exposes the Spring version. | 
| StandardReflectionParameterNameDiscoverer | ParameterNameDiscovererimplementation which uses JDK 8's reflection facilities
 for introspecting parameter names (based on the "-parameters" compiler flag). | 
| Exception | Description | 
|---|---|
| Constants.ConstantException | Exception thrown when the  Constantsclass is asked for
 an invalid constant name. | 
| NestedCheckedException | Handy class for wrapping checked  Exceptionswith a root cause. | 
| NestedIOException | Subclass of  IOExceptionthat properly handles a root cause,
 exposing the root cause just like NestedChecked/RuntimeException does. | 
| NestedRuntimeException | Handy class for wrapping runtime  Exceptionswith a root cause. |