All Classes and Interfaces
类
说明
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.A node that represents a bytecode instruction.
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.
An AccessException is thrown by an accessor if it has an unexpected problem.
A
MethodVisitor to insert before, after and around advices in methods and constructors.@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.A semantic bytecode analyzer.
A
MethodVisitor that keeps track of stack map frame changes between AnalyzerAdapter.visitFrame(int, int, Object[], int, Object[]) calls.An exception thrown if a problem occurs during the analysis of a method.
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 reflection- and ASM-based
AnnotationMetadata implementations.AnnotationAwareOrderComparator is an extension of
OrderComparator that supports
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.Example class used to test
AnnotationsScanner with enclosing classes.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 node that represents an annotation.
An
AnnotationVisitor that remaps types with a Remapper.Adapter class for exposing annotations as an
AnnotatedElementA 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 or not a string matches against a pattern via a
Pattern.The default
Comparator implementation returned by
AntPathMatcher.getPatternComparator(String).It is used for the scenario of changing less and reading more frequently.
Iterator over an array.
Trims the capacity of this instance's (list or array) to its size.
A
Printer that prints the ASM code to generate the classes if visits.An
Attribute that can generate the ASM code to create an equivalent
attribute.Type filter that uses AspectJ type pattern for matching.
Assertion utility class that assists in validating arguments.
Represents assignment.
A simple filter which matches classes that are assignable to a given type.
Utilities methods for use in the Ast classes.
Extension of the
AsyncTaskExecutor interface, adding the capability to submit
tasks for ListenableFutures.Extended interface for asynchronous
TaskExecutor implementations,
offering an overloaded AsyncTaskExecutor.execute(Runnable, long) variant with a start
timeout parameter as well 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.Provide a
BackOffExecution that indicates the rate at which
an operation should be retried.Represent a particular back-off execution.
A simple utility class for Base64 encoding and decoding.
An
Interpreter for BasicValue values.A
Value that is represented with its type in a seven types type system.An extended
BasicInterpreter that checks that bytecode instructions are correctly used.A
Map-based view of a JavaBean.Represents a bean reference to a type, for example
@foo or @'foo.bar'.A bean resolver can be registered with the evaluation context and will kick in
for bean references:
@myBeanName and &myBeanName expressions.Represents the literal values
TRUE and FALSE.A
TypedValue for booleans.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 Resource handle
(i.e. per ".class" file).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.An
AnnotationVisitor that checks that its methods are properly used.A
ClassVisitor that checks that its methods are properly used.A
FieldVisitor that checks that its methods are properly used.A
MethodVisitor that checks that its methods are properly used.A
ModuleVisitor that checks that its methods are properly used.A
RecordComponentVisitor that checks that its methods are properly used.A
SignatureVisitor that checks that its methods are properly used.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.
A node that represents a class.
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.A
ClassVisitor that remaps types with a Remapper.Exception thrown when the constant pool of a class produced by a
ClassWriter is too
large.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.
A non standard code attribute used for testing purposes.
A non standard code attribute used for testing purposes.
A non standard code attribute used for testing purposes.
A non standard code attribute used for testing purposes.
Manages the class being generated by the compilation process.
Interface used to generate
clinit static initializer blocks.Interface used to generate fields.
A
MethodVisitor that approximates the size of the methods it visits.Abstract base class for
PropertySource implementations backed by command line
arguments.A non standard attribute used for testing purposes.
A non standard attribute used for testing purposes.
A non standard attribute used for testing purposes.
A non standard attribute used for testing purposes.
Comparator that adapts Comparables to the Comparator interface.
Convenient entry point with generically typed factory methods
for common
Comparator variants.A compilable property accessor is able to generate bytecode that represents
the access operation, facilitating compilation to bytecode of expressions
that use the accessor.
Base superclass for compiled expressions.
Composite iterator that combines multiple other iterators,
as registered via
CompositeIterator.add(Iterator).ParameterNameDiscoverer implementation that tries several discoverer
delegates in succession.Composite
PropertySource implementation that iterates over a set of
PropertySource instances.Represents a template expression broken into pieces.
Represents a DOT separated expression sequence, such as
'property1.property2.methodOne()'.Support class for throttling concurrent access to a specific resource.
Adapter that exposes the
Executor interface
for any TaskExecutor.Simple LRU (Least Recently Used) cache, bounded by a specified cache capacity.
Caching implementation of the
MetadataReaderFactory interface backed by a
ConcurrentReferenceHashMap, caching MetadataReader per Framework
Resource handle (i.e. per ".class" file).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.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.Executors are built by resolvers and can be cached by the infrastructure to repeat an
operation quickly without going back to the resolvers.
not a suitable Constructor found
Represents the invocation of a constructor.
A constructor resolver attempts locate a constructor and returns a ConstructorExecutor
that can be used to invoke that constructor.
Extended interface for a resource that is loaded from an enclosing
'context', e.g. 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).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 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.Simple customizable helper class for creating new
Thread instances.Customizes key types for
KeyFactory when building equals, hashCode,
and toString.A
MethodResolver variant for data binding
purposes, using reflection to access instance methods on a given target object.A
PropertyAccessor variant for data binding
purposes, using reflection to access properties for reading and possibly writing.Basic abstraction over byte buffers.
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.From hutool
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
providing common handling of excluded packages and classes.Interface to be implemented by decorating proxies, in particular AOP
proxies but potentially also custom proxies with decorator semantics.
Simple implementation of the
AliasRegistry interface.A specialization of
GenericConversionService configured by default
with converters appropriate for most environments.Default implementation of the
DataBuffer interface that uses a
ByteBuffer internally. with separate read and write positions.Default implementation of the
DataBufferFactory interface.A default
Deserializer implementation that reads an input stream
using Java serialization.The default policy used by
AbstractClassGenerator.Default implementation of the
ParameterNameDiscoverer strategy interface,
using the Java 8 standard reflection mechanism (if available), and falling back
to the ASM-based LocalVariableTableParameterNameDiscoverer for checking
debug information in the class file.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.Default
toString() styler.Converts objects to String form, generally for debugging purposes,
using default
toString styling conventions.Helper class for invoking
ClassLoader.defineClass(String, byte[], int, int).define class strategy
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.
Represents the elvis operator ?
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.
Uses bytecode reflection to figure out the targets of all bridge methods that
use invokespecial and invokeinterface, so that we can later rewrite them to
use invokevirtual.
Enumerable for
EnumA
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.
Expressions are executed in an evaluation context.
Represent an exception that occurs during expression evaluation.
Comparator capable of sorting exceptions based on their depth from the thrown exception type.
An
InstanceFilter implementation that handles exception types.Adapter that takes a
TaskExecutor
and exposes a full java.util.concurrent.ExecutorService for it.A common annotation to declare that annotated elements is Experimental
that can change at any time, and has no guarantee of API stability and
backward-compatibility.
Implementation of
BackOff that increases the back off period for each
retry attempt.An expression capable of evaluating itself against context objects.
Super class for exceptions that can occur whilst processing expressions.
This exception wraps (as cause) a checked exception thrown by some method that SpEL
invokes.
Parses expression strings into compiled expressions that can be evaluated.
An ExpressionState is for maintaining per-expression-evaluation state, any changes to
it are not seen by other expressions but it gives a place to hold local variables and
for component expressions in a compound expression to communicate state.
Common utility functions that may be used by any Expression Language provider.
All enhanced instances returned by the
Enhancer class implement this
interface.Failure callback for a
ListenableFuture.A speedy alternative to
ByteArrayOutputStream.A node that represents a field instruction.
A node that represents a field.
A
FieldVisitor that remaps types with a Remapper.Customizes key types for
KeyFactory right in constructor.A visitor to visit a Java field.
Simple utility methods for file and stream copying.
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.Expression language AST node that represents a float literal.
A symbolic execution stack frame.
A node that represents a stack map frame.
A function reference is of the form "#someFunction(a,b,c)".
Abstract class that adapts a
Future parameterized over S into a Future
parameterized over T.Convenience utilities for working with
Future
and implementations.A
MethodVisitor with convenient methods to generate code.The
GeneratorStrategy</code. 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.
Fast call bean's getter Method
MethodA reference to a field or a method.
Constants and convenience methods for working with hints.
An 'identifier'
SpelNode.Contract for generating universally unique identifiers (
UUIDs).A node that represents an IINC instruction.
An Indexer can index into some proceeding structure to access a particular piece of it.
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.
Represent a list in an expression, e.g. '{1,2,3}'
Represent a map in an expression, e.g.
A node that represents an inner class.
Resource implementation for a given InputStream.A doubly linked list of
AbstractInsnNode objects.A node that represents a zero operand instruction.
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.
Simple factory used to instantiate objects by injecting available parameters.
Callback used to register available parameters.
Strategy for handling a failure that occurs when instantiating a type.
A
MethodVisitor providing a more detailed API to generate and transform instructions.Generates new interfaces at runtime.
Wraps a real parse exception.
A semantic bytecode interpreter.
A node that represents an instruction with a single int operand.
Expression language AST node that represents an integer literal.
Exception thrown from
MimeTypeUtils.parseMimeType(String) in case of
encountering an invalid content type specification String.InvocationHandler replacement (unavailable under
JDK 1.2).A node that represents an invokedynamic instruction.
Iterable
PropertyResolver extensionKnown Java versions.
An
IdGenerator that calls UUID.randomUUID().CommandLinePropertySource implementation backed by a JOpt OptionSet.A
MethodVisitor that removes JSR instructions and inlines the
referenced subroutines.A node that represents a jump instruction.
Generates classes to handle multi-valued keys, for use in things such as Maps
and Sets.
Marker interface for customizers of
KeyFactoryAn immutable container for a key and a value, suitable for use
in creating and populating
Map instances.A position in the bytecode of a method.
An
AbstractInsnNode that encapsulates a Label.Utility that can be used to invoke lambdas in a safe way.
Represents a single callback that can be invoked in a lambda safe way.
Represents a collection of callbacks that can be invoked in a lambda safe way.
The result of a callback which may be a value,
null or absent entirely if
the callback wasn't suitable.Abstract base class for lambda safe callbacks.
Lazy-loading
Enhancer callback.A node that represents an LDC instruction.
Custom
List to collect data buffers with and enforce a
limit on the total number of bytes buffered.A node that represents a line number declaration.
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.Extend
Future with the capability to accept completion callbacks.Abstract class that adapts a
ListenableFuture parameterized over S into a
ListenableFuture parameterized over T.Callback mechanism for the outcome, success or failure, from a
ListenableFuture.Helper class for
ListenableFuture implementations that maintains a
of success and failure callbacks and helps to notify them.Extension of
FutureTask that implements ListenableFuture.Common superclass for nodes representing literals (boolean, string, number, etc).
A very simple hardcoded implementation of the Expression interface that represents a
string literal.
Strategy interface for determining the current Locale.
Simple holder class that associates a LocaleContext instance
with the current thread.
A node that represents a type annotation on a local or resource variable.
A node that represents a local variable declaration.
A
MethodVisitor that renumbers local variables in their order of appearance.Implementation of
ParameterNameDiscoverer that uses the LocalVariableTable
information in the method attributes to discover parameter names.Factory for common
Logger delegates with logging conventions.Utility methods for formatting and logging messages.
Logger From slf4j
Factory that creates
Logger instances.A simple log message type for use with Commons Logging, allowing
for convenient lazy resolution of a given
Supplier instance
(typically bound to a Java 8 lambda expression) or a printf-style
format string (format(java.lang.String, java.lang.Object)) in its LogMessage.toString().Expression language AST node that represents a long integer literal.
A node that represents a LOOKUPSWITCH instruction.
Map cache
Map PropertyResolver implementation
PropertySource that reads keys and values from a Map object.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.From
MessageFormatter
Formats messages according to very simple substitution rules.Simple facade for accessing class metadata,
as read by an ASM
ClassReader.Factory interface for
MetadataReader instances.Simple strategy interface for resolving a value
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
MethodExecutors are built by the resolvers and can be cached by the infrastructure to
repeat an operation quickly without going back to the resolvers.
MethodFilter instances allow SpEL users to fine tune the behaviour of the method
resolution process.
A node that represents a method instruction.
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.
Fast Method Invoker
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.
A node that represents a method.
Helper class that encapsulates the specification of a method parameter, i.e. a
Method
or Constructor plus a parameter index and a nested type index for a declared generic
type.Classes generated by
Enhancer pass this object to the registered
MethodInterceptor objects when an intercepted method is invoked.Expression language AST node that represents a method reference.
A
MethodVisitor that remaps types with a Remapper.A method resolver attempts to locate a method and returns a command executor that can be
used to invoke that method.
A named method descriptor.
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.
Comparator to sort
MimeTypes in order of specificity.Miscellaneous
MimeType utility methods.Exception thrown when required properties are not found.
Mixin allows multiple objects to be combined into a single
larger object.Simple
PropertySource implementation for use in testing.A node that represents an exported package with its name and the module that can access to it.
A ModuleHashes attribute.
A node that represents a module declaration.
A node that represents an opened package with its name and the module that can access it.
A node that represents a service and its implementation provided by the current module.
A
ModuleVisitor that remaps types with a Remapper.A node that represents a required module with its name and access of a module descriptor.
A ModuleResolution attribute.
A ModuleTarget attribute.
A visitor to visit a Java module.
Adapts a
Mono into a ListenableFuture by obtaining a
CompletableFuture from the Mono via Mono.toFuture()
and then adapting it with CompletableToListenableFutureAdapter.A node that represents a MULTIANEWARRAY instruction.
Extension of the
Map interface that stores multiple values.Adapts a given
Map to the MultiValueMap contract.Mutable MapPropertySource
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.Handy class for wrapping checked
Exceptions with a root cause.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
ByteBuf.Implementation of the
DataBufferFactory interface based on a
Netty ByteBufAllocator.A common annotation to declare that annotated elements cannot be
null.A common annotation to declare that parameters and return values
are to be considered as non-nullable by default for a given package.
A common 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 annotation to declare that annotated elements can be
null under
some circumstance.Expression language AST node that represents null.
A Comparator that will safely compare nulls to be lower or higher than
other objects.
Simple serializable class that serves as a
null replacement
for cache stores which otherwise do not support null values.Miscellaneous object utility methods.
Represents the boolean AND operation.
The JVM opcodes, access flags and array type codes.
Decrement operator.
Implements division operator.
Implements the equality operator.
Supported operations that an
OperatorOverloader can implement for any pair of
operands.Common supertype for operators that operate on either one or two operands.
A descriptor comparison encapsulates the result of comparing descriptor
for two operands and describes at what level they are compatible.
Represents the between operator.
The operator 'instanceof' checks if an object is of the class specified in the right
hand operand, in the same way that
instanceof does in Java.Implements the matches operator.
Represents a NOT operation.
By default the mathematical operators
Operation support simple types
like numbers.The power operator.
Implements greater-than-or-equal operator.
Implements the greater-than operator.
Increment operator.
Implements the less-than-or-equal operator.
Implements the less-than operator.
The minus operator supports:
subtraction of numbers
subtraction of an int from a string of one character
(effectively decreasing that character), so 'd'-3='a'
Implements the modulus operator.
Implements the
multiply operator.Implements the not-equal operator.
Represents the boolean OR operation.
The plus operator will:
add numbers
concatenate strings
@Order defines the sort order for an annotated component.Comparator implementation for Ordered objects, sorting
by order value ascending, respectively by priority descending.Ordered is an interface that can be implemented by objects that
should be orderable, for example in a Collection.Strategy interface to provide an order source for a given object.
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.
abstract class to discover parameter names for methods and constructors.
A node that represents a parameter of a method.
Represent an exception that occurs during expression parsing.
Input provided to an expression parser that can influence an expression
parsing/compilation routine.
A
ResourceLoader implementation that is able to resolve a specified
resource location path into one or more matching Resources.Strategy interface for resolving a location pattern (for example,
an Ant-style path pattern) into
Resource objects.Strategy interface used to resolve replacement values for placeholders contained in Strings.
Extension of
DataBuffer that allows for buffers that share
a memory pool.An abstract converter from visit events to text.
Profile predicate that may be accepted by an
Environment.Represents projection, where a given operation is performed on all elements in some
input sequence, returning a new sequence of the same size.
Base class for JavaBean-style components that need to load properties
from one or more resources.
Strategy interface for persisting
java.util.Properties,
allowing for pluggable parsing strategies.PropertySource implementation that extracts properties from a
Properties object.Convenient utility methods for loading of
java.util.Properties,
performing standard handling of input streams.A description of a JavaBeans Property that allows us to avoid a dependency on
java.beans.PropertyDescriptor.A property accessor is able to read from (and possibly write to) an object's properties.
Utility that can be used to map values from a supplied source to a destination.
A source that is in the process of being mapped.
An operation that can be applied to a
PropertyMapper.Source.Represents a simple property or field reference.
Utility class for working with Strings that have placeholder values in them.
Interface for resolving properties against any underlying source.
Composite PropertyResolver implementation
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.Strategy interface for creating resource-based
PropertySource wrappers.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.Dispatching
Enhancer callback.Represents a dot separated sequence of strings that indicate a package qualified type
reference.
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, and others.BlockHoundIntegration for core classes.Describes the semantics of a reactive type including boolean checks for
ReactiveTypeDescriptor.isMultiValue(), ReactiveTypeDescriptor.isNoValue(), and ReactiveTypeDescriptor.supportsEmpty().Expression language AST node that represents a real literal.
A node that represents a record component.
A
RecordComponentVisitor that remaps types with a Remapper.A visitor to visit a record component.
Reflection operations exception
Utility methods used by the reflection resolver code to discover the appropriate
methods/constructors and fields that should be used in expressions.
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.
A simple ConstructorExecutor implementation that runs a constructor using reflective
invocation.
A constructor resolver that uses reflection to locate the constructor that should be invoked.
MethodExecutor that works via reflection.Helper class that allows for specifying a reflective method to invoke in a declarative
fashion, be it static or non-static.
Reflection-based
MethodResolver used by default in StandardEvaluationContext
unless explicit method resolvers have been specified.ParameterNameDiscoverer implementation which uses JDK 8's reflection facilities
for introspecting parameter names (based on the "-parameters" compiler flag).A powerful
PropertyAccessor that uses reflection to access properties
for reading and possibly also for writing on a target instance.An optimized form of a PropertyAccessor that will use reflection but only knows
how to access a particular property on a particular class.
A simple filter for matching a fully-qualified class name with a regex
Pattern.A class responsible for remapping types and names.
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.Strategy interface used to resolve
TypeVariables.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.Decoder for
Resources.This class implements the Wrapper or Decorator pattern.
Encoder for
Resources.Strategy interface for resolving a location pattern (for example, an
Ant-style path pattern) into Resource objects.
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.Contract for matching routes to patterns.
A parsed representation of a route.
Copy of the
@Scope annotation for testing purposes.Represents selection over a map or collection.
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.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.A
ClassVisitor that adds a serial version unique identifier to a class if missing.A
ListenableFuture whose value can be set via SettableListenableFuture.set(Object)
or SettableListenableFuture.setException(Throwable).Fast call bean's setter Method
MethodA parser for signature literals, as defined in the Java Virtual Machine Specification (JVMS), to
visit them with a SignatureVisitor.
A
SignatureVisitor that remaps types with a Remapper.A visitor to visit a generic signature.
A SignatureVisitor that generates signature literals, as defined in the Java Virtual Machine
Specification (JVMS).
TaskExecutor implementation that fires up a new Thread for each task,
executing it asynchronously.Parses a
String[] of command line arguments in order to populate a
CommandLineArgs object.CommandLinePropertySource implementation backed by a simple String array.A basic implementation of
EvaluationContext that focuses on a subset
of essential SpEL features and customization options, targeting simple
condition evaluation and in particular data binding scenarios.Builder for
SimpleEvaluationContext.A simple
IdGenerator that starts at 1, increments up to
Long.MAX_VALUE, and then rolls over.Simple implementation of the
LocaleContext interface,
always returning a specified Locale.Simple implementation of the
MetadataReaderFactory interface,
creating a new ASM ClassReader for every request.Simple
javax.xml.namespace.NamespaceContext implementation.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 implementation of the
TimeZoneAwareLocaleContext interface,
always returning a specified Locale and TimeZone.Simple
javax.xml.transform.ErrorListener implementation:
logs warnings using the given Commons Logging logger instance,
and rethrows errors to discontinue the XML transformation.An extended
BasicVerifier that performs more precise verifications.A
Supplier decorator that caches a singleton result and
makes it available from SingletonSupplier.get() (nullable) and SingletonSupplier.obtain() (null-safe).Bridge/route all JUL log records to the SLF4J API.
Interface to be implemented by a reloading-aware ClassLoader.
A List which is optimised for the sizes of 0 and 1,
in which cases it would not allocate array at all.
An
Interpreter for SourceValue values.A
Value which keeps track of the bytecode instructions that can produce it.A SpelCompiler will take a regular parsed expression and create (and load) a class
containing byte code that does the same thing as that expression.
Captures the possible configuration settings for a compiler that can be
used when evaluating expressions.
Root exception for Spring EL related exceptions.
A
SpelExpression represents a parsed (valid) expression that is ready to be
evaluated in a specified context.SpEL parser.
Contains all the messages that can be produced by the Spring Expression Language.
Message kinds.
Represents a node in the AST for a parsed expression.
The common supertype of all AST nodes in a parsed Spring Expression Language
format expression.
Root exception for Spring EL related exceptions.
Configuration object for the SpEL expression parser.
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. non-web)
applications.A powerful and highly configurable
EvaluationContext implementation.MethodMetadata implementation that uses standard reflection
to introspect a given Method.Standard implementation of
OperatorOverloader.A basic
TypeComparator implementation: supports comparison of
Number types as well as types implementing Comparable.Default implementation of the
TypeConverter interface,
delegating to a core ConversionService.A simple implementation of
TypeLocator that uses the context ClassLoader
(or any ClassLoader set upon it).A
ClassVisitor that merges <clinit> methods into a single one.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.Expression language AST node that represents a string literal.
This class implements a simple String->int mapping for a fixed set of keys.
Simple strategy interface for resolving a String value.
Success callback for a
ListenableFuture.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 code generator for switch statements.
A node that represents a TABLESWITCH instruction.
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 TaskExecutor for it.Exception thrown when a
TaskExecutor rejects to accept
a given task for execution.Exception thrown when a
AsyncTaskExecutor rejects to accept
a given task for execution because of the specified timeout.An expression parser that understands templates.
Configurable
ParserContext implementation for template parsing.Represents a ternary expression, for example: "someCheck()?
A
Printer that prints a disassembled view of the classes it visits.An
Attribute that can print a readable representation of itself.A throwable supplier is a functional interface which consists on a single get
function which is able to throw an exception.
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.Extension of
LocaleContext, adding awareness of the current time zone.today-framework Strategies
Strategy for resolving constructor arguments based on their type.
Strategy for handling a failure that occurs when instantiating a strategy.
Strategy for instantiate strategy.
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.An
AnnotationVisitor that prints the annotations it visits with a Printer.A
ClassVisitor that prints the classes it visits with a Printer.A
FieldVisitor that prints the fields it visits with a Printer.A
MethodVisitor that prints the methods it visits with a Printer.A
ModuleVisitor that prints the fields it visits with a Printer.A
RecordComponentVisitor that prints the record components it visits with a Printer.A
SignatureVisitor that builds the Java generic type declaration corresponding to the
signature it visits.Contains common behavior relating to
Transformers
and the javax.xml.transform package in general.A node that represents a try catch block.
A
MethodVisitor adapter to sort the exception handlers.A Java field or method type.
A node that represents a type annotation.
Captures primitive types and their corresponding class objects, plus one special entry
that represents all reference (non-primitive) types.
Instances of a type comparator should be able to compare pairs of objects for equality.
A type converter can convert values between different types encountered during
expression evaluation.
Contextual descriptor about a type to convert from or to.
Encapsulates an object and a
TypeDescriptor that describes it.Base interface for type filters using a
MetadataReader.A node that represents a type instruction.
Implementers of this interface are expected to be able to locate types.
The path to a type argument, wildcard bound, array element type, or static inner type within an
enclosing type.
A reference to a type appearing in a class, field or method declaration, or on an instruction.
The purpose of this class is to enable capturing and passing a generic
Type.Represents a reference to a type, for example
"T(String)" or "T(com.somewhere.Foo)".Utility to work with Java 5 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.Indicates that the annotated element uses an API from the
sun.misc
package.An immutable symbolic value for the semantic interpretation of bytecode.
Represents a reference to a value.
A ValueRef for the null value.
A ValueRef holder for a single value, which cannot be set.
Strategy that encapsulates value String styling algorithms
according to conventions.
Represents a variable reference, eg.
A node that represents a local variable instruction.
Class that exposes the version.
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.
Base class for YAML factories.
Strategy interface used to test if properties match.
Callback interface used to process the YAML parsing results.
Status returned from
YamlProcessor.DocumentMatcher.matches(java.util.Properties).Method to use for resolving resources.