All Classes and Interfaces
Class
Description
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
.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.Encode from a
CharSequence
stream to a bytes stream.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
.Comparator that adapts Comparables to the Comparator interface.
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.Support class for throttling concurrent access to a specific resource.
Deprecated, for removal: This API element is subject to removal in a future version.
ConcurrentExecutorAdapter
is obsolete and will be removed
in Spring Framework 6.1Simple 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.
This class can be used to parse other classes containing constant definitions
in public static final members.
Exception thrown when the
Constants
class is asked for
an invalid constant name.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, with a deprecated fallback
to LocalVariableTableParameterNameDiscoverer
.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.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
.CommandLinePropertySource
implementation backed by a JOpt OptionSet
.Generates classes to handle multi-valued keys, for use in things such as Maps and Sets.
Marker interface for customizers of
KeyFactory
A 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
CompletableFuture
Deprecated.
as of 6.0, in favor of
CompletableFuture
Deprecated.
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.Deprecated, for removal: This API element is subject to removal in a future version.
as of 6.0.1, in favor of
StandardReflectionParameterNameDiscoverer
(with the "-parameters" compiler flag)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.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
some circumstance.A Comparator that will safely compare nulls to be lower or higher than
other objects.
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" and "*xxx*" 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
CompletableFuture
A 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.Resource
implementation for java.net.URL
locators.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.
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)