@NonNullApi @NonNullFields

# 程序包 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.

请参阅: 说明

- 接口概要
  接口 | 说明
  --- | ---
  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: order values expressed by `PriorityOrdered` objects always apply before same order values expressed by plain `Ordered` objects.
  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 `org.springframework.instrument.classloading.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.
  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的说明

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