All Classes and Interfaces
类
说明
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.A
ConditionalConverter base implementation for enum-based converters.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
ListenableFuture implementation which does not allow for cancellation.A node that represents a bytecode instruction.
Abstract base class for
MergedAnnotation implementations.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.Abstract base class for SAX
ContentHandler and LexicalHandler
implementations that use StAX as a basis.Abstract base class for SAX
XMLReader implementations that use StAX as a basis.Implementation of the
Locator interface based on a given StAX Location.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.Abstract base class for
XMLEventReaders.Abstract base class for SAX
XMLReader implementations.Abstract base class for
XMLStreamReaders.Determine the access control of a
Member or type signature.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.KeyManagerFactory that allows a configurable key alias to be used.KeyManagerFactorySpi that allows a configurable key alias to be used.X509ExtendedKeyManager that allows a configurable key alias to be used.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.Adapted
AnnotatedElement that hold specific annotations.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.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.Callback interface used to process annotations.
Scanner to search for relevant annotations in the annotation hierarchy of an
AnnotatedElement.A simple
TypeFilter which matches classes with a given annotation,
checking inherited annotations as well.Provides mapping information for a single annotation (or meta-annotation) in
the context of a root annotation type.
Provides
AnnotationTypeMapping information for a single source
annotation type.Cache created per
AnnotationFilter.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).
Internal holder used to wrap default values.
A visitor to visit a Java annotation.
An
AnnotationVisitor that generates a corresponding 'annotation' or 'type_annotation'
structure, as defined in the Java Virtual Machine Specification (JVMS).AnsiElement implementation for ANSI 8-bit foreground or background color codes.Ansi background colors.Ansi colors.Utility for working with
AnsiColor in the context of AWT Colors.Bit depths supported by this class.
Represents a color stored in LAB form.
An ANSI encodable element.
Generates ANSI encoded output, automatically attempting to detect if the terminal
supports ANSI.
Possible values to pass to
AnsiOutput.setEnabled(cn.taketoday.core.ansi.AnsiOutput.Enabled).AnsiPropertySource.Mapping for AnsiElement enums.Mapping between a name and the pseudo property source.
Ansi styles.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).Value class that holds information about the pattern, e.g. number of
occurrences of "*", "**", and "{" pattern elements.
A simple cache for patterns that depend on the configured path separator.
Utility for determining if AOT-processed optimizations must be used rather
than the regular runtime.
Provides access to the application home directory.
Provides access to an application specific temporary directory.
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.
Converts an array to another array.
Converts an array to a Collection.
Converts an array to an Object by returning the first array element
after converting it to the desired target type.
Converts an array to a comma-delimited String.
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 support for Callable.A non standard class, field, method or Code attribute, as defined in the Java Virtual Machine
Specification (JVMS).
A set of attribute prototypes (attributes with the same type are considered equal).
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.Provides a quick way to access the attribute methods of an
Annotation
with consistent ordering as well as a few useful utility 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.Very basic json writer for the purposes of translating runtime hints to native
configuration.
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.Register the necessary reflection hints so that the specified type can be
bound at runtime.
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.Converts a
ByteBuffer directly to and from byte[] ByteBuffer directly to and from byte[]s and indirectly
to any type that the ConversionService support via byte[].Decoder for
ByteBuffers.Encoder for
ByteBuffers.Helper class for invoking
ClassLoader.defineClass(String, byte[], int, int).A ChildClassLoader will load the generated compiled classes.
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.Converts from a Character to any JDK-standard Number implementation.
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.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.An
Analyzer subclass which checks that methods provide stack map frames where expected
(i.e. at jump target and after instructions without immediate successor), and that these stack
map frames are valid (for the provided interpreter; they may still be invalid for the JVM, if the
Interpreter uses a simplified type system compared to the JVM verifier).A
MethodVisitor that checks that its methods are properly used.The 'generic' instruction visit methods (i.e. those that take an opcode argument).
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.The possible states of the automaton used to check the order of method calls.
Exception that indicates an incompatible class format encountered
in a class file during metadata reading.
Utilities for core hint inference on Infra-managed classes,
specifically for proxy types such as interface-based JDK proxies
and CGLIB-generated subclasses which need proxy/reflection hints.
Strategy interface for instantiate given implementation.
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.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.ClassPathResource that explicitly expresses a context-relative path
through implementing the ContextResource interface.
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.
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.Converts a Collection to an array.
Converts from a Collection to another Collection.
Converts a Collection to an Object by returning the first collection element after converting it to the desired targetType.
Converts a Collection to a comma-delimited String.
A simple representation of command line arguments, broken into "option arguments" and
"non-option arguments".
Abstract base class for
PropertySource implementations backed by command line
arguments.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.
A skeletal
ListenableFuture implementation which represents
a ListenableFuture which has been completed already.Composite iterator that combines multiple other iterators,
as registered via
CompositeIterator.add(Iterator).Implementation of
Logger that wraps a list of loggers and delegates
to the first one for which logging is enabled at the given level.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.
Composite
TaskDecorator that delegates to other task decorators.Represents a DOT separated expression sequence, such as
property1.property2.methodOne() or
property1?.property2?.methodOne() when the null-safe navigation
operator is used.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.
Draining status for the read/write buffers.
Caching implementation of the
MetadataReaderFactory interface backed by a
ConcurrentReferenceHashMap, caching MetadataReader per Framework
Resource handle (i.e. per ".class" file).Allows a task access to
ConcurrentReferenceHashMap.Segment entries.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.
Internal
ConcurrentReferenceHashMap.Reference implementation for SoftReferences.Various options supported by a
Task.Internal
ConcurrentReferenceHashMap.Reference implementation for WeakReferences.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.
Defines additional JVM opcodes, access flags and constants which are not part of the ASM public
API.
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.A
ConstructorExecutor is built by a ConstructorResolver 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 to locate a constructor and returns a
ConstructorExecutor that can be used to invoke that constructor.Information about a class being parsed in a
ClassReader.TaskDecorator that wrap the execution of
tasks, assisting with context propagation.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.
Internal utilities for the conversion package.
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.Adapts a
ConversionService and targetType to a Converter.Adapter that exposes a
PropertyEditor for any given
ConversionService and specific target type.Information about the input stack map frame at the "current" instruction of a method.
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.
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.An
InputStream that reads from a DataBuffer.Exception that indicates the cumulative number of bytes consumed from a
stream of
DataBuffer's exceeded some pre-configured limit.An
OutputStream that writes to a DataBuffer.Utility class for working with
DataBuffers.Base class for a
DataBufferUtils.NestedMatcher.Matcher that supports searching for multiple delimiters.
Implementation of
DataBufferUtils.Matcher that uses the Knuth-Morris-Pratt algorithm.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.Matcher that can be nested within
DataBufferUtils.CompositeMatcher where multiple
matchers advance together using the same index, one byte at a time.Matcher for a single byte delimiter.
Matcher with a 2 byte delimiter that does not benefit from a
Knuth-Morris-Pratt suffix-prefix table.
Provides a convenient implementation of the
DataBuffer interface
that can be overridden to adapt the delegate.A data size, such as '12MB'.
Static nested class to support lazy loading of the
DataSize.DataSizeUtils.PATTERN.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.
A callback interface for a decorator to be applied to any
TSimple 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.Default SettableFuture
Default
GenerationContext implementation.Default
MethodReference implementation based on a MethodSpec.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 ProgressiveFuture
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
SslBundleRegistry implementation.Default implementation of
SslManagerBundle.Default
toString() styler.Converts objects to String form, generally for debugging purposes,
using default
toString styling conventions.define class strategy
Extension of
CompletableFuture which allows for cancelling
a delegate along with the CompletableFuture itself.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.SAX
ContentHandler that transforms callback calls to DOM Nodes.Convenience methods for working with the DOM API,
in particular for working with DOM Nodes and DOM Elements.
An edge in the control flow graph of a method.
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.
The idea of the class is to cache relevant java.lang.reflect instances so
proxy-class can be instantiated faster that when using
ReflectionUtils.newInstance(Class, Class[], Object[]) and
Enhancer.setThreadCallbacks(Class, Callback[])Enumerable for
EnumA
PropertySource implementation capable of interrogating its
underlying source object to enumerate all possible property name/value
pairs.Calls
Enum.ordinal() to convert a source Enum to a Integer.Calls
Enum.name() to convert a source Enum to a String.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.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
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.
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.
A new scope is entered when a function is called and it is used to hold the
parameters to the function call.
Common utility functions that may be used by any Expression Language provider.
All enhanced instances returned by the
Enhancer class implement this
interface.The
CompleteFuture which is failed already.Failure callback for a
ListenableFuture.Simply calls
Object.toString() to convert any supported object
to a String.A speedy alternative to
ByteArrayOutputStream.An implementation of
InputStream that reads from a given
FastByteArrayOutputStream.A hint that describes the need for reflection on a
Field.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.
A
FieldVisitor that generates a corresponding 'field_info' structure, as defined in the
Java Virtual Machine Specification (JVMS).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).FileSystemResource that explicitly expresses a context-relative path
through implementing the ContextResource interface.
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.
Utility methods (formatters etc) used during parsing and evaluation.
The input and output stack map frames of a basic block.
A symbolic execution stack frame.
A node that represents a stack map frame.
A function reference is of the form "#someFunction(a,b,c)".
Listens to the result of a
ListenableFuture.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.
A
MethodVisitor with convenient methods to generate code.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.Key for use with the converter cache.
Manages all converters registered with the service.
Manages converters registered with a specific
GenericConverter.ConvertiblePair.Internal converter that performs no operation.
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.
Information about an exception handler.
Constants and convenience methods for working with hints.
An 'identifier'
SpelNode.Contract for generating universally unique identifiers (
UUIDs).Converts an entity identifier to a entity reference by calling a static finder method
on the target entity type.
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.
GeneratedFiles implementation that keeps generated files in-memory.A node that represents an inner class.
Resource implementation for a given InputStream.Simple interface for objects that are sources for an
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.
Supplier that provides a class type.A
MethodVisitor providing a more detailed API to generate and transform instructions.Converts from a Integer to a
Enum by calling Class.getEnumConstants().Generates new interfaces at runtime.
Wraps a real parse exception.
Hand-written SpEL parser.
A semantic bytecode interpreter.
A node that represents an instruction with a single int operand.
Expression language AST node that represents an integer literal.
Log facade used to handle annotation introspection failures (in particular
TypeNotPresentExceptions).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 extensionA hint that describes the need for Java serialization at runtime.
Builder for
JavaSerializationHint.Known Java versions.
An
IdGenerator that calls UUID.randomUUID().A hint that describes the need for a JDK interface-based
Proxy.Builder for
JdkProxyHint.SslStoreBundle backed by a Java keystore.Details for an individual trust or key store in a
JksSslStoreBundle.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.
A filter that can be used to restrict when a callback is used.
LambdaSafe.Filter that matches when the callback has a single generic and primary
argument is an instance of it.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.RunnableFuture
Common superclass for nodes representing literals (boolean, string, number, etc).
A very simple hardcoded implementation of the Expression interface that represents a
string literal.
PemSslStore loaded from PemSslStoreDetails.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.Helper class that inspects all methods and constructors and then
attempts to find the parameter names for the given
Executable.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 (MessageFormatter.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.Converts a Map to another Map.
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.Predicate implementation used for
MergedAnnotationPredicates.firstRunOf(Function).Predicate implementation used for
MergedAnnotationPredicates.unique(Function).AnnotationVisitor that can be used to construct a
MergedAnnotation.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.MergedAnnotations implementation backed by a Collection of
MergedAnnotation instances that represent direct annotations.Strategy interface used to select between two
MergedAnnotation
instances.MergedAnnotationSelector implementations that provide various options
for MergedAnnotation instances.MergedAnnotationSelector to select the first directly declared
annotation.MergedAnnotationSelector to select the nearest annotation.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
MethodInvoker PropertyAccessor implementation
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
A
MethodExecutor is built by a MethodResolver 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 camel-case method name that can be built from distinct parts.
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.MethodParameter subclass which detects field annotations as well.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.
Expression language AST node that represents a method reference.
Strategy for generating code for arguments based on their type.
A
MethodVisitor that remaps types with a Remapper.A method resolver attempts to locate a method and returns a
MethodExecutor 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.
A
MethodVisitor that generates a corresponding 'method_info' structure, as defined in the
Java Virtual Machine Specification (JVMS).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.An
AbstractMergedAnnotation used as the implementation of
MergedAnnotation.missing().Exception thrown when required properties are not found.
Mixin allows multiple objects to be combined into a single
larger object.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.
Resource implementation for Module resolution,
performing ModuleResource.getInputStream() access via Module.getResourceAsStream(java.lang.String).A ModuleTarget attribute.
A visitor to visit a Java module.
A
ModuleVisitor that generates the corresponding Module, ModulePackages and
ModuleMainClass attributes, as defined in the Java Virtual Machine Specification (JVMS).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.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.Handy class for wrapping
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.Netty5DataBuffer.BufferComponentIterator<T extends io.netty5.buffer.BufferComponent & io.netty5.buffer.ComponentIterator.Next>
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.Exception indicating that an
SslBundle was referenced with a name that does not
match any registered bundle.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.Converts from any JDK-standard Number implementation to a Character.
Converts from any JDK-standard Number implementation to any other JDK-standard Number implementation.
Miscellaneous utility methods for number conversion and parsing.
Converts an Object to a single-element array containing the Object.
Converts an Object to a single-element Collection containing the Object.
Generic converter that uses conventions to convert a source object to a
targetType by delegating to a method on the source object or to
a static factory method or constructor on the targetType.RuntimeHintsRegistrar to register hints for popular conventions in
cn.taketoday.core.conversion.support.ObjectToObjectConverter.Convert an Object to
java.util.Optional<T> if necessary using the
ConversionService to convert the source Object to the generic type
of Optional when known.Simply calls
Object.toString() to convert a source Object to a String.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.
Bridges between
OutputStream and
Publisher<DataBuffer>.ClassLoader that does not always delegate to the parent loader
as normal class loaders do.AnnotationFilter implementation used for
AnnotationFilter.packages(String...).Represents a generic pair of two values.
For the efficient sorting of multiple arrays in parallel.
The purpose of this class is to enable capturing and passing a generic
Type.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
PatternResourceLoader 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.Parser for X.509 certificates in PEM format.
Utility to load PEM content.
Parser for PKCS private key files in PEM format.
An ASN.1 DER encoded element.
Simple ASN.1 DER encoder.
ANS.1 encoded object identifier.
Parser for a specific PEM format.
Decryptor for PKCS8 encoded private keys.
An individual trust or key store that has been loaded from PEM content.
SslStoreBundle backed by PEM-encoded certificates and private keys.Details for an individual trust or key store in a
PemSslStoreBundle.Parser for Strings that have placeholder values in them.
A
PlaceholderParser.Part implementation that represents a single placeholder
containing nested placeholders.A representation of the parsing of an input string.
A part is a section of a String containing placeholders to replace.
Provide the necessary context to handle and resolve underlying placeholders.
A
PlaceholderParser.Part implementation that represents a single placeholder with
a hard-coded fallback.A
PlaceholderParser.Part implementation that does not contain a valid placeholder.Thrown when the resolution of placeholder failed.
Strategy interface used to resolve replacement values for placeholders contained in Strings.
Extension of
DataBuffer that allows for buffers that share
a memory pool.GraalVM
Feature that substitutes boolean field values that match a certain pattern
with values pre-computed AOT without causing class build-time initialization.An abstract converter from visit events to text.
Profile predicate that may be accepted by an
Environment.Internal parser used by
Profiles.of(java.lang.String...).A
SettableFuture which is used to indicate the progress of an operation.Listens to the result of a
ProgressiveFuture.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.Converts from a Properties to a String by calling
Properties.store(java.io.OutputStream, String).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.
Supplier that will catch and ignore any
NullPointerException.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.
Abstract base class representing a source of name/value property pairs.
A
PropertySource implementation intended for collection comparison
purposes.PropertySource to be used as a placeholder in cases where an actual
property source cannot be eagerly initialized at application context
creation time.Describe 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.Write
JdkProxyHints contained in a ProxyHints to the JSON
output expected by the GraalVM native-image compiler, typically named
proxy-config.json.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, etc.BlockHoundIntegration for core classes.ReactiveAdapter variant that wraps adapted Publishers as
Flux or
Mono depending on ReactiveTypeDescriptor.isMultiValue().A common delegate for detecting Reactive presence AND its features
Describes the semantics of a reactive type including boolean checks for
ReactiveTypeDescriptor.isMultiValue(), ReactiveTypeDescriptor.isNoValue(), and ReactiveTypeDescriptor.supportsEmpty().read-only PropertyAccessor
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.
An instance of ArgumentsMatchInfo describes what kind of match was achieved
between two sets of arguments - the set that a method/constructor is expecting
and the set that are being supplied at the point of invocation.
Arguments match kinds.
Gather the need for reflection at runtime.
Generator of
ReflectionHints predicates, testing whether the given hints
match the expected behavior for reflection.Write
ReflectionHints to the JSON output expected by the GraalVM
native-image compiler, typically named reflect-config.json
or jni-config.json.A
TypeReference based on a Class.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.
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.
java reflect
Method implementationMethodExecutor 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).Process an
AnnotatedElement and register the necessary reflection
hints for it.A powerful
PropertyAccessor that uses reflection to access properties
for reading and possibly also for writing on a target instance.java reflect
Field implementationCaptures the member (method/field) to call reflectively to access a property value
and the type descriptor for the value returned by the reflective call.
An optimized form of a PropertyAccessor that will use reflection but only knows
how to access a particular property on a particular class.
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).A class responsible for remapping types and names.
Strategy used to determine annotations that act as containers for other
annotations.
A single explicit mapping.
Standard
RepeatableContainers implementation that searches using
Java's @Repeatable annotation.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.Internal
Type used to represent an empty value.Strategy interface used to resolve
TypeVariables.Internal helper to handle bounds from
WildcardTypes.The various kinds of bounds.
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.Resource Consumer
Decoder for
Resources.This class implements the Wrapper or Decorator pattern.
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.Write a
ResourceHints to the JSON output expected by the GraalVM
native-image compiler, typically named resource-config.json.Strategy interface for resolving a location pattern (for example, an
Ant-style path pattern) into Resource objects.
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.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.
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.Represents selection over a map or collection.
Internal utility class that can be used to obtain wrapped
Serializable
variants of java.lang.reflect.Types.SerializableTypeWrapper.TypeProvider for Types obtained by invoking a no-arg method.Additional interface implemented by the type proxy.
A
Serializable interface providing access to a Type.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.Write a
SerializationHints to the JSON output expected by the
GraalVM native-image compiler, typically named
serialization-config.json.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.Special
ListenableFuture which is writable.A SettableFuture combiner monitors the outcome of a number of discrete
futures, then notifies a final, aggregate SettableFuture when all of the
combined futures are finished.
FutureListener implementation which takes other SettableFutures
and notifies them on completion.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).
AnnotationMetadata created from a
SimpleAnnotationMetadataReadingVisitor.ASM class visitor that creates
SimpleAnnotationMetadata.MergedAnnotation source.TaskExecutor implementation that fires up a new Thread for each task,
executing it asynchronously.Subclass of the general ConcurrencyThrottleSupport class,
making
beforeAccess() and afterAccess()
visible to the surrounding class.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.MetadataReader implementation based on an ASM
ClassReader.Simple implementation of the
MetadataReaderFactory interface,
creating a new ASM ClassReader for every request.MethodMetadata created from a SimpleMethodMetadataReadingVisitor.ASM method visitor that creates
SimpleMethodMetadata.MergedAnnotation source.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 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.A
TypeReference based on fully qualified name.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.
An immutable set of at most two elements, optimized for speed compared to a generic set
implementation.
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.
Reentrant lock that can be used in a try-with-resources statement.
A reentrant lock with a condition that can be used in a try-with-resources statement.
Specialization of
Properties that sorts properties alphanumerically
based on their keys.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 SpEL 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.
A bundle of trust material that can be used to establish an SSL connection.
A reference to a single key obtained via
SslBundle.Interface that can be used to register an
SslBundle for a given name.A managed set of
SslBundle instances that can be retrieved by name.A bundle of key and trust managers that can be used to establish an SSL connection.
Configuration options that should be applied when establishing an SSL connection.
A bundle of key and trust stores that can be used to establish an SSL connection.
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.SAX
XMLReader that reads from a StAX XMLEventReader.Implementation of the
Result tagging interface for StAX writers.Implementation of the
Source tagging interface for StAX readers.SAX
XMLReader that reads from a StAX XMLStreamReader.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.Converts a
Stream to and from a collection or array, converting the
element type if necessary.Stream Iterable
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.
Converts a comma-delimited String to an Array.
Converts String to a Boolean.
Converts a String to a Character.
Convert a String to a
Charset.Converts a comma-delimited String to a Collection.
Convert a String to a
Currency.Converts from a String to a
Enum by calling Enum.valueOf(Class, String).Converts from a String to a
Locale.Converts from a String any JDK-standard Number implementation.
Converts from a String to a
Pattern.Converts a String to a Properties by calling Properties#load(java.io.InputStream).
Convert a String to a
TimeZone.Converts from a String to a
UUID.Miscellaneous
String utility methods.Simple strategy interface for resolving a String value.
A method subroutine (corresponds to a JSR instruction).
The
CompleteFuture which is succeeded already.Success callback for a
ListenableFuture.Convenience utilities for
Supplier handling.An entry of the constant pool, of the BootstrapMethods attribute, or of the (ASM specific) type
table of a class.
The constant pool entries, the BootstrapMethods attribute entries and the (ASM specific) type
table entries of a class.
An entry of a SymbolTable.
TaskExecutor implementation that executes each task synchronously
in the calling thread.InvocationHandler for an Annotation that has
synthesized (i.e. wrapped in a dynamic proxy) with additional
functionality such as attribute alias handling.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.
PlaceholderResolver implementation that resolves against system properties
and system environment variables.
A code generator for switch statements.
A node that represents a TABLESWITCH instruction.
Allow to reference
com.sun.beans.finder.ClassFinder from
Target_Introspector.Introspector substitution with a refined findCustomizerClass implementation
designed to avoid thousands of AWT classes to be included in the native image.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.
This captures a type of bracket and the position in which it occurs in the
expression.
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.
ClassLoader used to load classes without causing build-time
initialization.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.RuntimeHintsRegistrar to register hints for TodayStrategies.today-framework Strategies
Strategy for resolving constructor arguments based on their type.
Internal instantiator used to create the strategy instance.
Strategy for handling a failure that occurs when instantiating a strategy.
RuntimeHintsRegistrar to register hints for infra.factories.Holder for a kind of token, the associated data and its position in the input data
stream (start/end).
Lex some input data into a stream of tokens that can then be parsed.
Token Kinds.
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.Represents a triad of values
There is no meaning attached to values in this class, it can be used for any purpose.
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.
Adapter class for exposing a
TypeDescriptor's annotations as an
AnnotatedElement, in particular to AnnotatedElementUtils.Encapsulates an object and a
TypeDescriptor that describes it.Base interface for type filters using a
MetadataReader.A hint that describes the need for reflection on a type.
Builder for
TypeHint.A node that represents a type instruction.
Implementers of this interface are expected to be able to locate types.
MergedAnnotation that adapts attributes from a root annotation by
applying the mapping and mirroring rules of an AnnotationTypeMapping.MergedAnnotations implementation that searches for and adapts
annotations and meta-annotations using AnnotationTypeMappings.AnnotationsProcessor used to detect if an annotation is directly
present or meta-present.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.
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.An annotation which marks a
Collection or Map type
as unmodifiable.Unmodifiable wrapper for
MultiValueMap.Thrown when a
ValueCodeGenerator could not generate the code for a
given value.Resource implementation for java.net.URL locators.Utility methods to convert an array of primitive or object values to a mutable ArrayList, not
baked by the array (unlike
Arrays.asList(T...)).An immutable symbolic value for the semantic interpretation of bytecode.
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.ValueCodeGenerator.Delegate for array types.ValueCodeGenerator.Delegate for Charset types.ValueCodeGenerator.Delegate for Class types.Abstract
ValueCodeGenerator.Delegate for Collection types.ValueCodeGenerator.Delegate for Enum types.ValueCodeGenerator.Delegate for List types.ValueCodeGenerator.Delegate for Map types.ValueCodeGenerator.Delegate for primitive types.ValueCodeGenerator.Delegate for ResolvableType types.ValueCodeGenerator.Delegate for Set types.ValueCodeGenerator.Delegate for String types.Strategy API for extracting a value for an annotation attribute from a given
source object which is typically an
Annotation, Map, or
TypeMappedAnnotation.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 — for example,
#someVar.A node that represents a local variable instruction.
Class that exposes the version.
Extracts version information for a Class.
Internal delegate for virtual thread handling on JDK 21.
A
TaskExecutor implementation based on virtual threads in JDK 21+.A member or type annotated with VisibleForTesting claims that its visibility is higher than necessary,
only for testing purposes.
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.
Implementation of the
XMLStreamReader interface that wraps a
XMLEventReader.Implementation of the
XMLStreamWriter interface
that wraps an XMLEventWriter.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.
Simple converter from Java 8's
ZonedDateTime to Calendar.