# All Classes and Interfaces

Class
Description
AbstractCharSequenceDecoder<T extends CharSequence>
Abstract base class that decodes from a data buffer stream to a `CharSequence` stream.
AbstractClassFilterTransformer
AbstractClassGenerator<T>
Abstract class for all code-generating CGLIB utilities.
AbstractClassGenerator.ClassLoaderData
AbstractClassGenerator.Source
AbstractClassLoader
AbstractClassTestingTypeFilter
Type filter that exposes a `ClassMetadata` object to subclasses, for class testing purposes.
AbstractClassTransformer
AbstractDataBufferDecoder<T>
Abstract base class for `Decoder` implementations that can decode a `DataBuffer` directly to the target element type.
AbstractDecoder<T>
Abstract base class for `Decoder` implementations.
AbstractEncoder<T>
Abstract base class for `Encoder` implementations.
AbstractEnvironment
Abstract base class for `Environment` implementations.
AbstractFileResolvingResource
Abstract base class for resources which resolve URLs into File references, such as `UrlResource` or `ClassPathResource`.
AbstractInterceptFieldCallback
AbstractPropertyResolver
Abstract base class for resolving properties against any underlying source.
AbstractResource
Convenience base class for `Resource` implementations, pre-implementing typical behavior.
AbstractSingleValueEncoder<T>
Abstract base class for `Encoder` classes that can only deal with a single value.
AbstractTypeHierarchyTraversingFilter
Type filter that is aware of traversing over hierarchy.
AbstractTypeReference
Base `TypeReference` implementation that ensures consistent behaviour for `equals()`, `hashCode()`, and `toString()` based on the canonical name.
AccessControl
Determine the access control of a `Member` or type signature.
AccessControl.Visibility
Access visibility types as determined by the modifiers on a `Member` or `ResolvableType`.
AccessFieldTransformer
AccessFieldTransformer.Callback
AddDelegateTransformer
AddInitTransformer
AddPropertyTransformer
AddStaticInitTransformer
AliasFor
`@AliasFor` is an annotation that is used to declare aliases for annotation attributes.
AliasRegistry
Common interface for managing aliases.
AlternativeJdkIdGenerator
An `IdGenerator` that uses `SecureRandom` for the initial seed and `Random` thereafter, instead of calling `UUID.randomUUID()` every time as `JdkIdGenerator` does.
AnnotatedElementUtils
General utility methods for finding annotations, meta-annotations, and repeatable annotations on `AnnotatedElements`.
AnnotatedMethod
A convenient wrapper for a `Method` handle, providing deep annotation introspection on methods and method parameters, including the exposure of interface-declared parameter annotations from the concrete target method.
AnnotatedTypeMetadata
Defines access to the annotations of a specific type (`class` or `method`), in a form that does not necessarily require class loading of the types being inspected.
AnnotationAttributes
`LinkedHashMap` subclass representing annotation attribute key-value pairs as read by `AnnotationUtils`, `AnnotatedElementUtils`, and Spring's reflection- and ASM-based `AnnotationMetadata` implementations.
AnnotationAwareOrderComparator
`AnnotationAwareOrderComparator` is an extension of `OrderComparator` that supports Spring's `Ordered` interface as well as the `@Order` and `@Priority` annotations, with an order value provided by an `Ordered` instance overriding a statically defined annotation value (if any).
AnnotationConfigurationException
Thrown by `AnnotationUtils` and synthesized annotations if an annotation is improperly configured.
AnnotationFilter
Callback interface that can be used to filter specific annotation types.
AnnotationMetadata
Interface that defines abstract access to the annotations of a specific class, in a form that does not require that class to be loaded yet.
AnnotationTypeFilter
A simple `TypeFilter` which matches classes with a given annotation, checking inherited annotations as well.
AnnotationUtils
General utility methods for working with annotations, handling meta-annotations, bridge methods (which the compiler generates for generic declarations) as well as super methods (for optional annotation inheritance).
AnnotationVisitor
A visitor to visit a Java annotation.
AnnotationVisitorTee
AntPathMatcher
`PathMatcher` implementation for Ant-style path patterns.
AntPathMatcher.AntPathStringMatcher
Tests whether a string matches against a pattern via a `Pattern`.
AntPathMatcher.AntPatternComparator
The default `Comparator` implementation returned by `AntPathMatcher.getPatternComparator(String)`.
AotDetector
Utility for determining if AOT-processed optimizations must be used rather than the regular runtime.
ApplicationStartup
Instruments the application startup phase using `steps`.
AspectJTypeFilter
Type filter that uses AspectJ type pattern for matching.
Assert
Assertion utility class that assists in validating arguments.
AssignableTypeFilter
A simple filter which matches classes that are assignable to a given type.
AsyncListenableTaskExecutor
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, in favor of `AsyncTaskExecutor.submitCompletable(Runnable)` and `AsyncTaskExecutor.submitCompletable(Callable)`
AsyncTaskExecutor
Extended interface for asynchronous `TaskExecutor` implementations, offering support for `Callable`.
Attribute
A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine Specification (JVMS).
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.
AutoPopulatingList<E>
Simple `List` wrapper class that allows for elements to be automatically populated as they are requested.
AutoPopulatingList.ElementFactory<E>
Factory interface for creating elements for an index-based access data structure such as a `List`.
AutoPopulatingList.ElementInstantiationException
Exception to be thrown from ElementFactory.
BackOff
Provide a `BackOffExecution` that indicates the rate at which an operation should be retried.
BackOffExecution
Represent a particular back-off execution.
BeanCopier
BeanCopier.Generator
BeanGenerator
BeanMap
A `Map`-based view of a JavaBean.
BeanMap.Generator
BindingReflectionHintsRegistrar
Register the necessary reflection hints so that the specified type can be bound at runtime.
Block
BooleanComparator
A `Comparator` for `Boolean` objects that can sort either `true` or `false` first.
BridgeMethodResolver
Helper for resolving synthetic `bridge Methods` to the `Method` being bridged.
BulkBean
BulkBean.Generator
BulkBeanException
ByteArrayDecoder
Decoder for `byte` arrays.
ByteArrayEncoder
Encoder for `byte` arrays.
ByteArrayResource
`Resource` implementation for a given byte array.
ByteBufferDecoder
Decoder for `ByteBuffers`.
ByteBufferEncoder
Encoder for `ByteBuffers`.
ByteVector
A dynamically extensible vector of bytes.
CachingMetadataReaderFactory
Caching implementation of the `MetadataReaderFactory` interface, caching a `MetadataReader` instance per Spring `Resource` handle (i.e.
Callback
All callback interfaces used by `Enhancer` extend this interface.
CallbackFilter
Map methods of subclasses generated by `Enhancer` to a particular callback.
CallbackHelper
CharBufferDecoder
Decode from a data buffer stream to a `CharBuffer` stream, either splitting or aggregating incoming data chunks to realign along newlines delimiters and produce a stream of char buffers.
CharSequenceEncoder
Encode from a `CharSequence` stream to a bytes stream.
CheckReturnValue
Specifies that the method return value must be used.
ClassEmitter
ClassEmitterTransformer
ClassesKey
ClassFilter
ClassFilterTransformer
ClassFormatException
Exception that indicates an incompatible class format encountered in a class file during metadata reading.
ClassGenerator
ClassHintUtils
Utilities for core hint inference on Spring-managed classes, specifically for proxy types such as interface-based JDK proxies and CGLIB-generated subclasses which need proxy/reflection hints.
ClassInfo
ClassLoaderAwareGeneratorStrategy
CGLIB GeneratorStrategy variant which exposes the application ClassLoader as current thread context ClassLoader for the time of class generation.
ClassMetadata
Interface that defines abstract metadata of a specific class, in a form that does not require that class to be loaded yet.
ClassNameGenerator
Generate unique class names based on a target `ClassName` and a feature name.
ClassNameReader
ClassPathResource
`Resource` implementation for class path resources.
ClassReader
A parser to make a `ClassVisitor` visit a ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS).
ClassReaderGenerator
ClassRelativeResourceLoader
`ResourceLoader` implementation that interprets plain resource paths as relative to a given `java.lang.Class`.
ClassTooLargeException
Exception thrown when the constant pool of a class produced by a `ClassWriter` is too large.
ClassTransformer
ClassTransformerChain
ClassTransformerFactory
ClassTransformerTee
ClassUtils
Miscellaneous `java.lang.Class` utility methods.
ClassVisitor
A visitor to visit a Java class.
ClassVisitorTee
ClassWriter
A `ClassVisitor` that generates a corresponding ClassFile structure, as defined in the Java Virtual Machine Specification (JVMS).
CloseableDataBuffer
Extension of `DataBuffer` that allows for buffers that can be used in a `try`-with-resources statement.
CodecException
General error that indicates a problem while encoding and decoding to and from an Object stream.
CodeEmitter
CodeGenerationException
CollectionFactory
Factory for collections that is aware of common Java and Spring collection types.
CollectionUtils
CollectionUtils
Miscellaneous collection utility methods.
CommandLinePropertySource<T>
Abstract base class for `PropertySource` implementations backed by command line arguments.
CommonsLogWriter
`java.io.Writer` adapter for a Commons Logging `Log`.
ComparableComparator<T extends Comparable<T>>
Deprecated.
as of 6.1 in favor of `Comparator.naturalOrder()`
Comparators
Convenient entry point with generically typed factory methods for common Spring `Comparator` variants.
CompletableToListenableFutureAdapter<T>
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, with no concrete replacement
CompositeIterator<E>
Composite iterator that combines multiple other iterators, as registered via `CompositeIterator.add(Iterator)`.
CompositePropertySource
Composite `PropertySource` implementation that iterates over a set of `PropertySource` instances.
CompositeTaskDecorator
Composite `TaskDecorator` that delegates to other task decorators.
ConcurrencyThrottleSupport
Support class for throttling concurrent access to a specific resource.
ConcurrentLruCache<K,V>
Simple LRU (Least Recently Used) cache, bounded by a specified cache capacity.
ConcurrentReferenceHashMap<K,V>
A `ConcurrentHashMap` that uses `soft` or weak references for both `keys` and `values`.
ConcurrentReferenceHashMap.Entry<K,V>
A single map entry.
ConcurrentReferenceHashMap.Reference<K,V>
A reference to an `ConcurrentReferenceHashMap.Entry` contained in the map.
ConcurrentReferenceHashMap.ReferenceType
Various reference types supported by this map.
ConcurrentReferenceHashMap.Restructure
The types of restructuring that can be performed.
ConditionalConverter
Allows a `Converter`, `GenericConverter` or `ConverterFactory` to conditionally execute based on attributes of the `source` and `target` `TypeDescriptor`.
ConditionalGenericConverter
A `GenericConverter` that may conditionally execute based on attributes of the `source` and `target` `TypeDescriptor`.
ConditionalHint
Contract for `runtime hints` that only apply if the described condition is met.
ConfigurableConversionService
Configuration interface to be implemented by most if not all `ConversionService` types.
ConfigurableEnvironment
Configuration interface to be implemented by most if not all `Environment` types.
ConfigurableObjectInputStream
Special `ObjectInputStream` subclass that resolves class names against a specific `ClassLoader`.
ConfigurablePropertyResolver
Configuration interface to be implemented by most if not all `PropertyResolver` types.
ConstantDynamic
A constant whose value is computed at runtime, with a bootstrap method.
Constants
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.
ConstructorDelegate
ConstructorDelegate.Generator
ContextPropagatingTaskDecorator
`TaskDecorator` that `wraps the execution` of tasks, assisting with context propagation.
ContextResource
Extended interface for a resource that is loaded from an enclosing 'context', for example, from a `jakarta.servlet.ServletContext` but also from plain classpath paths or relative file system paths (specified without an explicit prefix, hence applying relative to the local `ResourceLoader`'s context).
Contract
Specifies some aspects of the method behavior depending on the arguments.
Conventions
Provides methods to support various naming and other conventions used throughout the framework.
ConversionException
Base class for exceptions thrown by the conversion system.
ConversionFailedException
Exception to be thrown when an actual type conversion attempt fails.
ConversionService
A service interface for type conversion.
ConversionServiceFactory
A factory for common `ConversionService` configurations.
Converter
Converter<S,T>
A converter converts a source object of type `S` to a target of type `T`.
ConverterFactory<S,R>
A factory for "ranged" converters that can convert objects from S to subtypes of R.
ConverterNotFoundException
Exception to be thrown when a suitable converter could not be found in a given conversion service.
ConverterRegistry
For registering converters with a type conversion system.
ConvertingComparator<S,T>
A `Comparator` that converts values before they are compared.
ConvertingPropertyEditorAdapter
Adapter that exposes a `PropertyEditor` for any given `ConversionService` and specific target type.
CoroutinesUtils
Utilities for working with Kotlin Coroutines.
CustomizableThreadCreator
Simple customizable helper class for creating new `Thread` instances.
Customizer
Customizes key types for `KeyFactory` when building equals, hashCode, and toString.
CustomizerRegistry
DataBuffer
Basic abstraction over byte buffers.
DataBuffer.ByteBufferIterator
A dedicated iterator type that ensures the lifecycle of iterated `ByteBuffer` elements.
DataBufferDecoder
Simple pass-through decoder for `DataBuffers`.
DataBufferEncoder
Simple pass-through encoder for `DataBuffers`.
DataBufferFactory
A factory for `DataBuffers`, allowing for allocation and wrapping of data buffers.
DataBufferLimitException
Exception that indicates the cumulative number of bytes consumed from a stream of `DataBuffer`'s exceeded some pre-configured limit.
DataBufferUtils
Utility class for working with `DataBuffers`.
DataBufferUtils.Matcher
Contract to find delimiter(s) against one or more data buffers that can be passed one at a time to the `DataBufferUtils.Matcher.match(DataBuffer)` method.
DataBufferWrapper
Provides a convenient implementation of the `DataBuffer` interface that can be overridden to adapt the delegate.
DataSize
A data size, such as '12MB'.
DataUnit
A standard set of `DataSize` units.
DebuggingClassWriter
Decoder<T>
Strategy for decoding a `DataBuffer` input stream into an output stream of elements of type `<T>`.
DecodingException
Indicates an issue with decoding the input stream with a focus on content related issues such as a parse failure.
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.
DefaultConversionService
A specialization of `GenericConversionService` configured by default with converters appropriate for most environments.
DefaultDataBuffer
Default implementation of the `DataBuffer` interface that uses a `ByteBuffer` internally.
DefaultDataBufferFactory
Default implementation of the `DataBufferFactory` interface.
DefaultDeserializer
A default `Deserializer` implementation that reads an input stream using Java serialization.
DefaultGenerationContext
Default `GenerationContext` implementation.
DefaultGeneratorStrategy
DefaultMethodReference
Default `MethodReference` implementation based on a `MethodSpec`.
DefaultNamingPolicy
The default policy used by `AbstractClassGenerator`.
DefaultParameterNameDiscoverer
Default implementation of the `ParameterNameDiscoverer` strategy interface, delegating to the Java 8 standard reflection mechanism.
DefaultPropertiesPersister
Default implementation of the `PropertiesPersister` interface.
DefaultPropertySourceFactory
The default implementation for `PropertySourceFactory`, wrapping every resource in a `ResourcePropertySource`.
DefaultResourceLoader
Default implementation of the `ResourceLoader` interface.
DefaultResourceLoader.ClassPathContextResource
ClassPathResource that explicitly expresses a context-relative path through implementing the ContextResource interface.
DefaultSerializer
A `Serializer` implementation that writes an object to an output stream using Java serialization.
DefaultToStringStyler
Spring's default `toString()` styler.
DefaultValueStyler
Converts objects to String form, generally for debugging purposes, using Spring's `toString` styling conventions.
DescriptiveResource
Simple `Resource` implementation that holds a resource description but does not point to an actually readable resource.
Deserializer<T>
A strategy interface for converting from data in an InputStream to an Object.
DeserializingConverter
A `Converter` that delegates to a `Deserializer` to convert data in a byte array to an object.
DigestUtils
Miscellaneous methods for calculating digests.
Dispatcher
Dispatching `Enhancer` callback.
DomUtils
Convenience methods for working with the DOM API, in particular for working with DOM Nodes and DOM Elements.
DuplicatesPredicate
EmitUtils
EmitUtils.ArrayDelimiters
EncodedResource
Holder that combines a `Resource` descriptor with a specific encoding or `Charset` to be used for reading from the resource.
Encoder<T>
Strategy to encode a stream of Objects of type `<T>` into an output stream of bytes.
EncodingException
Indicates an issue with encoding the input Object stream with a focus on not being able to encode Objects.
Enhancer
Generates dynamic subclasses to enable method interception.
EnumerablePropertySource<T>
A `PropertySource` implementation capable of interrogating its underlying source object to enumerate all possible property name/value pairs.
Environment
Interface representing the environment in which the current application is running.
EnvironmentCapable
Interface indicating a component that contains and exposes an `Environment` reference.
ErrorHandler
A strategy for handling errors.
ExceptionDepthComparator
Comparator capable of sorting exceptions based on their depth from the thrown exception type.
ExceptionTypeFilter
An `InstanceFilter` implementation that handles exception types.
ExecutableHint
A hint that describes the need for reflection on a `Method` or `Constructor`.
ExecutableHint.Builder
Builder for `ExecutableHint`.
ExecutableMode
Represent the need of reflection for a given `Executable`.
ExecutorServiceAdapter
Adapter that takes a Spring `TaskExecutor` and exposes a full `java.util.concurrent.ExecutorService` for it.
ExponentialBackOff
Implementation of `BackOff` that increases the back off period for each retry attempt.
Factory
All enhanced instances returned by the `Enhancer` class implement this interface.
FailureCallback
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, in favor of `CompletableFuture.whenComplete(BiConsumer)`
FastByteArrayOutputStream
A speedy alternative to `ByteArrayOutputStream`.
FastClass
FastClass.Generator
FastConstructor
FastMember
FastMethod
FieldHint
A hint that describes the need for reflection on a `Field`.
FieldProvider
FieldProviderTransformer
FieldTypeCustomizer
Customizes key types for `KeyFactory` right in constructor.
FieldVisitor
A visitor to visit a Java field.
FieldVisitorTee
FileCopyUtils
Simple utility methods for file and stream copying.
FileNativeConfigurationWriter
A `NativeConfigurationWriter` implementation that writes the configuration to disk.
FilePatternResourceHintsRegistrar
Register the necessary resource hints for loading files from the classpath, based on file name prefixes and file extensions with convenience to support multiple classpath locations.
FilePatternResourceHintsRegistrar.Builder
Builder for `FilePatternResourceHintsRegistrar`.
FileSystemGeneratedFiles
`GeneratedFiles` implementation that stores generated files using a `FileSystem`.
FileSystemResource
`Resource` implementation for `java.io.File` and `java.nio.file.Path` handles with a file system target.
FileSystemResourceLoader
`ResourceLoader` implementation that resolves plain paths as file system resources rather than as class path resources (the latter is `DefaultResourceLoader`'s default strategy).
FileSystemUtils
Utility methods for working with the file system.
FileUrlResource
Subclass of `UrlResource` which assumes file resolution, to the degree of implementing the `WritableResource` interface for it.
FixedBackOff
A simple `BackOff` implementation that provides a fixed interval between two attempts and a maximum number of retries.
FixedKeySet
FixedValue
`Enhancer` callback that simply returns the value to return from the proxied method.
FlightRecorderApplicationStartup
`ApplicationStartup` implementation for the Java Flight Recorder.
Function<K,V>
FutureAdapter<T,S>
Deprecated.
as of 6.0, with no concrete replacement
FutureUtils
Convenience utilities for working with `Future` and implementations.
Generated
Indicate that the type has been generated ahead of time.
GeneratedClass
A single generated class.
GeneratedClasses
A managed collection of generated classes.
GeneratedFiles
Repository of generated files.
GeneratedFiles.FileHandler
Provide access to a particular file and offer convenient methods to retrieve, save, or override its content.
GeneratedFiles.Kind
The various kinds of generated files that are supported.
GeneratedMethod
A generated method.
GeneratedMethods
A managed collection of generated methods.
GeneratedTypeReference
A `TypeReference` for a generated type.
GenerationContext
Central interface used for code generation.
GeneratorStrategy
The `GeneratorStrategy` is responsible for taking a `ClassGenerator` and producing a byte array containing the data for the generated `Class`.
GenericConversionService
Base `ConversionService` implementation suitable for use in most environments.
GenericConverter
Generic converter interface for converting between two or more types.
GenericConverter.ConvertiblePair
Holder for a source-to-target class pair.
GenericTypeResolver
Helper class for resolving generic types against type variables.
Handle
A reference to a field or a method.
HashCodeCustomizer
Hints
Constants and convenience methods for working with hints.
IdGenerator
Contract for generating universally unique identifiers (`UUIDs`).
ImmutableBean
ImmutableBean.Generator
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.
InMemoryGeneratedFiles
`GeneratedFiles` implementation that keeps generated files in-memory.
InputStreamResource
`Resource` implementation for a given `InputStream` or a given `InputStreamSource` (which can be supplied as a lambda expression) for a lazy `InputStream` on demand.
InputStreamSource
Simple interface for objects that are sources for an `InputStream`.
InstanceComparator<T>
Compares objects based on an arbitrary class order.
InstanceFilter<T>
A simple instance filter that checks if a given instance match based on a collection of includes and excludes element.
InterceptFieldCallback
InterceptFieldEnabled
InterceptFieldFilter
InterceptFieldTransformer
InterfaceMaker
Generates new interfaces at runtime.
InvalidMimeTypeException
Exception thrown from `MimeTypeUtils.parseMimeType(String)` in case of encountering an invalid content type specification String.
InvocationHandler
`InvocationHandler` replacement (unavailable under JDK 1.2).
JavaSerializationHint
A hint that describes the need for Java serialization at runtime.
JavaSerializationHint.Builder
Builder for `JavaSerializationHint`.
JdkIdGenerator
An `IdGenerator` that calls `UUID.randomUUID()`.
JdkProxyHint
A hint that describes the need for a JDK interface-based `Proxy`.
JdkProxyHint.Builder
Builder for `JdkProxyHint`.
JettyDataBuffer
Implementation of the `DataBuffer` interface that can wrap a Jetty `Content.Chunk`.
JettyDataBufferFactory
Implementation of the `DataBufferFactory` interface that creates `JettyDataBuffer` instances.
JOptCommandLinePropertySource
Deprecated.
since 6.1 with no plans for a replacement
KeyFactory
Generates classes to handle multi-valued keys, for use in things such as Maps and Sets.
KeyFactory.Generator
KeyFactoryCustomizer
Marker interface for customizers of `KeyFactory`
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.
Label
A position in the bytecode of a method.
LazyLoader
Lazy-loading `Enhancer` callback.
LimitedDataBufferList
Custom `List` to collect data buffers with and enforce a limit on the total number of bytes buffered.
LinkedCaseInsensitiveMap<V>
`LinkedHashMap` variant that stores String keys in a case-insensitive manner, for example for key-based access in a results table.
LinkedMultiValueMap<K,V>
Simple implementation of `MultiValueMap` that wraps a `LinkedHashMap`, storing multiple values in an `ArrayList`.
ListenableFuture<T>
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, in favor of `CompletableFuture`
ListenableFutureAdapter<T,S>
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, in favor of `CompletableFuture`
ListenableFutureCallback<T>
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, in favor of `CompletableFuture.whenComplete(BiConsumer)`
ListenableFutureCallbackRegistry<T>
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, with no concrete replacement
ListenableFutureTask<T>
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, with no concrete replacement
LoadingCache<K,KK,V>
Local
LocalizedResourceHelper
Helper class for loading a localized resource, specified through name, extension and current locale.
LocalVariablesSorter
A `MethodVisitor` that renumbers local variables in their order of appearance.
LogAccessor
A convenient accessor for Commons Logging, providing not only `CharSequence` based log methods but also `Supplier` based variants for use with Java 8 lambda expressions.
LogDelegateFactory
Factory for common `Log` delegates with Spring's logging conventions.
LogFormatUtils
Utility methods for formatting and logging messages.
LogMessage
A simple log message type for use with Commons Logging, allowing for convenient lazy resolution of a given `Supplier` instance (typically bound to a lambda expression) or a printf-style format string (`String.format(java.lang.String, java.lang.Object...)`) in its `LogMessage.toString()`.
MapPropertySource
`PropertySource` that reads keys and values from a `Map` object.
MemberCategory
Predefined `Member` categories.
MemberHint
Base hint that describes the need for reflection on a `Member`.
MergedAnnotation<A extends Annotation>
A single merged annotation returned from a `MergedAnnotations` collection.
MergedAnnotation.Adapt
Adaptations that can be applied to attribute values when creating Maps or `AnnotationAttributes`.
MergedAnnotationCollectors
`Collector` implementations that provide various reduction operations for `MergedAnnotation` instances.
MergedAnnotationPredicates
Predicate implementations that provide various test operations for `MergedAnnotations`.
MergedAnnotations
Provides access to a collection of merged annotations, usually obtained from a source such as a `Class` or `Method`.
MergedAnnotations.Search
Fluent API for configuring the search algorithm used in the `MergedAnnotations` model and performing a search.
MergedAnnotations.SearchStrategy
Search strategies supported by `MergedAnnotations.search(SearchStrategy)` as well as `MergedAnnotations.from(AnnotatedElement, SearchStrategy)` and variants of that method.
MergedAnnotationSelector<A extends Annotation>
Strategy interface used to select between two `MergedAnnotation` instances.
MergedAnnotationSelectors
`MergedAnnotationSelector` implementations that provide various options for `MergedAnnotation` instances.
MetadataReader
Simple facade for accessing class metadata, as read by an ASM `ClassReader`.
MetadataReaderFactory
Factory interface for `MetadataReader` instances.
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).
MethodDelegate
DOCUMENTATION FROM APACHE AVALON DELEGATE CLASS
MethodDelegate.Generator
MethodFilter
MethodFilterTransformer
MethodInfo
MethodInfoTransformer
MethodInterceptor
General-purpose `Enhancer` callback which provides for "around advice".
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.
MethodInvoker
Helper class that allows for specifying a method to invoke in a declarative fashion, be it static or non-static.
MethodMetadata
Interface that defines abstract access to the annotations of a specific method, in a form that does not require that method's class to be loaded yet.
MethodParameter
Helper class that encapsulates the specification of a method parameter, i.e.
MethodProxy
Classes generated by `Enhancer` pass this object to the registered `MethodInterceptor` objects when an intercepted method is invoked.
MethodReference
A reference to a method with convenient code generation for referencing, or invoking it.
MethodReference.ArgumentCodeGenerator
Strategy for generating code for arguments based on their type.
MethodTooLargeException
Exception thrown when the Code attribute of a method produced by a `ClassWriter` is too large.
MethodVisitor
A visitor to visit a Java method.
MethodVisitorTee
MethodWrapper
MimeType
Represents a MIME Type, as originally defined in RFC 2046 and subsequently used in other Internet protocols including HTTP.
MimeType.SpecificityComparator<T extends MimeType>
Deprecated, for removal: This API element is subject to removal in a future version.
As of 6.0, with no direct replacement
MimeTypeUtils
Miscellaneous `MimeType` utility methods.
MissingRequiredPropertiesException
Exception thrown when required properties are not found.
Mixin
`Mixin` allows multiple objects to be combined into a single larger object.
Mixin.Generator
ModuleResource
`Resource` implementation for `Module` resolution, performing `ModuleResource.getInputStream()` access via `Module.getResourceAsStream(java.lang.String)`.
ModuleVisitor
A visitor to visit a Java module.
MonoToListenableFutureAdapter<T>
Deprecated.
as of 6.0, in favor of `Mono.toFuture()`
MulticastDelegate
MulticastDelegate.Generator
MultiValueMap<K,V>
Extension of the `Map` interface that stores multiple values.
MultiValueMapAdapter<K,V>
Adapts a given `Map` to the `MultiValueMap` contract.
MutablePropertySources
The default implementation of the `PropertySources` interface.
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).
NamingPolicy
Customize the generated class name for `AbstractClassGenerator`-based utilities.
NativeConfigurationWriter
Write `RuntimeHints` as GraalVM native configuration.
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.
Netty5BufferDecoder
Decoder for `Buffers`.
Netty5BufferEncoder
Encoder for `Buffers`.
Netty5DataBuffer
Implementation of the `DataBuffer` interface that wraps a Netty 5 `Buffer`.
Netty5DataBufferFactory
Implementation of the `DataBufferFactory` interface based on a Netty 5 `BufferAllocator`.
NettyByteBufDecoder
Decoder for `ByteBufs`.
NettyByteBufEncoder
Encoder for `ByteBufs`.
NettyDataBuffer
Implementation of the `DataBuffer` interface that wraps a Netty 4 `ByteBuf`.
NettyDataBufferFactory
Implementation of the `DataBufferFactory` interface based on a Netty 4 `ByteBufAllocator`.
NonNull
A common Spring annotation to declare that annotated elements cannot be `null`.
NonNullApi
A common Spring annotation to declare that parameters and return values are to be considered as non-nullable by default for a given package.
NonNullFields
A common Spring annotation to declare that fields are to be considered as non-nullable by default for a given package.
NoOp
Methods using this `Enhancer` callback will delegate directly to the default (super) implementation in the base class.
Nullable
A common Spring annotation to declare that annotated elements can be `null` under certain circumstances.
NullSafeComparator<T>
Deprecated.
as of 6.1 in favor of `Comparator.nullsLast(java.util.Comparator<? super T>)` and `Comparator.nullsFirst(java.util.Comparator<? super T>)`
NumberUtils
Miscellaneous utility methods for number conversion and parsing.
ObjectSwitchCallback
ObjectUtils
Miscellaneous object utility methods.
Opcodes
The JVM opcodes, access flags and array type codes.
Order
`@Order` defines the sort order for an annotated component.
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`.
OrderUtils
General utility for determining the order of an object based on its type declaration.
OverridingClassLoader
`ClassLoader` that does not always delegate to the parent loader as normal class loaders do.
ParallelSorter
For the efficient sorting of multiple arrays in parallel.
ParallelSorter.Generator
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.
PathMatcher
Strategy interface for `String`-based path matching.
PathMatchingResourcePatternResolver
A `ResourcePatternResolver` implementation that is able to resolve a specified resource location path into one or more matching Resources.
PathResource
`Resource` implementation for `Path` handles, performing all operations and transformations via the `Path` API.
PatternMatchUtils
Utility methods for simple pattern matching, in particular for Spring's typical `xxx*`, `*xxx`, `*xxx*`, and `xxx*yyy` pattern styles.
PlaceholderResolutionException
Thrown when the resolution of placeholder failed.
PooledDataBuffer
Extension of `DataBuffer` that allows for buffers that share a memory pool.
Predicate
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.
ProcessArrayCallback
ProcessSwitchCallback
Profiles
Profile predicate that may be accepted by an `Environment`.
PropertiesLoaderSupport
Base class for JavaBean-style components that need to load properties from one or more resources.
PropertiesLoaderUtils
Convenient utility methods for loading of `java.util.Properties`, performing standard handling of input streams.
PropertiesPersister
Strategy interface for persisting `java.util.Properties`, allowing for pluggable parsing strategies.
PropertiesPropertySource
`PropertySource` implementation that extracts properties from a `Properties` object.
Property
A description of a JavaBeans Property that allows us to avoid a dependency on `java.beans.PropertyDescriptor`.
PropertyPlaceholderHelper
Utility class for working with Strings that have placeholder values in them.
PropertyPlaceholderHelper.PlaceholderResolver
Strategy interface used to resolve replacement values for placeholders contained in Strings.
PropertyResolver
Interface for resolving properties against any underlying source.
PropertySource<T>
Abstract base class representing a source of name/value property pairs.
PropertySource.StubPropertySource
`PropertySource` to be used as a placeholder in cases where an actual property source cannot be eagerly initialized at application context creation time.
PropertySourceDescriptor
Descriptor for a `PropertySource`.
PropertySourceFactory
Strategy interface for creating resource-based `PropertySource` wrappers.
PropertySourceProcessor
Contribute `property sources` to the `Environment`.
PropertySources
Holder containing one or more `PropertySource` objects.
PropertySourcesPropertyResolver
`PropertyResolver` implementation that resolves property values against an underlying set of `PropertySources`.
ProtocolResolver
A resolution strategy for protocol-specific resource handles.
Proxy
This class is meant to be used as replacement for `java.lang.reflect.Proxy` under JDK 1.2.
ProxyHints
Gather the need for using proxies at runtime.
ProxyHintsPredicates
Generator of `ProxyHints` predicates, testing whether the given hints match the expected behavior for proxies.
ProxyRefDispatcher
Dispatching `Enhancer` callback.
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()`.
RecordComponentVisitor
A visitor to visit a record component.
ReflectionHints
Gather the need for reflection at runtime.
ReflectionHintsPredicates
Generator of `ReflectionHints` predicates, testing whether the given hints match the expected behavior for reflection.
ReflectionHintsPredicates.ConstructorHintPredicate
ReflectionHintsPredicates.ExecutableHintPredicate<T extends Executable>
ReflectionHintsPredicates.FieldHintPredicate
ReflectionHintsPredicates.MethodHintPredicate
ReflectionHintsPredicates.TypeHintPredicate
ReflectionUtils
Simple utility class for working with the reflection API and handling reflection exceptions.
ReflectionUtils.FieldCallback
Callback interface invoked on each field in the hierarchy.
ReflectionUtils.FieldFilter
Callback optionally used to filter fields to be operated on by a field callback.
ReflectionUtils.MethodCallback
Action to take on each method.
ReflectionUtils.MethodFilter
Callback optionally used to filter methods to be operated on by a method callback.
Reflective
Indicate that the annotated element requires reflection.
ReflectiveProcessor
Process an `AnnotatedElement` and register the necessary reflection hints for it.
ReflectiveRuntimeHintsRegistrar
Process `@Reflective` annotated elements.
ReflectUtils
RegexPatternTypeFilter
A simple filter for matching a fully-qualified class name with a regex `Pattern`.
RegisterReflection
Register reflection hints against an arbitrary number of target classes.
RegisterReflectionForBinding
Register reflection hints for data binding or reflection-based serialization against an arbitrary number of target classes.
RegisterReflectionReflectiveProcessor
A `ReflectiveProcessor` implementation that pairs with `@RegisterReflection`.
RegisterReflectionReflectiveProcessor.ReflectionRegistration
RejectModifierPredicate
RepeatableContainers
Strategy used to determine annotations that act as containers for other annotations.
ResizableByteArrayOutputStream
An extension of `ByteArrayOutputStream` that: has public `ResizableByteArrayOutputStream.grow(int)` and `ResizableByteArrayOutputStream.resize(int)` methods to get more control over the size of the internal buffer has a higher initial capacity (256) by default
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`.
Resource
Interface for a resource descriptor that abstracts from the actual type of underlying resource, such as a file or class path resource.
ResourceArrayPropertyEditor
Editor for `Resource` arrays, to automatically convert `String` location patterns (for example, `"file:C:/my*.txt"` or `"classpath*:myfile.txt"`) to `Resource` array properties.
ResourceBundleHint
A hint that describes the need to access a `ResourceBundle`.
ResourceBundleHint.Builder
Builder for `ResourceBundleHint`.
ResourceDecoder
Decoder for `Resources`.
ResourceEditor
`Editor` for `Resource` descriptors, to automatically convert `String` locations for example, `file:C:/myfile.txt` or `classpath:myfile.txt` to `Resource` properties instead of using a `String` location property.
ResourceEncoder
Encoder for `Resources`.
ResourceHints
Gather the need for resources available at runtime.
ResourceHintsPredicates
Generator of `ResourceHints` predicates, testing whether the given hints match the expected behavior for resources.
ResourceLoader
Strategy interface for loading resources (for example, class path or file system resources).
ResourcePatternHint
A hint that describes resources that should be made available at runtime.
ResourcePatternHints
A collection of `ResourcePatternHint` describing whether resources should be made available at runtime using a matching algorithm based on include/exclude patterns.
ResourcePatternHints.Builder
Builder for `ResourcePatternHints`.
ResourcePatternResolver
Strategy interface for resolving a location pattern (for example, an Ant-style path pattern) into `Resource` objects.
ResourcePatternUtils
Utility class for determining whether a given URL is a resource location that can be loaded via a `ResourcePatternResolver`.
ResourcePropertySource
Subclass of `PropertiesPropertySource` that loads a `Properties` object from a given `Resource` or resource location such as `"classpath:/com/myco/foo.properties"` or `"file:/path/to/file.xml"`.
ResourceRegion
Region of a `Resource` implementation, materialized by a `position` within the `Resource` and a byte `count` for the length of that region.
ResourceRegionEncoder
Encoder for `ResourceRegions`.
ResourceUtils
Utility methods for resolving resource locations to files in the file system.
RouteMatcher
Contract for matching routes to patterns.
RouteMatcher.Route
A parsed representation of a route.
RuntimeHints
Gather hints that can be used to optimize the application runtime.
RuntimeHintsPredicates
Static generator of predicates that test whether the given `RuntimeHints` instance matches the expected behavior for reflection, resource, serialization, or proxy generation.
RuntimeHintsRegistrar
Contract for registering `RuntimeHints` based on the `ClassLoader` of the deployment unit.
SerializationDelegate
A convenient delegate with pre-arranged configuration state for common serialization needs.
SerializationFailedException
Wrapper for the native IOException (or similar) when a `Serializer` or `Deserializer` failed.
SerializationHints
Gather the need for Java serialization at runtime.
SerializationHintsPredicates
Generator of `SerializationHints` predicates, testing whether the given hints match the expected behavior for serialization.
SerializationUtils
Static utilities for serialization and deserialization using Java Object Serialization.
Serializer<T>
A strategy interface for streaming an object to an OutputStream.
SerializingConverter
A `Converter` that delegates to a `Serializer` to convert an object to a byte array.
SettableListenableFuture<T>
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, in favor of `CompletableFuture`
Signature
A representation of a method signature, containing the method name, return type, and parameter types.
SimpleAliasRegistry
Simple implementation of the `AliasRegistry` interface.
SimpleAsyncTaskExecutor
`TaskExecutor` implementation that fires up a new Thread for each task, executing it asynchronously.
SimpleCommandLinePropertySource
`CommandLinePropertySource` implementation backed by an instance of `CommandLineArgs`.
SimpleIdGenerator
A simple `IdGenerator` that starts at 1, increments up to `Long.MAX_VALUE`, and then rolls over.
SimpleMetadataReaderFactory
Simple implementation of the `MetadataReaderFactory` interface, creating a new ASM `ClassReader` for every request.
SimpleNamespaceContext
Simple `javax.xml.namespace.NamespaceContext` implementation.
SimpleReflectiveProcessor
A simple `ReflectiveProcessor` implementation that registers only a reflection hint for the annotated type.
SimpleRouteMatcher
`RouteMatcher` that delegates to a `PathMatcher`.
SimpleSaxErrorHandler
Simple `org.xml.sax.ErrorHandler` implementation: logs warnings using the given Commons Logging logger instance, and rethrows errors to discontinue the XML transformation.
SimpleTransformErrorListener
Simple `javax.xml.transform.ErrorListener` implementation: logs warnings using the given Commons Logging logger instance, and rethrows errors to discontinue the XML transformation.
SimpleValueStyler
`ValueStyler` that converts objects to String form — generally for debugging purposes — using simple styling conventions that mimic the `toString()` styling conventions for standard JDK implementations of collections, maps, and arrays.
SingletonSupplier<T>
A `Supplier` decorator that caches a singleton result and makes it available from `SingletonSupplier.get()` (nullable) and `SingletonSupplier.obtain()` (null-safe).
SmartClassLoader
Interface to be implemented by a reloading-aware ClassLoader (for example, a Groovy-based ClassLoader).
SpringAsmInfo
Utility class exposing constants related to Spring's internal repackaging of the ASM bytecode library: currently based on ASM 9.x plus minor patches.
SpringCglibInfo
Empty class used to ensure that the `org.springframework.cglib` package is processed during javadoc generation.
SpringFactoriesLoader
General purpose factory loading mechanism for internal use within the framework.
SpringFactoriesLoader.ArgumentResolver
Strategy for resolving constructor arguments based on their type.
SpringFactoriesLoader.FailureHandler
Strategy for handling a failure that occurs when instantiating a factory.
SpringNamingPolicy
Custom variant of CGLIB's `DefaultNamingPolicy`, modifying the tag in generated class names from "EnhancerByCGLIB" etc to a "SpringCGLIB" tag and using a plain counter suffix instead of a hash code suffix (as of 6.0).
SpringObjenesis
Spring-specific variant of `ObjenesisStd` / `ObjenesisBase`, providing a cache based on `Class` keys instead of class names, and allowing for selective use of the cache.
SpringProperties
Static holder for local Spring properties, i.e.
SpringVersion
Class that exposes the Spring version.
StandardAnnotationMetadata
`AnnotationMetadata` implementation that uses standard reflection to introspect a given `Class`.
StandardClassMetadata
`ClassMetadata` implementation that uses standard reflection to introspect a given `Class`.
StandardEnvironment
`Environment` implementation suitable for use in 'standard' (i.e.
StandardMethodMetadata
`MethodMetadata` implementation that uses standard reflection to introspect a given `Method`.
StandardReflectionParameterNameDiscoverer
`ParameterNameDiscoverer` implementation which uses JDK 8's reflection facilities for introspecting parameter names (based on the "-parameters" compiler flag).
StartupStep
Step recording metrics about a particular phase or action happening during the `ApplicationStartup`.
StartupStep.Tag
Simple key/value association for storing step metadata.
StartupStep.Tags
Immutable collection of `StartupStep.Tag`.
StaxUtils
Convenience methods for working with the StAX API.
StopWatch
Simple stop watch, allowing for timing of a number of tasks, exposing total running time and running time for each named task.
StopWatch.TaskInfo
Nested class to hold data about one task executed within the `StopWatch`.
StreamUtils
Simple utility methods for dealing with streams.
StringDecoder
Decode from a data buffer stream to a `String` stream, either splitting or aggregating incoming data chunks to realign along newlines delimiters and produce a stream of strings.
StringSwitcher
This class implements a simple String → int mapping for a fixed set of keys.
StringSwitcher.Generator
StringUtils
Miscellaneous `String` utility methods.
StringValueResolver
Simple strategy interface for resolving a String value.
StylerUtils
Simple utility class to allow for convenient access to value styling logic, mainly to support descriptive logging messages.
SuccessCallback<T>
Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0, in favor of `CompletableFuture.whenComplete(BiConsumer)`
SupplierUtils
Convenience utilities for `Supplier` handling.
SyncTaskExecutor
`TaskExecutor` implementation that executes each task synchronously in the calling thread.
SynthesizingMethodParameter
A `MethodParameter` variant which synthesizes annotations that declare attribute aliases via `@AliasFor`.
SystemEnvironmentPropertySource
Specialization of `MapPropertySource` designed for use with system environment variables.
SystemPropertyUtils
Helper class for resolving placeholders in texts.
TaskDecorator
A callback interface for a decorator to be applied to any `Runnable` about to be executed.
TaskExecutor
Simple task executor interface that abstracts the execution of a `Runnable`.
TaskExecutorAdapter
Adapter that takes a JDK `java.util.concurrent.Executor` and exposes a Spring `TaskExecutor` for it.
TaskRejectedException
Exception thrown when a `TaskExecutor` rejects to accept a given task for execution.
TaskTimeoutException
Deprecated.
as of 5.3.16 since the common executors do not support start timeouts
ThrowingBiFunction<T,U,R>
A `BiFunction` that allows invocation of code that throws a checked exception.
ThrowingConsumer<T>
A `Consumer` that allows invocation of code that throws a checked exception.
ThrowingFunction<T,R>
A `Function` that allows invocation of code that throws a checked exception.
ThrowingSupplier<T>
A `Supplier` that allows invocation of code that throws a checked exception.
TinyBitSet
Deprecated.
ToStringCreator
Utility class that builds pretty-printing `toString()` methods with pluggable styling conventions.
ToStringStyler
A strategy interface for pretty-printing `toString()` methods.
TouchableDataBuffer
Extension of `DataBuffer` that allows for buffers that can be given hints for debugging purposes.
Transformer
TransformerUtils
Contains common behavior relating to `Transformers` and the `javax.xml.transform` package in general.
TransformingClassGenerator
TransformingClassLoader
Type
A Java field or method type.
TypeDescriptor
Contextual descriptor about a type to convert from or to.
TypeFilter
Base interface for type filters using a `MetadataReader`.
TypeHint
A hint that describes the need for reflection on a type.
TypeHint.Builder
Builder for `TypeHint`.
TypePath
The path to a type argument, wildcard bound, array element type, or static inner type within an enclosing type.
TypeReference
Type abstraction that can be used to refer to types that are not available as a `Class` yet.
TypeReference
A reference to a type appearing in a class, field or method declaration, or on an instruction.
TypeUtils
TypeUtils
Utility to work with generic type parameters.
UndeclaredThrowableException
Used by `Proxy` as a replacement for `java.lang.reflect.UndeclaredThrowableException`.
UndeclaredThrowableStrategy
A `GeneratorStrategy` suitable for use with `Enhancer` which causes all undeclared exceptions thrown from within a proxied method to be wrapped in an alternative exception of your choice.
UndeclaredThrowableTransformer
UnsupportedTypeValueCodeGenerationException
Thrown when a `ValueCodeGenerator` could not generate the code for a given value.
UrlResource
`Resource` implementation for `java.net.URL` locators.
ValueCodeGenerationException
Thrown when value code generation fails.
ValueCodeGenerator
Code generator for a single value.
ValueCodeGenerator.Delegate
Strategy interface that can be used to implement code generation for a particular value type.
ValueCodeGeneratorDelegates
Code generator `ValueCodeGenerator.Delegate` for well known value types.
ValueCodeGeneratorDelegates.CollectionDelegate<T extends Collection<?>>
Abstract `ValueCodeGenerator.Delegate` for `Collection` types.
ValueCodeGeneratorDelegates.MapDelegate
`ValueCodeGenerator.Delegate` for `Map` types.
ValueStyler
Strategy that encapsulates value String styling algorithms according to Spring conventions.
VfsResource
JBoss VFS based `Resource` implementation.
VfsUtils
Utility for detecting and accessing JBoss VFS in the classpath.
VirtualThreadTaskExecutor
A `TaskExecutor` implementation based on virtual threads in JDK 21+.
VisibilityPredicate
WeakCacheKey<T>
Allows to check for object equality, yet the class does not keep strong reference to the target.
WritableResource
Extended interface for a resource that supports writing to it.
XmlValidationModeDetector
Detects whether an XML stream is using DTD- or XSD-based validation.