Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.
ClassDescriptionCommon interface for managing aliases.Interface defining a generic contract for attaching and accessing metadata to/from arbitrary objects.Support class for
AttributeAccessors, providing a base implementation of all methods.Factory for collections that is aware of common Java and Spring collection types.This class can be used to parse other classes containing constant definitions in public static final members.Exception thrown when the
Constantsclass is asked for an invalid constant name.Provides methods to support various naming and other conventions used throughout the framework.Utilities for working with Kotlin Coroutines.Interface to be implemented by decorating proxies, in particular Spring AOP proxies but potentially also custom proxies with decorator semantics.Comparator capable of sorting exceptions based on their depth from the thrown exception type.Helper class for resolving generic types against type variables.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.A common delegate for detecting Kotlin's presence and for identifying Kotlin types.
ParameterNameDiscovererimplementation which uses Kotlin's reflection facilities for introspecting parameter names.Implementation of
ParameterNameDiscovererthat uses the LocalVariableTable information in the method attributes to discover parameter names.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.A callback interface for metadata lookup on a given method.Helper class that encapsulates the specification of a method parameter, i.e.A common delegate for detecting a GraalVM native image environment.Handy class for wrapping checked
Exceptionswith a root cause.Helper class for implementing exception classes which are capable of holding nested exceptions.Subclass of
IOExceptionthat properly handles a root cause, exposing the root cause just like NestedChecked/RuntimeException does.Handy class for wrapping runtime
Exceptionswith a root cause.Strategy interface to provide an order source for a given object.
Orderedis an interface that can be implemented by objects that should be orderable, for example in a
ClassLoaderthat does not always delegate to the parent loader as normal class loaders do.The purpose of this class is to enable capturing and passing a generic
Type.Interface to discover parameter names for methods and constructors.
ParameterNameDiscovererimplementation that tries several discoverer delegates in succession.Adapter for a Reactive Streams
Publisherto and from an async/reactive type such as
Observable, and others.A registry of adapters to adapt Reactive Streams
Publisherto/from various async/reactive types such as
Flowable, and others.
BlockHoundIntegrationfor spring-core classes.Any object can implement this interface to provide its actual
ResolvableType.Simple implementation of the
AliasRegistryinterface.Interface to be implemented by a reloading-aware ClassLoader (e.g.Static holder for local Spring properties, i.e.Class that exposes the Spring version.
ParameterNameDiscovererimplementation which uses JDK 8's reflection facilities for introspecting parameter names (based on the "-parameters" compiler flag).