All Classes and Interfaces
Class
Description
Abstract base class that decodes from a data buffer stream to a
CharSequence stream.Abstract class for all code-generating CGLIB utilities.
Type filter that exposes a
ClassMetadata object
to subclasses, for class testing purposes.Abstract base class for
Decoder implementations that can decode
a DataBuffer directly to the target element type.Abstract base class for
Decoder implementations.Abstract base class for
Encoder implementations.Abstract base class for
Environment implementations.Abstract base class for resources which resolve URLs into File references,
such as
UrlResource or ClassPathResource.Abstract base class for resolving properties against any underlying source.
Convenience base class for
Resource implementations,
pre-implementing typical behavior.Abstract base class for
Encoder
classes that can only deal with a single value.Type filter that is aware of traversing over hierarchy.
Base
TypeReference implementation that ensures consistent behaviour
for equals(), hashCode(), and toString() based on
the canonical name.Determine the access control of a
Member or type signature.@AliasFor is an annotation that is used to declare aliases for
annotation attributes.Common interface for managing aliases.
An
IdGenerator that uses SecureRandom for the initial seed and
Random thereafter, instead of calling UUID.randomUUID() every
time as JdkIdGenerator does.General utility methods for finding annotations, meta-annotations, and
repeatable annotations on
AnnotatedElements.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.LinkedHashMap subclass representing annotation attribute
key-value pairs as read by AnnotationUtils,
AnnotatedElementUtils, and Spring's reflection- and ASM-based
AnnotationMetadata implementations.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).Thrown by
AnnotationUtils and synthesized annotations
if an annotation is improperly configured.Callback interface that can be used to filter specific annotation types.
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.
A simple
TypeFilter which matches classes with a given annotation,
checking inherited annotations as well.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).
A visitor to visit a Java annotation.
PathMatcher implementation for Ant-style path patterns.Tests whether a string matches against a pattern via a
Pattern.The default
Comparator implementation returned by
AntPathMatcher.getPatternComparator(String).Utility for determining if AOT-processed optimizations must be used rather
than the regular runtime.
Instruments the application startup phase using
steps.Type filter that uses AspectJ type pattern for matching.
Assertion utility class that assists in validating arguments.
A simple filter which matches classes that are assignable to a given type.
Deprecated.
Extended interface for asynchronous
TaskExecutor implementations,
offering support for Callable.A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine
Specification (JVMS).
Interface defining a generic contract for attaching and accessing metadata
to/from arbitrary objects.
Support class for
AttributeAccessors, providing
a base implementation of all methods.Simple
List wrapper class that allows for elements to be
automatically populated as they are requested.Factory interface for creating elements for an index-based access
data structure such as a
List.Exception to be thrown from ElementFactory.
Provide a
BackOffExecution that indicates the rate at which
an operation should be retried.Represent a particular back-off execution.
Deprecated, for removal: This API element is subject to removal in a future version.
as of Spring Framework 6.0.5 in favor of
Base64; scheduled
for removal in 6.2A
Map-based view of a JavaBean.Register the necessary reflection hints so that the specified type can be
bound at runtime.
Helper for resolving synthetic
bridge Methods to the
Method being bridged.Decoder for
byte arrays.Encoder for
byte arrays.Resource implementation for a given byte array.Decoder for
ByteBuffers.Encoder for
ByteBuffers.A dynamically extensible vector of bytes.
Caching implementation of the
MetadataReaderFactory interface,
caching a MetadataReader instance per Spring Resource handle
(i.e.All callback interfaces used by
Enhancer extend this interface.Map methods of subclasses generated by
Enhancer to a particular
callback.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.Encode from a
CharSequence stream to a bytes stream.Exception that indicates an incompatible class format encountered
in a class file during metadata reading.
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.
CGLIB GeneratorStrategy variant which exposes the application ClassLoader
as current thread context ClassLoader for the time of class generation.
Interface that defines abstract metadata of a specific class,
in a form that does not require that class to be loaded yet.
Generate unique class names based on a target
ClassName and a
feature name.Resource implementation for class path resources.A parser to make a
ClassVisitor visit a ClassFile structure, as defined in the Java
Virtual Machine Specification (JVMS).ResourceLoader implementation that interprets plain resource paths
as relative to a given java.lang.Class.Exception thrown when the constant pool of a class produced by a
ClassWriter is too
large.Miscellaneous
java.lang.Class utility methods.A visitor to visit a Java class.
A
ClassVisitor that generates a corresponding ClassFile structure, as defined in the Java
Virtual Machine Specification (JVMS).Extension of
DataBuffer that allows for buffers that can be used
in a try-with-resources statement.General error that indicates a problem while encoding and decoding to and
from an Object stream.
Factory for collections that is aware of common Java and Spring collection types.
Miscellaneous collection utility methods.
Abstract base class for
PropertySource implementations backed by command line
arguments.java.io.Writer adapter for a Commons Logging Log.Deprecated.
as of 6.1 in favor of
Comparator.naturalOrder()Convenient entry point with generically typed factory methods
for common Spring
Comparator variants.Deprecated.
as of 6.0, with no concrete replacement
Composite iterator that combines multiple other iterators,
as registered via
CompositeIterator.add(Iterator).Composite
PropertySource implementation that iterates over a set of
PropertySource instances.Composite
TaskDecorator that delegates to other task decorators.Support class for throttling concurrent access to a specific resource.
Simple LRU (Least Recently Used) cache, bounded by a specified cache capacity.
A single map entry.
A reference to an
ConcurrentReferenceHashMap.Entry contained in the map.Various reference types supported by this map.
The types of restructuring that can be performed.
Allows a
Converter, GenericConverter or ConverterFactory to
conditionally execute based on attributes of the source and target
TypeDescriptor.A
GenericConverter that may conditionally execute based on attributes
of the source and target TypeDescriptor.Contract for
runtime hints that only apply
if the described condition is met.Configuration interface to be implemented by most if not all
ConversionService
types.Configuration interface to be implemented by most if not all
Environment types.Special
ObjectInputStream subclass that resolves class names
against a specific ClassLoader.Configuration interface to be implemented by most if not all
PropertyResolver
types.A constant whose value is computed at runtime, with a bootstrap method.
Deprecated.
since 6.1 with no replacement; use an enum, map, or similar custom
solution instead
Exception thrown when the
Constants class is asked for
an invalid constant name.TaskDecorator that wraps the execution
of tasks, assisting with context propagation.Extended interface for a resource that is loaded from an enclosing
'context', e.g.
Provides methods to support various naming and other conventions used
throughout the framework.
Base class for exceptions thrown by the conversion system.
Exception to be thrown when an actual type conversion attempt fails.
A service interface for type conversion.
A factory for common
ConversionService
configurations.A converter converts a source object of type
S to a target of type T.A factory for "ranged" converters that can convert objects from S to subtypes of R.
Exception to be thrown when a suitable converter could not be found
in a given conversion service.
For registering converters with a type conversion system.
A
Comparator that converts values before they are compared.Adapter that exposes a
PropertyEditor for any given
ConversionService and specific target type.Utilities for working with Kotlin Coroutines.
Simple customizable helper class for creating new
Thread instances.Customizes key types for
KeyFactory when building equals, hashCode, and toString.Basic abstraction over byte buffers.
A dedicated iterator type that ensures the lifecycle of iterated
ByteBuffer elements.Simple pass-through decoder for
DataBuffers.Simple pass-through encoder for
DataBuffers.A factory for
DataBuffers, allowing for allocation and
wrapping of data buffers.Exception that indicates the cumulative number of bytes consumed from a
stream of
DataBuffer's exceeded some pre-configured limit.Utility class for working with
DataBuffers.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.Provides a convenient implementation of the
DataBuffer interface
that can be overridden to adapt the delegate.A data size, such as '12MB'.
A standard set of
DataSize units.Strategy for decoding a
DataBuffer input stream into an output stream
of elements of type <T>.Indicates an issue with decoding the input stream with a focus on content
related issues such as a parse failure.
Base class for decorating ClassLoaders such as
OverridingClassLoader
and org.springframework.instrument.classloading.ShadowingClassLoader,
providing common handling of excluded packages and classes.Interface to be implemented by decorating proxies, in particular Spring AOP
proxies but potentially also custom proxies with decorator semantics.
A specialization of
GenericConversionService configured by default
with converters appropriate for most environments.Default implementation of the
DataBuffer interface that uses a
ByteBuffer internally.Default implementation of the
DataBufferFactory interface.A default
Deserializer implementation that reads an input stream
using Java serialization.Default
GenerationContext implementation.Default
MethodReference implementation based on a MethodSpec.The default policy used by
AbstractClassGenerator.Default implementation of the
ParameterNameDiscoverer strategy interface,
delegating to the Java 8 standard reflection mechanism.Default implementation of the
PropertiesPersister interface.The default implementation for
PropertySourceFactory,
wrapping every resource in a ResourcePropertySource.Default implementation of the
ResourceLoader interface.ClassPathResource that explicitly expresses a context-relative path
through implementing the ContextResource interface.
A
Serializer implementation that writes an object to an output stream
using Java serialization.Spring's default
toString() styler.Converts objects to String form, generally for debugging purposes,
using Spring's
toString styling conventions.Simple
Resource implementation that holds a resource description
but does not point to an actually readable resource.A strategy interface for converting from data in an InputStream to an Object.
A
Converter that delegates to a
Deserializer
to convert data in a byte array to an object.Miscellaneous methods for calculating digests.
Dispatching
Enhancer callback.Convenience methods for working with the DOM API,
in particular for working with DOM Nodes and DOM Elements.
Holder that combines a
Resource descriptor with a specific encoding
or Charset to be used for reading from the resource.Strategy to encode a stream of Objects of type
<T> into an output
stream of bytes.Indicates an issue with encoding the input Object stream with a focus on
not being able to encode Objects.
Generates dynamic subclasses to enable method interception.
A
PropertySource implementation capable of interrogating its
underlying source object to enumerate all possible property name/value
pairs.Interface representing the environment in which the current application is running.
Interface indicating a component that contains and exposes an
Environment reference.A strategy for handling errors.
Comparator capable of sorting exceptions based on their depth from the thrown exception type.
An
InstanceFilter implementation that handles exception types.A hint that describes the need for reflection on a
Method or
Constructor.Builder for
ExecutableHint.Represent the need of reflection for a given
Executable.Adapter that takes a Spring
TaskExecutor
and exposes a full java.util.concurrent.ExecutorService for it.Implementation of
BackOff that increases the back off period for each
retry attempt.All enhanced instances returned by the
Enhancer class implement this interface.Deprecated.
as of 6.0, in favor of
CompletableFuture.whenComplete(BiConsumer)A speedy alternative to
ByteArrayOutputStream.A hint that describes the need for reflection on a
Field.Customizes key types for
KeyFactory right in constructor.A visitor to visit a Java field.
Simple utility methods for file and stream copying.
A
NativeConfigurationWriter implementation that writes the
configuration to disk.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.
Builder for
FilePatternResourceHintsRegistrar.GeneratedFiles implementation that stores generated files using a
FileSystem.ResourceLoader implementation that resolves plain paths as
file system resources rather than as class path resources
(the latter is DefaultResourceLoader's default strategy).Utility methods for working with the file system.
Subclass of
UrlResource which assumes file resolution, to the degree
of implementing the WritableResource interface for it.A simple
BackOff implementation that provides a fixed interval
between two attempts and a maximum number of retries.Enhancer callback that simply returns the value to return
from the proxied method.ApplicationStartup implementation for the Java Flight Recorder.Deprecated.
as of 6.0, with no concrete replacement
Convenience utilities for working with
Future
and implementations.Indicate that the type has been generated ahead of time.
A single generated class.
A managed collection of generated classes.
The various kinds of generated files that are supported.
A generated method.
A managed collection of generated methods.
A
TypeReference for a generated type.Central interface used for code generation.
The
GeneratorStrategy is responsible for taking a
ClassGenerator and producing a byte array containing the
data for the generated Class.Base
ConversionService implementation suitable for use in most environments.Generic converter interface for converting between two or more types.
Holder for a source-to-target class pair.
Helper class for resolving generic types against type variables.
A reference to a field or a method.
Constants and convenience methods for working with hints.
Contract for generating universally unique identifiers (
UUIDs).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.
GeneratedFiles implementation that keeps generated files in-memory.Resource implementation for a given InputStream.Simple interface for objects that are sources for an
InputStream.Compares objects based on an arbitrary class order.
A simple instance filter that checks if a given instance match based on
a collection of includes and excludes element.
Generates new interfaces at runtime.
Exception thrown from
MimeTypeUtils.parseMimeType(String) in case of
encountering an invalid content type specification String.InvocationHandler replacement (unavailable under JDK 1.2).A hint that describes the need for Java serialization at runtime.
Builder for
JavaSerializationHint.An
IdGenerator that calls UUID.randomUUID().A hint that describes the need for a JDK interface-based
Proxy.Builder for
JdkProxyHint.Deprecated.
since 6.1 with no plans for a replacement
Generates classes to handle multi-valued keys, for use in things such as Maps and Sets.
Marker interface for customizers of
KeyFactoryA common delegate for detecting Kotlin's presence and for identifying Kotlin types.
ParameterNameDiscoverer implementation which uses Kotlin's reflection facilities
for introspecting parameter names.A position in the bytecode of a method.
Lazy-loading
Enhancer callback.Custom
List to collect data buffers with and enforce a
limit on the total number of bytes buffered.LinkedHashMap variant that stores String keys in a case-insensitive
manner, for example for key-based access in a results table.Simple implementation of
MultiValueMap that wraps a LinkedHashMap,
storing multiple values in an ArrayList.Deprecated.
as of 6.0, in favor of
CompletableFutureDeprecated.
as of 6.0, in favor of
CompletableFutureDeprecated.
as of 6.0, in favor of
CompletableFuture.whenComplete(BiConsumer)Deprecated.
as of 6.0, with no concrete replacement
Deprecated.
as of 6.0, with no concrete replacement
Helper class for loading a localized resource,
specified through name, extension and current locale.
A
MethodVisitor that renumbers local variables in their order of
appearance.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.Factory for common
Log delegates with Spring's logging conventions.Utility methods for formatting and logging messages.
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().PropertySource that reads keys and values from a Map object.Predefined
Member categories.Base hint that describes the need for reflection on a
Member.A single merged annotation returned from a
MergedAnnotations
collection.Adaptations that can be applied to attribute values when creating
Maps or
AnnotationAttributes.Collector implementations that provide various reduction operations for
MergedAnnotation instances.Predicate implementations that provide various test operations for
MergedAnnotations.Fluent API for configuring the search algorithm used in the
MergedAnnotations model and performing a search.Search strategies supported by
MergedAnnotations.search(SearchStrategy)
as well as MergedAnnotations.from(AnnotatedElement, SearchStrategy)
and variants of that method.Strategy interface used to select between two
MergedAnnotation
instances.MergedAnnotationSelector implementations that provide various options
for MergedAnnotation instances.Simple facade for accessing class metadata,
as read by an ASM
ClassReader.Factory interface for
MetadataReader instances.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).DOCUMENTATION FROM APACHE AVALON DELEGATE CLASS
General-purpose
Enhancer callback which provides for "around advice".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.
A callback interface for metadata lookup on a given method.
Helper class that allows for specifying a method to invoke in a declarative
fashion, be it static or non-static.
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.
Helper class that encapsulates the specification of a method parameter, i.e.
Classes generated by
Enhancer pass this object to the
registered MethodInterceptor objects when an intercepted method is invoked.A reference to a method with convenient code generation for
referencing, or invoking it.
Strategy for generating code for arguments based on their type.
Exception thrown when the Code attribute of a method produced by a
ClassWriter is too
large.A visitor to visit a Java method.
Represents a MIME Type, as originally defined in RFC 2046 and subsequently
used in other Internet protocols including HTTP.
Deprecated, for removal: This API element is subject to removal in a future version.
As of 6.0, with no direct replacement
Miscellaneous
MimeType utility methods.Exception thrown when required properties are not found.
Mixin allows
multiple objects to be combined into a single larger object.Resource implementation for Module resolution,
performing ModuleResource.getInputStream() access via Module.getResourceAsStream(java.lang.String).A visitor to visit a Java module.
Deprecated.
as of 6.0, in favor of
Mono.toFuture()Extension of the
Map interface that stores multiple values.Adapts a given
Map to the MultiValueMap contract.The default implementation of the
PropertySources interface.InheritableThreadLocal subclass that exposes a specified name
as NamedInheritableThreadLocal.toString() result (allowing for introspection).ThreadLocal subclass that exposes a specified name
as NamedThreadLocal.toString() result (allowing for introspection).Customize the generated class name for
AbstractClassGenerator-based utilities.Write
RuntimeHints as GraalVM native configuration.A common delegate for detecting a GraalVM native image environment.
Native image context as defined in GraalVM's
ImageInfo.
Handy class for wrapping checked
Exceptions with a root cause.Helper class for implementing exception classes which are capable of
holding nested exceptions.
Handy class for wrapping runtime
Exceptions with a root cause.Decoder for
Buffers.Encoder for
Buffers.Implementation of the
DataBuffer interface that wraps a Netty 5
Buffer.Implementation of the
DataBufferFactory interface based on a
Netty 5 BufferAllocator.Decoder for
ByteBufs.Encoder for
ByteBufs.Implementation of the
DataBuffer interface that wraps a Netty 4
ByteBuf.Implementation of the
DataBufferFactory interface based on a
Netty 4 ByteBufAllocator.A common Spring annotation to declare that annotated elements cannot be
null.A common Spring annotation to declare that parameters and return values
are to be considered as non-nullable by default for a given package.
A common Spring annotation to declare that fields are to be considered as
non-nullable by default for a given package.
Methods using this
Enhancer callback will delegate directly to the
default (super) implementation in the base class.A common Spring annotation to declare that annotated elements can be
null
under certain circumstances.Deprecated.
as of 6.1 in favor of
Comparator.nullsLast(java.util.Comparator<? super T>) and Comparator.nullsFirst(java.util.Comparator<? super T>)Miscellaneous utility methods for number conversion and parsing.
Miscellaneous object utility methods.
The JVM opcodes, access flags and array type codes.
@Order defines the sort order for an annotated component.Comparator implementation for Ordered objects, sorting
by order value ascending, respectively by priority descending.Strategy interface to provide an order source for a given object.
Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection.General utility for determining the order of an object based on its type declaration.
ClassLoader that does not always delegate to the parent loader
as normal class loaders do.For the efficient sorting of multiple arrays in parallel.
The purpose of this class is to enable capturing and passing a generic
Type.Interface to discover parameter names for methods and constructors.
Strategy interface for
String-based path matching.A
ResourcePatternResolver implementation that is able to resolve a
specified resource location path into one or more matching Resources.Utility methods for simple pattern matching, in particular for Spring's typical
xxx*, *xxx, *xxx*, and xxx*yyy pattern styles.Extension of
DataBuffer that allows for buffers that share
a memory pool.ParameterNameDiscoverer implementation that tries several discoverer
delegates in succession.Profile predicate that may be accepted by an
Environment.Base class for JavaBean-style components that need to load properties
from one or more resources.
Convenient utility methods for loading of
java.util.Properties,
performing standard handling of input streams.Strategy interface for persisting
java.util.Properties,
allowing for pluggable parsing strategies.PropertySource implementation that extracts properties from a
Properties object.A description of a JavaBeans Property that allows us to avoid a dependency on
java.beans.PropertyDescriptor.Utility class for working with Strings that have placeholder values in them.
Strategy interface used to resolve replacement values for placeholders contained in Strings.
Interface for resolving properties against any underlying source.
Abstract base class representing a source of name/value property pairs.
PropertySource to be used as a placeholder in cases where an actual
property source cannot be eagerly initialized at application context
creation time.Descriptor for a
PropertySource.Strategy interface for creating resource-based
PropertySource wrappers.Contribute
property sources to the Environment.Holder containing one or more
PropertySource objects.PropertyResolver implementation that resolves property values against
an underlying set of PropertySources.A resolution strategy for protocol-specific resource handles.
This class is meant to be used as replacement for
java.lang.reflect.Proxy under JDK 1.2.Gather the need for using proxies at runtime.
Generator of
ProxyHints predicates, testing whether the given hints
match the expected behavior for proxies.Dispatching
Enhancer callback.Adapter for a Reactive Streams
Publisher to and from an async/reactive
type such as CompletableFuture, RxJava Observable, and others.A registry of adapters to adapt Reactive Streams
Publisher to/from various
async/reactive types such as CompletableFuture, RxJava Flowable, etc.BlockHoundIntegration for spring-core classes.Describes the semantics of a reactive type including boolean checks for
ReactiveTypeDescriptor.isMultiValue(), ReactiveTypeDescriptor.isNoValue(), and ReactiveTypeDescriptor.supportsEmpty().A visitor to visit a record component.
Gather the need for reflection at runtime.
Generator of
ReflectionHints predicates, testing whether the given hints
match the expected behavior for reflection.Simple utility class for working with the reflection API and handling
reflection exceptions.
Callback interface invoked on each field in the hierarchy.
Callback optionally used to filter fields to be operated on by a field callback.
Action to take on each method.
Callback optionally used to filter methods to be operated on by a method callback.
Indicate that the annotated element requires reflection.
Process an
AnnotatedElement and register the necessary reflection
hints for it.Process
@Reflective annotated elements.A simple filter for matching a fully-qualified class name with a regex
Pattern.Indicates that the classes specified in the annotation attributes require some
reflection hints for binding or reflection-based serialization purposes.
A
ReflectiveProcessor implementation that registers reflection hints
for data binding purpose (class, constructors, fields, properties, record
components, including types transitively used on properties and record components).Strategy used to determine annotations that act as containers for other
annotations.
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
Encapsulates a Java
Type, providing access to
supertypes, interfaces, and
generic parameters along with the ability to ultimately
resolve to a Class.Any object can implement this interface to provide its actual
ResolvableType.Interface for a resource descriptor that abstracts from the actual
type of underlying resource, such as a file or class path resource.
Editor for
Resource arrays, to
automatically convert String location patterns
(e.g.A hint that describes the need to access a
ResourceBundle.Builder for
ResourceBundleHint.Decoder for
Resources.Encoder for
Resources.Gather the need for resources available at runtime.
Generator of
ResourceHints predicates, testing whether the given hints
match the expected behavior for resources.Strategy interface for loading resources (e.g., class path or file system
resources).
A hint that describes resources that should be made available at runtime.
A collection of
ResourcePatternHint describing whether resources should
be made available at runtime using a matching algorithm based on include/exclude
patterns.Builder for
ResourcePatternHints.Strategy interface for resolving a location pattern (for example,
an Ant-style path pattern) into
Resource objects.Utility class for determining whether a given URL is a resource
location that can be loaded via a
ResourcePatternResolver.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".Encoder for
ResourceRegions.Utility methods for resolving resource locations to files in the
file system.
Contract for matching routes to patterns.
A parsed representation of a route.
Gather hints that can be used to optimize the application runtime.
Static generator of predicates that test whether the given
RuntimeHints
instance matches the expected behavior for reflection, resource, serialization,
or proxy generation.Contract for registering
RuntimeHints based on the ClassLoader
of the deployment unit.A convenient delegate with pre-arranged configuration state for common
serialization needs.
Wrapper for the native IOException (or similar) when a
Serializer or
Deserializer failed.Gather the need for Java serialization at runtime.
Generator of
SerializationHints predicates, testing whether the
given hints match the expected behavior for serialization.Static utilities for serialization and deserialization using
Java Object Serialization.
A strategy interface for streaming an object to an OutputStream.
A
Converter that delegates to a
Serializer
to convert an object to a byte array.Deprecated.
as of 6.0, in favor of
CompletableFutureA representation of a method signature, containing the method name,
return type, and parameter types.
Simple implementation of the
AliasRegistry interface.TaskExecutor implementation that fires up a new Thread for each task,
executing it asynchronously.CommandLinePropertySource implementation backed by a simple String array.A simple
IdGenerator that starts at 1, increments up to
Long.MAX_VALUE, and then rolls over.Simple implementation of the
MetadataReaderFactory interface,
creating a new ASM ClassReader for every request.Simple
javax.xml.namespace.NamespaceContext implementation.A simple
ReflectiveProcessor implementation that registers only a
reflection hint for the annotated type.RouteMatcher that delegates to a PathMatcher.Simple
org.xml.sax.ErrorHandler implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.Simple
javax.xml.transform.ErrorListener implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.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.A
Supplier decorator that caches a singleton result and
makes it available from SingletonSupplier.get() (nullable) and SingletonSupplier.obtain() (null-safe).Interface to be implemented by a reloading-aware ClassLoader
(e.g.
Utility class exposing constants related to Spring's internal repackaging
of the ASM bytecode library: currently based on ASM 9.x plus minor patches.
Empty class used to ensure that the
org.springframework.cglib
package is processed during javadoc generation.General purpose factory loading mechanism for internal use within the framework.
Strategy for resolving constructor arguments based on their type.
Strategy for handling a failure that occurs when instantiating a factory.
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).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.Static holder for local Spring properties, i.e.
Class that exposes the Spring version.
AnnotationMetadata implementation that uses standard reflection
to introspect a given Class.ClassMetadata implementation that uses standard reflection
to introspect a given Class.Environment implementation suitable for use in 'standard' (i.e.MethodMetadata implementation that uses standard reflection
to introspect a given Method.ParameterNameDiscoverer implementation which uses JDK 8's reflection facilities
for introspecting parameter names (based on the "-parameters" compiler flag).Step recording metrics about a particular phase or action happening during the
ApplicationStartup.Simple key/value association for storing step metadata.
Immutable collection of
StartupStep.Tag.Convenience methods for working with the StAX API.
Simple stop watch, allowing for timing of a number of tasks, exposing total
running time and running time for each named task.
Nested class to hold data about one task executed within the
StopWatch.Simple utility methods for dealing with streams.
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.This class implements a simple String → int mapping for a fixed set of keys.
Miscellaneous
String utility methods.Simple strategy interface for resolving a String value.
Simple utility class to allow for convenient access to value
styling logic, mainly to support descriptive logging messages.
Deprecated.
as of 6.0, in favor of
CompletableFuture.whenComplete(BiConsumer)Convenience utilities for
Supplier handling.TaskExecutor implementation that executes each task synchronously
in the calling thread.A
MethodParameter variant which synthesizes annotations that
declare attribute aliases via @AliasFor.Specialization of
MapPropertySource designed for use with
system environment variables.Helper class for resolving placeholders in texts.
A callback interface for a decorator to be applied to any
Runnable
about to be executed.Simple task executor interface that abstracts the execution
of a
Runnable.Adapter that takes a JDK
java.util.concurrent.Executor and
exposes a Spring TaskExecutor for it.Exception thrown when a
TaskExecutor rejects to accept
a given task for execution.Deprecated.
as of 5.3.16 since the common executors do not support start timeouts
A
BiFunction that allows invocation of code that throws a checked
exception.A
Consumer that allows invocation of code that throws a checked
exception.A
Function that allows invocation of code that throws a checked
exception.A
Supplier that allows invocation of code that throws a checked exception.Deprecated.
Utility class that builds pretty-printing
toString() methods
with pluggable styling conventions.A strategy interface for pretty-printing
toString() methods.Extension of
DataBuffer that allows for buffers that can be given
hints for debugging purposes.Contains common behavior relating to
Transformers
and the javax.xml.transform package in general.A Java field or method type.
Contextual descriptor about a type to convert from or to.
Base interface for type filters using a
MetadataReader.A hint that describes the need for reflection on a type.
Builder for
TypeHint.The path to a type argument, wildcard bound, array element type, or static inner type within an
enclosing type.
Type abstraction that can be used to refer to types that are not available as
a
Class yet.A reference to a type appearing in a class, field or method declaration, or on an instruction.
Utility to work with generic type parameters.
Used by
Proxy as a replacement for java.lang.reflect.UndeclaredThrowableException.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.Thrown when a
ValueCodeGenerator could not generate the code for a
given value.Resource implementation for java.net.URL locators.Thrown when value code generation fails.
Code generator for a single value.
Strategy interface that can be used to implement code generation for a
particular value type.
Code generator
ValueCodeGenerator.Delegate for well known value types.Abstract
ValueCodeGenerator.Delegate for Collection types.ValueCodeGenerator.Delegate for Map types.Strategy that encapsulates value String styling algorithms
according to Spring conventions.
JBoss VFS based
Resource implementation.Utility for detecting and accessing JBoss VFS in the classpath.
A
TaskExecutor implementation based on virtual threads in JDK 21+.Allows to check for object equality, yet the class does not keep strong reference to the target.
Extended interface for a resource that supports writing to it.
Detects whether an XML stream is using DTD- or XSD-based validation.
AsyncTaskExecutor.submitCompletable(Runnable)andAsyncTaskExecutor.submitCompletable(Callable)