# 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
Deprecated.
since 6.1 with no replacement; use an enum, map, or similar custom solution instead
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 `org.springframework.instrument.classloading.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`, etc.
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 (for example, a Groovy-based ClassLoader).
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).