程序包 cn.taketoday.core

@NonNullApi @NonNullFields package cn.taketoday.core

Provides core helpers that are not specific to any part of the framework.

Related Packages

程序包	说明
cn.taketoday.core.annotation	Core support package for annotations, meta-annotations, and merged annotations with attribute overrides.
cn.taketoday.core.codec	Encoder and Decoder abstractions to convert between a reactive stream of bytes and Java objects.
cn.taketoday.core.conversion	Type Conversion System
cn.taketoday.core.env	environment abstraction consisting of bean definition profile and hierarchical property source support.
cn.taketoday.core.i18n	Abstraction for determining the current Locale, plus global holder that exposes a thread-bound Locale.
cn.taketoday.core.io
cn.taketoday.core.serializer	Root package for Framework's serializer interfaces and implementations.
cn.taketoday.core.style	Support for styling values as Strings, with ToStringBuilder as central class.
cn.taketoday.core.task	This package defines core TaskExecutor abstraction, and provides SyncTaskExecutor and SimpleAsyncTaskExecutor implementations.
cn.taketoday.core.type	Core support package for type introspection.

类	说明
AliasRegistry	Common interface for managing aliases.
AntPathMatcher	PathMatcher implementation for Ant-style path patterns.
AntPathMatcher.AntPathStringMatcher	Tests whether or not a string matches against a pattern via a Pattern.
AntPathMatcher.AntPatternComparator	The default Comparator implementation returned by AntPathMatcher.getPatternComparator(String).
ArraySizeTrimmer	Trims the capacity of this instance's (list or array) to its size.
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.
CompositeParameterNameDiscoverer	ParameterNameDiscoverer implementation that tries several discoverer delegates in succession.
CompositeStrategies<T>
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.
ConstructorNotFoundException	not a suitable Constructor found
Conventions	Provides methods to support various naming and other conventions used throughout the framework.
DecoratingClassLoader	Base class for decorating ClassLoaders such as OverridingClassLoader providing common handling of excluded packages and classes.
DecoratingProxy	Interface to be implemented by decorating proxies, in particular AOP proxies but potentially also custom proxies with decorator semantics.
DefaultAliasRegistry	Simple implementation of the AliasRegistry interface.
DefaultMultiValueMap<K,V>	Simple implementation of MultiValueMap that wraps a Map, storing multiple values in a List.
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.
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.
JavaVersion	Known Java versions.
LinkedMultiValueMap<K,V>	Simple implementation of MultiValueMap that wraps a LinkedHashMap, storing multiple values in an ArrayList.
LocalVariableTableParameterNameDiscoverer	Implementation of ParameterNameDiscoverer that uses the LocalVariableTable information in the method attributes to discover parameter names.
MetadataResolver<M,C>	Simple strategy interface for resolving a value
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. a Method or Constructor plus a parameter index and a nested type index for a declared generic type.
MultiValueMap<K,V>	Extension of the Map interface that stores multiple values.
MultiValueMapAdapter<K,V>	Adapts a given Map to the MultiValueMap contract.
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).
NestedCheckedException	Handy class for wrapping checked Exceptions with a root cause.
NestedRuntimeException	Handy class for wrapping runtime Exceptions with a root cause.
NoStackTraceRuntimeException
OrderComparator	Comparator implementation for Ordered objects, sorting by order value ascending, respectively by priority descending.
Ordered	Ordered is an interface that can be implemented by objects that should be orderable, for example in a Collection.
OrderedSupport
OrderSourceProvider	Strategy interface to provide an order source for a given object.
OverridingClassLoader	ClassLoader that does not always delegate to the parent loader as normal class loaders do.
ParameterNameDiscoverer	abstract class to discover parameter names for methods and constructors.
PathMatcher
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.CoreBlockHoundIntegration	BlockHoundIntegration for core classes.
ReactiveTypeDescriptor	Describes the semantics of a reactive type including boolean checks for ReactiveTypeDescriptor.isMultiValue(), ReactiveTypeDescriptor.isNoValue(), and ReactiveTypeDescriptor.supportsEmpty().
ReflectiveParameterNameDiscoverer	ParameterNameDiscoverer implementation which uses JDK 8's reflection facilities for introspecting parameter names (based on the "-parameters" compiler flag).
ResolvableType	Encapsulates a Java Type, providing access to supertypes, interfaces, and generic parameters along with the ability to ultimately resolve to a Class.
ResolvableType.VariableResolver	Strategy interface used to resolve TypeVariables.
ResolvableTypeProvider	Any object can implement this interface to provide its actual ResolvableType.
SmartClassLoader	Interface to be implemented by a reloading-aware ClassLoader.
StringValueResolver	Simple strategy interface for resolving a String value.
ThrowableSupplier<T,E extends Throwable>	A throwable supplier is a functional interface which consists on a single get function which is able to throw an exception.
TypeDescriptor	Contextual descriptor about a type to convert from or to.
TypeReference<T>	The purpose of this class is to enable capturing and passing a generic Type.
YamlProcessor	Base class for YAML factories.
YamlProcessor.DocumentMatcher	Strategy interface used to test if properties match.
YamlProcessor.MatchCallback	Callback interface used to process the YAML parsing results.
YamlProcessor.MatchStatus	Status returned from YamlProcessor.DocumentMatcher.matches(java.util.Properties).
YamlProcessor.ResolutionMethod	Method to use for resolving resources.