org.springframework.core (Spring Framework 5.2.12.RELEASE API)

Provides basic classes for exception handling and version detection, and other core helpers that are not specific to any part of the framework.

接口概要
接口	说明
AliasRegistry	Common interface for managing aliases.
AttributeAccessor	Interface defining a generic contract for attaching and accessing metadata to/from arbitrary objects.
DecoratingProxy	Interface to be implemented by decorating proxies, in particular Spring AOP proxies but potentially also custom proxies with decorator semantics.
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.
MethodIntrospector.MetadataLookup<T>	A callback interface for metadata lookup on a given method.
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`.
ParameterNameDiscoverer	Interface to discover parameter names for methods and constructors.
PriorityOrdered	Extension of the `Ordered` interface, expressing a priority ordering: `PriorityOrdered` objects are always applied before plain`Ordered` objects regardless of their order values.
ResolvableTypeProvider	Any object can implement this interface to provide its actual `ResolvableType`.
SmartClassLoader	Interface to be implemented by a reloading-aware ClassLoader (e.g. a Groovy-based ClassLoader).

类概要
类	说明
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.
Conventions	Provides methods to support various naming and other conventions used throughout the framework.
DecoratingClassLoader	Base class for decorating ClassLoaders such as `OverridingClassLoader` and `ShadowingClassLoader`, providing common handling of excluded packages and classes.
DefaultParameterNameDiscoverer	Default implementation of the `ParameterNameDiscoverer` strategy interface, using the Java 8 standard reflection mechanism (if available), and falling back to the ASM-based `LocalVariableTableParameterNameDiscoverer` for checking debug information in the class file.
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.
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.
LocalVariableTableParameterNameDiscoverer	Implementation of `ParameterNameDiscoverer` that uses the LocalVariableTable information in the method attributes to discover 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.
MethodParameter	Helper class that encapsulates the specification of a method parameter, i.e. a `Method` or `Constructor` plus a parameter index and a nested type index for a declared generic type.
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).
NestedExceptionUtils	Helper class for implementing exception classes which are capable of holding nested exceptions.
OrderComparator	`Comparator` implementation for `Ordered` objects, sorting by order value ascending, respectively by priority descending.
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`.
PrioritizedParameterNameDiscoverer	`ParameterNameDiscoverer` implementation that tries several discoverer delegates in succession.
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 `Observable`, 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`.
SimpleAliasRegistry	Simple implementation of the `AliasRegistry` interface.
SpringProperties	Static holder for local Spring properties, i.e. defined at the Spring library level.
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).

异常错误概要
异常错误	说明
Constants.ConstantException	Exception thrown when the `Constants` class is asked for an invalid constant name.
NestedCheckedException	Handy class for wrapping checked `Exceptions` with a root cause.
NestedIOException	Subclass of `IOException` that properly handles a root cause, exposing the root cause just like NestedChecked/RuntimeException does.
NestedRuntimeException	Handy class for wrapping runtime `Exceptions` with a root cause.

程序包 org.springframework.core