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.

Related Packages

Package	Description
org.springframework.core.annotation	Core support package for annotations, meta-annotations, and merged annotations with attribute overrides.
org.springframework.core.codec	Encoder and Decoder abstractions to convert between a reactive stream of bytes and Java objects.
org.springframework.core.convert	Type conversion system API.
org.springframework.core.env	Spring's environment abstraction consisting of bean definition profile and hierarchical property source support.
org.springframework.core.io	Generic abstraction for (file-based) resources, used throughout the framework.
org.springframework.core.log	Useful delegates for Spring's logging conventions.
org.springframework.core.metrics	Support package for recording metrics during application startup.
org.springframework.core.serializer	Root package for Spring's serializer interfaces and implementations.
org.springframework.core.style	Support for styling values as Strings, with ToStringCreator as central class.
org.springframework.core.task	This package defines Spring's core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
org.springframework.core.type	Core support package for type introspection.

Class	Description
AliasRegistry	Common interface for managing aliases.
AttributeAccessor	Interface defining a generic contract for attaching and accessing metadata to/from arbitrary objects.
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.
Constants.ConstantException	Exception thrown when the Constants class is asked for an invalid constant name.
Conventions	Provides methods to support various naming and other conventions used throughout the framework.
CoroutinesUtils	Utilities for working with Kotlin Coroutines.
DecoratingClassLoader	Base class for decorating ClassLoaders such as OverridingClassLoader and ShadowingClassLoader, providing common handling of excluded packages and classes.
DecoratingProxy	Interface to be implemented by decorating proxies, in particular Spring AOP proxies but potentially also custom proxies with decorator semantics.
DefaultParameterNameDiscoverer	Default implementation of the ParameterNameDiscoverer strategy interface, delegating to the Java 8 standard reflection mechanism.
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.
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.
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.
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.
MethodIntrospector.MetadataLookup<T>	A callback interface for metadata lookup on a given method.
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).
NativeDetector	A common delegate for detecting a GraalVM native image environment.
NativeDetector.Context	Native image context as defined in GraalVM's ImageInfo.
NestedCheckedException	Handy class for wrapping checked Exceptions with a root cause.
NestedExceptionUtils	Helper class for implementing exception classes which are capable of holding nested exceptions.
NestedRuntimeException	Handy class for wrapping runtime Exceptions with a root cause.
OrderComparator	Comparator implementation for Ordered objects, sorting by order value ascending, respectively by priority descending.
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.
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.
ParameterNameDiscoverer	Interface to discover parameter names for methods and constructors.
PrioritizedParameterNameDiscoverer	ParameterNameDiscoverer implementation that tries several discoverer delegates in succession.
PriorityOrdered	Extension of the Ordered interface, expressing a priority ordering: PriorityOrdered objects are always applied before plain Ordered objects regardless of their order values.
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 Flowable, 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.
ResolvableTypeProvider	Any object can implement this interface to provide its actual ResolvableType.
SimpleAliasRegistry	Simple implementation of the AliasRegistry interface.
SmartClassLoader	Interface to be implemented by a reloading-aware ClassLoader (e.g.
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).