@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 synthetic
bridge Methodsto the
Methodbeing bridged.Factory for collections that is aware of common Java and Spring collection types.Special
ObjectInputStreamsubclass that resolves class names against a specific
ClassLoader.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.Base class for decorating ClassLoaders such as
ShadowingClassLoader, 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 the
ParameterNameDiscovererstrategy interface, using the Java 8 standard reflection mechanism (if available), and falling back to the ASM-based
LocalVariableTableParameterNameDiscovererfor checking debug information in the class file.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.A common key class for a method against a specific target class, including
Comparablesupport (as suggested for custom
HashMapkeys 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.
InheritableThreadLocalsubclass that exposes a specified name as
NamedInheritableThreadLocal.toString()result (allowing for introspection).
ThreadLocalsubclass that exposes a specified name as
NamedThreadLocal.toString()result (allowing for introspection).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.Handy class for wrapping runtime
Exceptionswith a root cause.
Orderedobjects, sorting by order value ascending, respectively by priority descending.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.Describes the semantics of a reactive type including boolean checks for
ReactiveTypeDescriptor.supportsEmpty().Encapsulates a Java
Type, providing access to
generic parametersalong with the ability to ultimately
Class.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).