Package org.springframework.core
@NonNullApi
@NonNullFields
package org.springframework.core
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.Helper for resolving syntheticbridge Methods
to theMethod
being bridged.Factory for collections that is aware of common Java and Spring collection types.SpecialObjectInputStream
subclass that resolves class names against a specificClassLoader
.Deprecated.since 6.1 with no replacement; use an enum, map, or similar custom solution insteadException thrown when theConstants
class 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.Base class for decorating ClassLoaders such asOverridingClassLoader
andShadowingClassLoader
, providing common handling of excluded packages and classes.Interface to be implemented by decorating proxies, in particular Spring AOP proxies but potentially also custom proxies with decorator semantics.Default implementation of theParameterNameDiscoverer
strategy interface, delegating to the Java 8 standard reflection mechanism.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.ParameterNameDiscoverer
implementation which uses Kotlin's reflection facilities for introspecting parameter names.A common key class for a method against a specific target class, includingMethodClassKey.toString()
representation andComparable
support (as suggested for customHashMap
keys as of Java 8).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.InheritableThreadLocal
subclass that exposes a specified name asNamedInheritableThreadLocal.toString()
result (allowing for introspection).ThreadLocal
subclass that exposes a specified name asNamedThreadLocal.toString()
result (allowing for introspection).A common delegate for detecting a GraalVM native image environment.Native image context as defined in GraalVM's ImageInfo.Handy class for wrapping checkedExceptions
with a root cause.Helper class for implementing exception classes which are capable of holding nested exceptions.Handy class for wrapping runtimeExceptions
with a root cause.Comparator
implementation forOrdered
objects, sorting by order value ascending, respectively by priority descending.Strategy interface to provide an order source for a given object.Ordered
is an interface that can be implemented by objects that should be orderable, for example in aCollection
.ClassLoader
that 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 genericType
.Interface to discover parameter names for methods and constructors.ParameterNameDiscoverer
implementation that tries several discoverer delegates in succession.Adapter for a Reactive StreamsPublisher
to and from an async/reactive type such asCompletableFuture
, RxJavaObservable
, and others.A registry of adapters to adapt Reactive StreamsPublisher
to/from various async/reactive types such asCompletableFuture
, RxJavaFlowable
, etc.BlockHoundIntegration
for spring-core classes.Describes the semantics of a reactive type including boolean checks forReactiveTypeDescriptor.isMultiValue()
,ReactiveTypeDescriptor.isNoValue()
, andReactiveTypeDescriptor.supportsEmpty()
.Encapsulates a JavaType
, providing access tosupertypes
,interfaces
, andgeneric parameters
along with the ability to ultimatelyresolve
to aClass
.Any object can implement this interface to provide its actualResolvableType
.Simple implementation of theAliasRegistry
interface.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.ParameterNameDiscoverer
implementation which uses JDK 8's reflection facilities for introspecting parameter names (based on the "-parameters" compiler flag).