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 |
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection . |
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 Methods to the
Method being 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
OverridingClassLoader
and ShadowingClassLoader ,
providing common handling of excluded packages and classes. |
DefaultParameterNameDiscoverer |
Default implementation of the
ParameterNameDiscoverer strategy interface,
using the Java 8 standard reflection mechanism (if available), and falling back
to the ASM-based LocalVariableTableParameterNameDiscoverer for 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 |
ParameterNameDiscoverer implementation which uses Kotlin's reflection facilities
for introspecting parameter names. |
LocalVariableTableParameterNameDiscoverer |
Implementation of
ParameterNameDiscoverer that 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 and Comparable
support (as suggested for custom HashMap keys 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> |
InheritableThreadLocal subclass that exposes a specified name
as NamedInheritableThreadLocal.toString() result (allowing for introspection). |
NamedThreadLocal<T> |
ThreadLocal subclass that exposes a specified name
as NamedThreadLocal.toString() result (allowing for introspection). |
NestedExceptionUtils |
Helper class for implementing exception classes which are capable of
holding nested exceptions.
|
OrderComparator |
Comparator implementation for Ordered objects, sorting
by order value ascending, respectively by priority descending. |
OverridingClassLoader |
ClassLoader that 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 |
ParameterNameDiscoverer implementation that tries several discoverer
delegates in succession. |
ReactiveAdapter |
Adapter for a Reactive Streams
Publisher to and from an async/reactive
type such as CompletableFuture , RxJava Observable , and others. |
ReactiveAdapterRegistry |
A registry of adapters to adapt Reactive Streams
Publisher to/from
various async/reactive types such as CompletableFuture , RxJava
Observable , and others. |
ReactiveAdapterRegistry.SpringCoreBlockHoundIntegration |
BlockHoundIntegration for spring-core classes. |
ReactiveTypeDescriptor |
Describes the semantics of a reactive type including boolean checks for
ReactiveTypeDescriptor.isMultiValue() , ReactiveTypeDescriptor.isNoValue() , and ReactiveTypeDescriptor.supportsEmpty() . |
ResolvableType |
Encapsulates a Java
Type , providing access to
supertypes , interfaces , and
generic parameters along with the ability to ultimately
resolve to a Class . |
SimpleAliasRegistry |
Simple implementation of the
AliasRegistry interface. |
SpringProperties |
Static holder for local Spring properties, i.e.
|
SpringVersion |
Class that exposes the Spring version.
|
StandardReflectionParameterNameDiscoverer |
ParameterNameDiscoverer implementation 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
Constants class is asked for
an invalid constant name. |
NestedCheckedException |
Handy class for wrapping checked
Exceptions with a root cause. |
NestedIOException |
Subclass of
IOException that properly handles a root cause,
exposing the root cause just like NestedChecked/RuntimeException does. |
NestedRuntimeException |
Handy class for wrapping runtime
Exceptions with a root cause. |