All Classes and Interfaces
类
说明
Abstract implementation of the
ApplicationContext
interface.Abstract implementation of the
ApplicationEventMulticaster interface,
providing the basic listener registration facility.Abstract base
Configuration class providing common structure for enabling
asynchronous method execution capability.Abstract base class for
BindHandler implementations.Abstract implementation of the
BindingResult interface and
its super-interface Errors.A base component for invoking
Cache operations and using a
configurable CacheErrorHandler when an exception occurs.Abstract base class implementing the common
CacheManager methods.A base
CacheResolver implementation that requires the concrete
implementation to provide the collection of cache name(s) based on the
invocation context.Abstract base
@Configuration class providing common structure
for enabling Framework's annotation-driven cache management capability.Base class for MBeanInfoAssemblers that support configurable
JMX notification behavior.
Abstract implementation of the
Errors interface.Abstract implementation of
CacheOperation that caches attributes
for methods and implements a fallback policy: 1. specific target method;
2. target class; 3. declaring method; 4. declaring class/interface.Base class for all JMX metadata classes.
Abstract implementation of the
MBeanInfoAssembler interface
that encapsulates the creation of a ModelMBeanInfo instance
but delegates the creation of metadata to subclasses.Abstract implementation of the
HierarchicalMessageSource interface,
implementing common handling of message variants, making it easy
to implement a specific strategy for a concrete MessageSource.Abstract base class for nested conditions.
Abstract formatter for Numbers,
providing a
AbstractNumberFormatter.getNumberFormat(Locale) template method.Abstract base class for
BindingResult implementations that work with
Framework's PropertyAccessor mechanism.Builds on the
AbstractMBeanInfoAssembler superclass to
add a basic algorithm for building metadata based on the
reflective metadata of the MBean class.Base class for
ApplicationContext
implementations which are supposed to support multiple calls to AbstractApplicationContext.refresh(),
creating a new internal bean factory instance every time.AbstractRefreshableApplicationContext subclass that adds common handling
of specified config locations.Abstract base class for
MessageSource implementations based on
resource bundle conventions, such as ResourceBundleMessageSource
and ReloadableResourceBundleMessageSource.Common base class for
Cache implementations that need to adapt
null values (and potentially other such special values) before
passing them on to the underlying store.Convenient base class for
ApplicationContext
implementations, drawing configuration from XML documents containing bean definitions
understood by an XmlBeanDefinitionReader.Enumeration used to determine whether JDK proxy-based or
AspectJ weaving-based advice should be applied.
Convenient base class for
ImportSelector implementations that select imports
based on an AdviceMode value from an annotation (such as the @Enable*
annotations).Condition that will match when all nested class conditions match.Convenient adapter for programmatic registration of bean classes.
Represent an
AnnotatedElement on a particular Class
and is suitable as a key.Specialization of
AsyncExecutionInterceptor that
delegates method execution to an Executor based
on the Async annotation.BeanNameGenerator implementation for bean classes annotated with the
@Component annotation or
with another annotation that is itself annotated with @Component as a
meta-annotation.Implementation of the
CacheOperationSource interface for working with caching metadata in annotation format.Callback interface providing
CacheOperation instance(s) based on
a given CacheAnnotationParser.Standalone application context, accepting component classes as input —
in particular
@Configuration-annotated classes, but also plain
@Component types and JSR-330 compliant
classes using jakarta.inject annotations.Parser for the <context:annotation-config/> element.
Common interface for annotation config application contexts,
defining
AnnotationConfigRegistry.register(Class[]) and AnnotationConfigRegistry.scan(String...) methods.Utility class that allows for convenient registration of common
BeanPostProcessor and
BeanFactoryPostProcessor
definitions for annotation-based configuration.Parser for the 'annotation-driven' element of the 'task' namespace.
A factory that creates formatters to format values of fields annotated with a particular
Annotation.Implementation of the
JmxAttributeSource interface that
reads annotations and exposes the corresponding attributes.Convenient subclass of Framework's standard
MBeanExporter,
activating Java 5 annotation usage for JMX exposure of Framework beans:
ManagedResource, ManagedAttribute, ManagedOperation, etc.A
ScopeMetadataResolver implementation that by default checks for
the presence of Framework's @Scope annotation on the bean class.Condition that will match when any nested class condition matches.Central interface to provide configuration for an application.
Interface to be implemented by any object that wishes to be notified
of the
ApplicationContext that it runs in.Base class for events raised for an
ApplicationContext.Exception thrown during application context initialization.
Callback interface for initializing a
ConfigurableApplicationContext
prior to being refreshed.Convenient superclass for application objects that want to be aware of
the application context, e.g. for custom lookup of collaborating beans
or for context-specific resource access.
A specialization of
FormattingConversionService configured by default with
converters and formatters appropriate for most applications.Class to be extended by all application events.
Interface to be implemented by objects that can manage a number of
ApplicationListener objects and publish events to them.Interface that encapsulates event publication functionality.
Interface to be implemented by any object that wishes to be notified
of the ApplicationEventPublisher (typically the ApplicationContext)
that it runs in.
Interface to be implemented by application event listeners.
GenericApplicationListener adapter that delegates the processing of
an event to an EventListener annotated method.Post-processor that registers AspectJ's
ClassPreProcessorAgentAdapter
with the Framework application context's default
LoadTimeWeaver.Annotation that marks a method as a candidate for asynchronous execution.
Advisor that activates asynchronous method execution through the
Async
annotation.Bean post-processor that automatically applies asynchronous invocation
behavior to any bean that carries the
Async annotation at class or
method-level by adding a corresponding AsyncAnnotationAdvisor to the
exposed proxy (either an existing AOP proxy or a newly generated proxy that
implements all of the target's interfaces).Selects which implementation of
AbstractAsyncConfiguration should
be used based on the value of EnableAsync.mode() on the importing
@Configuration class.Interface to be implemented by @
Configuration classes annotated with @EnableAsync that wish to customize the
Executor instance used when processing async method invocations or the
AsyncUncaughtExceptionHandler instance used to process exception thrown from
async method with void return type.A convenience
AsyncConfigurer that implements all methods
so that the defaults are used.A pass-through
Future handle that can be used for method signatures
which are declared with a Future return type for asynchronous execution.Indicates that a class provides configuration that can be automatically applied by
Framework Unify.
A
TypeFilter implementation that matches registered auto-configuration classes.Event fired when auto-configuration classes are imported.
Filter that can be registered in
today-strategies.properties to limit the
auto-configuration classes considered.Listener that can be registered with
today-strategies.properties to receive details of
imported auto-configurations.DeferredImportSelector to handle auto-configuration.Provides access to meta-data written by the auto-configure annotation processor.
Registers packages with
AutoConfigurationPackages.Class for storing auto-configuration packages for reference later (e.g. by JPA entity
scanner).
Configurations representing auto-configuration @Configuration classes.Hint for that an
auto-configuration should be applied
after other specified auto-configuration classes.Hint that an
auto-configuration should be applied
before other specified auto-configuration classes.Auto-configuration specific variant of Framework's
@Order
annotation.Extends the
MBeanInfoAssembler to add autodetection logic.Registers an auto proxy creator against the current
BeanDefinitionRegistry
as appropriate based on an @Enable* annotation having mode and
proxyTargetClass attributes set to the correct values.The base interface that all cache operations must implement.
Indicates that a method produces a bean to be managed by the container.
load bean definitions
scanning BeanDefinition loading strategy
EL property accessor that knows how to traverse the beans and contextual objects
of a
BeanExpressionContext.EL property accessor that knows how to traverse the beans of a
BeanFactory.Advisor driven by a
CacheOperationSource, used to include a
cache advice bean for methods that are cacheable.EL bean resolver that operates against a
BeanFactory.Default implementation of the
Errors and BindingResult
interfaces, for the registration and evaluation of binding errors on
JavaBean objects.Simple
InitializationBeanPostProcessor that checks JSR-303 constraint annotations
in Framework-managed beans, throwing an initialization exception in case of
constraint violations right before calling the bean's init method (if any).Source that can be bound by a
Binder.Restrictions that can be applied when binding values.
Strategy interface used to determine a specific constructor to use when binding.
Context information for use by
BindHandlers.A container object which Binds objects from one or more
ConfigurationPropertySources.Exception thrown when binding fails.
Thrown when binding errors are considered fatal.
Callback interface that can be used to handle additional logic during element
binding.Strategy for processing
DataBinder's missing field errors,
and for translating a PropertyAccessException to a
FieldError.General interface that represents binding results.
Convenience methods for looking up BindingResults in a model Map.
A container object to return the result of a
Binder bind operation.Error thrown when validation fails during a bind operation.
Startup(Refresh) Context
Bean to record and provide bound
@ConfigurationProperties.BindHandler that can be used to track bound configuration properties.BeanShell-based implementation of Framework's
ScriptEvaluator strategy interface.ScriptFactory implementation
for a BeanShell script.Utility methods for handling BeanShell-scripted objects.
Exception to be thrown on script execution failure.
Interface that defines common cache operations.
Wrapper exception to be thrown from
Cache.get(Object, Callable)
in case of the value loader callback failing with an exception.A (wrapper) object representing a cache value.
Annotation indicating that the result of invoking a method (or all methods
in a class) can be cached.
Class describing a cache 'cacheable' operation.
A builder that can be used to create a
CacheableOperation.Strategy interface for parsing known caching annotation types.
Base class for caching aspects, such as the
CacheInterceptor or an
AspectJ aspect.Metadata of a cache operation that does not depend on a particular invocation
which makes it a good candidate for caching.
@CacheConfig provides a mechanism for sharing common cache-related
settings at the class level.Shared utility class used to evaluate and cache EL expressions that
are defined on
AnnotatedElement.An expression key.
A strategy for handling cache-related errors.
Annotation indicating that a method (or all methods on a class) triggers a
cache evict operation.Class describing a cache 'evict' operation.
A builder that can be used to create a
CacheEvictOperation.AOP Alliance MethodInterceptor for declarative cache
management using the common Framework caching infrastructure
(
Cache).Configuration constants for internal sharing across subpackages.
Framework's central cache manager SPI.
NamespaceHandler allowing for the configuration of declarative
cache management using either XML or using annotations.Base class for cache operations.
Base class for builders that can be used to create a
CacheOperation.Representation of the context of the invocation of a cache operation.
Abstract the invocation of a cache operation.
Wrap any exception thrown while invoking
CacheOperationInvoker.invoke().Interface used by
CacheInterceptor.Proxy factory bean for simplified declarative caching handling.
Annotation indicating that a method (or all methods on a class) triggers a
cache put operation.Class describing a cache 'put' operation.
A builder that can be used to create a
CachePutOperation.Determine the
Cache instance(s) to use for an intercepted method invocation.Group annotation for multiple cache annotations (of different or the same type).
Selects which implementation of
AbstractCachingConfiguration should
be used based on the value of EnableCaching.mode() on the importing
@Configuration class.Interface to be implemented by @
Configuration classes annotated with @EnableCaching that wish or need to
specify explicitly how caches are resolved and how keys are generated for annotation-driven
cache management.Framework
Cache adapter implementation
on top of a Caffeine Cache instance.CacheManager implementation that lazily builds CaffeineCache
instances for each CaffeineCacheManager.getCache(java.lang.String) request.Provide access to the candidates that are defined in
META-INF/today.components.Candidate components index loading mechanism for internal use within the framework.
A bean definition scanner that detects bean candidates on the classpath,
registering corresponding bean definitions with a given registry (
BeanFactory
or ApplicationContext).A component provider that provides candidate components from a base package.
A component provider that provides components from a base package.
Standalone XML application context, taking the context definition files
from the class path, interpreting plain paths as class path resource names
that include the package path (e.g.
BeanPostProcessor implementation
that supports common Java annotations out of the box, in particular the common
annotations in the jakarta.annotation package.Class representing generic injection information about an annotated field
or setter method, supporting @Resource and related annotations.
This annotation indicates that an annotated element is a bean component in
your application
Configures component scanning directives for use with @
Configuration classes.Declares the type filter to be used as an include filter or exclude filter.
Parser for the
<context:component-scan/> element.Container annotation that aggregates several
ComponentScan annotations.Composite
CacheManager implementation that iterates over
a given collection of delegate CacheManager instances.Composite
CacheOperationSource implementation that iterates
over a given array of CacheOperationSource instances.Simple
Cache implementation based on the
core JDK java.util.concurrent package.FactoryBean for easy configuration of a ConcurrentMapCache
when used within a Framework container.CacheManager implementation that lazily builds ConcurrentMapCache
instances for each ConcurrentMapCacheManager.getCache(java.lang.String) request.Implementation of the
Model interface based on a ConcurrentHashMap
for use in concurrent scenarios.Adapter that takes a
java.util.concurrent.Executor and exposes
a Framework TaskExecutor for it.Delegate that wraps a given Runnable/Callable with a JSR-236 ManagedTask,
exposing a long-running hint based on
SchedulingAwareRunnable
and a given identity name.Adapter that takes a
java.util.concurrent.ScheduledExecutorService and
exposes a Framework TaskScheduler for it.A single
condition that must be matched in order
for a component to be registered.Indicates that a component is only eligible for registration when all
specified conditions match.
@Conditional that only matches when beans meeting all the specified
requirements are already contained in the BeanFactory.@Conditional that only matches when the specified classes are on
the classpath.annotation for a conditional element that depends on the value of a Java
Unified Expression Language
@Conditional that matches based on the JVM version the application
is running on.Range options.
@Conditional that matches based on the availability of a JNDI
InitialContext and the ability to lookup specific locations.@Conditional that only matches when no beans meeting the specified
requirements are already contained in the BeanFactory.Conditional that only matches when the specified classes are not on
the classpath.@Conditional that checks if the specified properties have a
specific value.Conditional that only matches when the specified resources are exits@Conditional that only matches when a bean of the specified class
is already contained in the BeanFactory and a single candidate can be
determined.for ConditionEvaluator Evaluation
Records condition evaluation details for reporting and logging.
Provides access to a single
Condition and ConditionOutcome.Provides access to a number of
ConditionEvaluationReport.ConditionAndOutcome items.A condition evaluation report message that can logged or printed.
Condition Evaluation
A message associated with a
ConditionOutcome.Render styles.
Outcome for a condition match, including log message.
SPI interface to be implemented by most if not all application contexts.
Framework-configurable
FileTypeMap implementation that will read
MIME type to file extension mappings from a standard JavaMail MIME type
mapping file, using a standard MimetypesFileTypeMap underneath.Indicates that a class declares one or more
@Component methods and
may be processed by the container to generate bean definitions and
service requests for those beans at runtime, for example:BeanFactoryPostProcessor used for bootstrapping processing of
@Configuration classes.A
Condition that offers more fine-grained control when used with
@Configuration.The various configuration phases where the condition could be evaluated.
Annotation for externalized configuration.
Provides access to
@ConfigurationProperties bean
details, regardless of if the annotation was used directly or on a @Bean
factory method.The binding method that is used for the bean.
BindConstructorProvider used when binding
@ConfigurationProperties.Exception thrown when
@ConfigurationProperties binding
fails.Allows additional functionality to be applied to the
BindHandler used by the
ConfigurationPropertiesBindingPostProcessor.Qualifier for beans that are needed to configure the binding of
@ConfigurationProperties (e.g.Configures the base packages used when scanning for
@ConfigurationProperties classes.A single configuration property obtained from a
ConfigurationPropertySource
consisting of a name, value and optional
origin.Interface that can be used to control configuration property source caches.
A configuration property name composed of elements separated by dots.
The various forms that a non-indexed element value can take.
Maintains a mapping of
ConfigurationPropertyName aliases.A source of
ConfigurationProperties.Provides access to
ConfigurationPropertySources.The state of content from a
ConfigurationPropertySource.A set of
@Configuration classes that can be registered in
ApplicationContext.FactoryBean that creates a JSR-160 JMXConnectorServer,
optionally registers it with the MBeanServer, and then starts it.Annotation that can be used to indicate which constructor to use when binding
configuration properties using constructor arguments rather than by calling setters.
Complete implementation of the
AutowireCandidateResolver strategy
interface, providing support for qualifier annotations as well as for lazy resolution
driven by the Lazy annotation in the context.annotation package.When close
ApplicationContext will publish this eventBase of all
Condition implementations used with Framework.JSR-303
ConstraintValidatorFactory implementation that delegates to a
Framework BeanFactory for creating autowired ConstraintValidator instances.ScheduledTaskRegistrar subclass which redirects the actual scheduling
of tasks to the ContextLifecycleScheduledTaskRegistrar.afterSingletonsInstantiated() callbackNamespaceHandler
for the 'context' namespace.Event raised when an
ApplicationContext gets initialized or refreshed.Event raised when an
ApplicationContext gets started.Event raised when an
ApplicationContext gets stopped.ApplicationContext Utils
Indicates that an annotated class is a "Controller" (e.g. a web controller).
A factory providing convenient access to a ConversionService configured with
converters appropriate for most environments.
Representation of a
crontab expression
that can calculate the next time it matches.
TriggerTask implementation defining a Runnable to be executed according
to a standard cron expression.Trigger implementation for cron expressions.A BigDecimal formatter for number values in currency style.
Formatter for JSR-354
CurrencyUnit values,
from and to currency code Strings.Implementation of the
ThreadFactory interface,
allowing for customizing the created threads (name, priority, etc).Configurable bean class that exposes a specific JSR-303 Validator
through its original interface as well as through the Framework
Validator interface.Binder that allows for setting property values on a target object, including
support for validation and binding result analysis.
Internal utility to help when dealing with data object property names.
Annotation that can be used to change the default unit used when converting a
DataSize.A formatter for
Date types.Configures basic date formatting for use with Framework, primarily for
DateTimeFormat declarations.A context that holds user-specific
java.time (JSR-310) settings
such as the user's Chronology (calendar system) and time zone.A holder for a thread-local user
DateTimeContext.Declares that a field or method parameter should be formatted as a date or time.
Common ISO date time format patterns.
Formats fields annotated with the
DateTimeFormat annotation using a DateFormatter.Factory that creates a JSR-310
DateTimeFormatter.FactoryBean that creates a JSR-310 DateTimeFormatter.Configures the JSR-310
java.time formatting system for use with Framework.Default
BindingErrorProcessor implementation.Strategy implementation for parsing Framework's
Caching, Cacheable,
CacheEvict, and CachePut annotations.Default
LoadTimeWeaver bean for use in an application context,
decorating an automatically detected internal LoadTimeWeaver.Default
EventListenerFactory implementation that supports the
regular EventListener annotation.A specialization of
FormattingConversionService configured by default with
converters and formatters appropriate for most applications.Default implementation of the
LifecycleProcessor strategy.JNDI-based variant of
CustomizableThreadFactory, performing a default lookup
for JSR-236's "java:comp/DefaultManagedThreadFactory" in a Jakarta EE environment,
falling back to the local CustomizableThreadFactory setup if not found.JNDI-based variant of
ConcurrentTaskExecutor, performing a default lookup for
JSR-236's "java:comp/DefaultManagedExecutorService" in a Jakarta EE/8 environment.JNDI-based variant of
ConcurrentTaskScheduler, performing a default lookup for
JSR-236's "java:comp/DefaultManagedScheduledExecutorService" in a Jakarta EE environment.Default implementation of the
MessageCodesResolver interface.Common message code formats.
Framework's default implementation of the
MessageSourceResolvable interface.Annotation that can be used to specify the default value when binding to an immutable
property.
A variation of
ImportSelector that runs after all @Configuration beans
have been processed.Interface used to group results from different import selectors.
An entry that holds the
AnnotationMetadata of the importing
Configuration class and the class name to import.Runnable wrapper that catches any exception or error thrown from its
delegate Runnable and allows an
ErrorHandler to handle it.Empty
MessageSource that delegates all calls to the parent MessageSource.Declares a field or method parameter should be converted to collection using the
specified delimiter.
Beans on which the current bean depends.
Indicates that a getter in a
@ConfigurationProperties
object is deprecated.Interface that can be implemented by
ImportSelector and
ImportBeanDefinitionRegistrar implementations when they can determine imports
early.Special implementation of the Errors and BindingResult interfaces,
supporting registration and evaluation of binding errors on value objects.
Annotation that can be used to indicate the format to use when converting a
Duration.Duration format styles.
Units that we support.
Annotation that can be used to change the default unit used when converting a
Duration.Convenient base class for components with a need for embedded value resolution
(i.e.
Interface to be implemented by any object that wishes to be notified of a
StringValueResolver for the resolution of embedded definition values.Enables support for handling components marked with AspectJ's
@Aspect annotation,
similar to functionality found in Framework's <aop:aspectj-autoproxy> XML element.Enables asynchronous method execution capability, similar to functionality
found in
<task:*> XML namespace.Enable auto-configuration of the Application Context, attempting to guess and
configure beans that you are likely to need.
Enables Framework's annotation-driven cache management capability, similar to the
support found in Framework's
<cache:*> XML namespace.Enable support for
@ConfigurationProperties annotated
beans.Activates a Framework
LoadTimeWeaver for this application context, available as
a bean with the name "loadTimeWeaver", similar to the <context:load-time-weaver>
element in Framework XML.AspectJ weaving enablement options.
Enables default exporting of all standard
MBeans from the Framework context, as
well as well all @ManagedResource annotated beans.Enables scheduled task execution capability, similar to
functionality found in
<task:*> XML namespace.Read-only EL property accessor that knows how to retrieve keys
of a
Environment instance.Interface to be implemented by any bean that wishes to be notified
of the
Environment that it runs in.Stores and exposes information about data-binding and validation
errors for a specific object.
Annotation that marks a method as a listener for application events.
Strategy interface for creating
ApplicationListener for methods
annotated with EventListener.Process @EventListener annotated on a method
Interceptor that publishes an
ApplicationEvent to all ApplicationListeners
registered with an ApplicationEventPublisher after each
successful method invocation.Parser for the 'executor' element of the 'task' namespace.
Base class for setting up a
ExecutorService
(typically a ThreadPoolExecutor or
ScheduledThreadPoolExecutor).Encapsulates a field error, that is, a reason for rejecting a specific
field value.
Standalone XML application context, taking the context definition files
from the file system or from URLs, interpreting plain paths as relative
file system locations (e.g.
Custom
MethodValidationPostProcessor that applies
exclusion filters.Abstract base class for a
ContextCondition that also implements
AutoConfigurationImportFilter.Enumeration of the type filters that may be used in conjunction with
@ComponentScan.Specialization of
IntervalTask for fixed-delay semantics.Specialization of
IntervalTask for fixed-rate semantics.A Framework
FactoryBean that builds and exposes a preconfigured ForkJoinPool.Formats objects of type T.
Adapter that bridges between
Formatter and PropertyEditor.Registers
Converters and Formatters with
a FormattingConversionService through the FormatterRegistry SPI.A registry of field formatting logic.
A
ConversionService implementation
designed to be configured as a FormatterRegistry.A factory providing convenient access to a
FormattingConversionService
configured with converters and formatters for common types such as numbers and
datetimes.An extension of
AnnotationBeanNameGenerator that uses the fully qualified
class name as the default bean name if an explicit bean name is not supplied via
a supported type-level annotation such as @Component (see
AnnotationBeanNameGenerator for details on supported annotations).Generic ApplicationContext implementation that holds a single internal
StandardBeanFactory
instance and does not assume a specific bean definition format.Extended variant of the standard
ApplicationListener interface,
exposing further metadata such as the supported event and source type.GenericApplicationListener adapter that determines supported event types
through introspecting the generically declared type of the target listener.Convenient application context with built-in XML support.
Strategy used by
GroovyScriptFactory to allow the customization of
a created GroovyObject.Groovy-based implementation of Framework's
ScriptEvaluator strategy interface.ScriptFactory implementation
for a Groovy script.Sub-interface of MessageSource to be implemented by objects that
can resolve messages hierarchically.
An implementation of the
ObjectNamingStrategy interface that
creates a name based on the identity of a given instance.BindHandler that can be used to ignore binding errors.BindHandler that can be used to ignore top-level
ConverterNotFoundExceptions.Indicates one or more component classes to import — typically
@Configuration classes.Import and apply the specified auto-configuration classes.
Variant of
AutoConfigurationImportSelector for
@ImportAutoConfiguration.Interface to be implemented by any @
Configuration class that wishes
to be injected with the BeanDefinition of the @Configuration
class that imported it.Interface to be implemented by types that register additional bean definitions when
processing @
Configuration classes.Contains
@Configuration import candidates, usually auto-configurations.Indicates one or more resources containing bean definitions to import.
Interface to be implemented by types that determine which @
Configuration
class(es) should be imported based on a given selection criteria, usually one or
more annotation attributes.Exception thrown when the application has configured an incompatible set of
ConfigurationProperties keys.Indicate that the annotated element represents a stereotype for the index.
Adapter that takes a JSR-303
javax.validator.Validator and
exposes it as a Framework Validator
while also exposing the original JSR-303 Validator interface itself.Formatter implementation for a JSR-310 Instant,
following JSR-310's parsing rules for an Instant (that is, not using a
configurable DateTimeFormatter): accepting the
default ISO_INSTANT format as well as RFC_1123_DATE_TIME
(which is commonly used for HTTP date header values)LoadTimeWeaver relying on VM Instrumentation.Subclass of
AbstractReflectiveMBeanInfoAssembler that allows for
the management interface of a bean to be defined using arbitrary interfaces.Editor for
java.mail.internet.InternetAddress,
to directly populate an InternetAddress property.Task implementation defining a Runnable to be executed at a given
millisecond interval which may be treated as fixed-rate or fixed-delay depending on
context.Exception thrown when
ConfigurationPropertyName has invalid characters.Exception thrown when a configuration property value is invalid.
Thrown when trying to invoke an operation on a proxy that is not exposed
by the proxied MBean resource's management interface.
Thrown by the
JmxAttributeSource when it encounters
incorrect metadata on a managed resource or one of its methods.Thrown when an invocation on an MBean resource failed with an exception (either
a reflection exception or an exception thrown by the target method itself).
A
ConfigurationPropertySource with a fully Iterable set of entries.Extended
MailSender interface for JavaMail,
supporting MIME messages both as direct arguments and through preparation
callbacks.Production implementation of the
JavaMailSender interface,
supporting both JavaMail MimeMessages and Framework
SimpleMailMessages.NamespaceHandler
for the 'jee' namespace.Interface used by the
MetadataMBeanInfoAssembler to
read source-level metadata from a managed resource's class.General base exception to be thrown on JMX errors.
Utility methods for converting Framework JMX metadata into their plain JMX equivalents.
Collection of generic utility methods to support Framework JMX.
Convenient superclass for JNDI accessors, providing "jndiTemplate"
and "jndiEnvironment" bean properties.
Callback interface to be implemented by classes that need to perform an
operation (such as a lookup) in a JNDI context.
JndiLocatorSupport subclass with public lookup methods,
for convenient use as a delegate.Convenient superclass for classes that can locate any number of JNDI objects.
RuntimeException to be thrown in case of JNDI lookup failures,
in particular from code that does not declare JNDI's checked
NamingException: for example, from
JndiObjectTargetSource.FactoryBean that looks up a
JNDI object.Convenient superclass for JNDI-based service locators,
providing configurable lookup of a specific JNDI resource.
AOP
TargetSource that provides
configurable JNDI lookups for getTarget() calls.PropertySource implementation that reads properties from an underlying Framework
JndiLocatorDelegate.Helper class that simplifies JNDI operations.
Formats fields annotated with the
DateTimeFormat annotation using the
JSR-310 java.time package in JDK 8.Simple
ScopeMetadataResolver implementation that follows JSR-330 scoping rules:
defaulting to prototype scope unless Singleton is present.Formats
MonetaryAmount fields annotated
with Framework's common NumberFormat annotation.Cache key generator.
ObjectNamingStrategy implementation that builds
ObjectName instances from the key used in the
"beans" map passed to MBeanExporter.NamespaceHandler that supports the wiring of
objects backed by dynamic languages such as Groovy, JRuby and
BeanShell.Utilities for use with
LangNamespaceHandler.Indicates whether a bean is to be lazily initialized.
A common interface defining methods for start/stop lifecycle control.
Strategy interface for processing Lifecycle beans within the ApplicationContext.
Defines the contract for adding one or more
ClassFileTransformers to a ClassLoader.Interface to be implemented by any object that wishes to be notified
of the application context's default
LoadTimeWeaver.BeanPostProcessor
implementation that passes the context's default LoadTimeWeaver
to beans that implement the LoadTimeWeaverAware interface.@Configuration class that registers a LoadTimeWeaver bean.Interface to be implemented by
@Configuration
classes annotated with @EnableLoadTimeWeaving that wish to
customize the LoadTimeWeaver instance to be used.Delegates to a target
MessageInterpolator implementation but enforces Framework's
managed Locale.This is the central class for
jakarta.validation (JSR-303) setup in a Framework
application context: It bootstraps a jakarta.validation.ValidationFactory and
exposes it through the Framework Validator interface
as well as through the JSR-303 Validator interface and the
ValidatorFactory interface itself.A
CacheErrorHandler implementation that logs error message.Exception thrown on failed authentication.
Base class for all mail exceptions.
This is a common interface for mail messages, allowing a user to set key
values required in assembling a mail message, without needing to know if
the underlying message is a simple text message or a more sophisticated
MIME message.
Exception thrown if illegal message properties are encountered.
Exception to be thrown by user code if a mail cannot be prepared properly,
for example when a FreeMarker template cannot be rendered for the mail text.
This interface defines a strategy for sending simple mails.
Exception thrown when a mail sending error is encountered.
Method-level annotation that indicates to expose a given bean property as a
JMX attribute, corresponding to the
ManagedAttribute.Metadata that indicates to expose a given bean property as JMX attribute.
Method-level annotation that indicates to expose a given bean property as a
JMX attribute, with added descriptor properties to indicate that it is a metric.
Metadata that indicates to expose a given bean property as a JMX attribute,
with additional descriptor properties that indicate that the attribute is a
metric.
Type-level annotation that indicates a JMX notification emitted by a bean.
Metadata that indicates a JMX notification emitted by a bean.
Type-level annotation that indicates JMX notifications emitted by a bean,
containing multiple
ManagedNotifications.Method-level annotation that indicates to expose a given method as a
JMX operation, corresponding to the
ManagedOperation attribute.Metadata that indicates to expose a given method as JMX operation.
Method-level annotation used to provide metadata about operation parameters,
corresponding to a
ManagedOperationParameter attribute.Metadata about JMX operation parameters.
Method-level annotation used to provide metadata about operation parameters,
corresponding to an array of
ManagedOperationParameter attributes.Class-level annotation that indicates to register instances of a class
with a JMX server, corresponding to the
ManagedResource attribute.Metadata indicating that instances of an annotated class
are to be registered with a JMX server.
EL property accessor that knows how to traverse the keys
of a standard
Map.Map-based implementation of the BindingResult interface,
supporting registration and evaluation of binding errors on
Map attributes.
A
ConfigurationPropertySource backed by a Map and using standard name
mapping rules.MethodInterceptor that routes calls to an
MBean running on the supplied MBeanServerConnection.Thrown when an invocation failed because of an I/O problem on the
MBeanServerConnection.
@Configuration class that registers a AnnotationMBeanExporter bean.JMX exporter that allows for exposing any Framework-managed bean to a
JMX
MBeanServer, without the need to define any
JMX-specific information in the bean classes.A listener that allows application code to be notified when an MBean is
registered and unregistered via an
MBeanExporter.Exception thrown in case of failure when exporting an MBean.
Interface that defines the set of MBean export operations that are intended to be
accessed by application developers during application runtime.
Interface to be implemented by all classes that can
create management interface metadata for a managed resource.
Thrown if an exception is encountered when trying to retrieve
MBean metadata.
Creates a proxy to a managed resource running either locally or remotely.
Provides supporting infrastructure for registering MBeans with an
MBeanServer.FactoryBean that creates a JMX 1.2 MBeanServerConnection
to a remote MBeanServer exposed via a JMXServerConnector.FactoryBean that obtains a MBeanServer reference
through the standard JMX 1.2 MBeanServerFactory
API.Exception thrown when we cannot locate an instance of an
MBeanServer,
or when more than one instance is found.A strategy interface for formatting message codes.
Strategy interface for building message codes from validation error codes.
Supplier that can be used to create a MessageInterpolator.Strategy interface for resolving messages, with support for the parameterization
and internationalization of such messages.
Helper class for easy access to messages from a MessageSource,
providing various overloaded getMessage methods.
Interface to be implemented by any object that wishes to be notified
of the MessageSource (typically the ApplicationContext) that it runs in.
Interface for objects that are suitable for message resolution in a
MessageSource.Helper class that allows for accessing a Framework
MessageSource as a ResourceBundle.Implementation of Hibernate Validator 4.3/5.x's
ResourceBundleLocator interface,
exposing a Framework MessageSource as localized MessageSourceResourceBundle.Base class for message source implementations, providing support infrastructure
such as
MessageFormat handling but not implementing concrete
methods defined in the MessageSource.Implementation of the
MBeanInfoAssembler interface that reads
the management interface information from source level metadata.An implementation of the
ObjectNamingStrategy interface
that reads the ObjectName from the source-level metadata.MetadataReader Consumer
A method-based
EvaluationContext that
provides explicit support for method-based invocations.AbstractReflectiveMBeanInfoAssembler subclass that allows
method names to be explicitly excluded as MBean operations and attributes.Adapter that implements the
Runnable interface as a configurable
method invocation based on Framework's MethodInvoker.Subclass of
AbstractReflectiveMBeanInfoAssembler that allows
to specify method names to be exposed as MBean operations and attributes.A filter for excluding types from method validation.
An AOP Alliance
MethodInterceptor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods.A convenient
BeanPostProcessor implementation that delegates to a
JSR-303 provider for performing method-level validation on annotated methods.Represents how the measurement values of a
ManagedMetric will change over time.Implementation of the MailMessage interface for a JavaMail MIME message,
to let message population code interact with a simple message or a MIME
message through a common interface.
Helper class for populating a
MimeMessage.Callback interface for the preparation of JavaMail MIME messages.
Context will create a bean definition when current context were missing
Context will create a bean definition when current context were missing
Model that defines a holder for model attributes.
Implementation of
Map for use when building model data for use
with UI tools.NotificationPublisher implementation that uses the infrastructure
provided by the ModelMBean interface to track
javax.management.NotificationListeners
and send Notifications to those listeners.Formatter for JSR-354
MonetaryAmount values,
delegating to MonetaryAmountFormat.format(javax.money.MonetaryAmount)
and MonetaryAmountFormat.parse(java.lang.CharSequence).Exception thrown when more than one mutually exclusive configuration property has been
configured.
Annotation that can be used to specify the name when binding to an immutable property.
A
CacheResolver that forces the resolution to a configurable
collection of name(s) against a given CacheManager.Simple
CacheOperationSource implementation that allows attributes to be matched
by registered name.Indicates that a field in a
@ConfigurationProperties
object should be treated as if it were a nested type.Never match Condition
Condition that will match when none of the nested class conditions match.A no operation
Cache implementation suitable for disabling caching.A basic, no operation
CacheManager implementation suitable
for disabling caching, typically used for backing cache declarations
without an actual backing store.Exception thrown when a message can't be resolved.
Helper class that aggregates a
NotificationListener,
a NotificationFilter, and an arbitrary handback object.Helper class that aggregates a
NotificationListener,
a NotificationFilter, and an arbitrary handback
object, as well as the names of MBeans from which the listener wishes
to receive Notifications.Registrar object that associates a specific
NotificationListener
with one or more MBeans in an MBeanServer
(typically via a MBeanServerConnection).Simple interface allowing Framework-managed MBeans to publish JMX notifications
without being aware of how those notifications are being transmitted to the
MBeanServer.Interface to be implemented by any Framework-managed resource that is to be
registered with an
MBeanServer and wishes to send
JMX javax.management.Notifications.BindHandler to enforce that all configuration properties under the root name
have been bound.Declares that a field or method parameter should be formatted as a number.
Common number format styles.
Formats fields annotated with the
NumberFormat annotation.A general-purpose number formatter using NumberFormat's number style.
Encapsulates an object error, that is, a global reason for rejecting
an object.
Helper class for the creation of
ObjectName instances.Strategy interface that encapsulates the creation of
ObjectName instances.Condition that checks if a property whose value is a list is defined in the
environment.LocalValidatorFactoryBean subclass that simply turns
Validator calls into no-ops
in case of no Bean Validation provider being available.Interface that uniquely represents the origin of an item.
An interface that may be implemented by an object that can lookup
Origin
information from a given key.Interface to provide access to the origin of an item.
Variant of
OriginTrackedResource for WritableResource instances.Parses text strings to produce instances of T.
An
ApplicationEvent that carries an arbitrary payload.A formatter for number values in percent style.
Annotation that can be used to indicate the format to use when converting a
Period.A trigger for periodic task execution.
A standard set of
Period units.Annotation that can be used to change the default unit used when converting a
Period.Interface for objects that may participate in a phased
process such as lifecycle management.
Optional strategy that used by a
Binder to resolve property placeholders.Indicates that a bean should be given preference when multiple candidates
are qualified to autowire a single-valued dependency.
Prints objects of type T for display.
Indicates that a component is eligible for registration when one or more
specified profiles are active.
Annotation providing a convenient and declarative mechanism for adding a
PropertySource to
Environment.Origin from a PropertySource.Container annotation that aggregates several
PropertySource annotations.Specialization of
PlaceholderConfigurerSupport that resolves ${...} placeholders
within bean definition property values and @Value annotations against the current
Framework Environment and its set of PropertySources.PlaceholdersResolver to resolve placeholders from PropertySources.Annotation for externalized configuration.
@Configuration class that registers the Framework infrastructure beans necessary
to enable proxy-based asynchronous method execution.@Configuration class that registers the Framework infrastructure beans necessary
to enable proxy-based annotation-driven cache management.LoadTimeWeaver which uses reflection to delegate to an underlying ClassLoader
with well-known transformation hooks.Subclass of
BeanFactoryRefreshableTargetSource that determines whether
a refresh is required through the given ScriptFactory.Indicates registration behavior when attempting to register an MBean that already
exists.
Framework-specific
MessageSource implementation
that accesses resource bundles using specified basenames, participating in the
Framework ApplicationContext's resource loading.MessageSource implementation that
accesses resource bundles using specified basenames.ContextCondition used to check if a resource can be found using a
configurable property and optional default location(s).Interface to be implemented by any object that wishes to be notified of the
ResourceLoader (typically the ApplicationContext) that it runs in.Subclass of ShadowingClassLoader that overrides attempts to
locate certain files.
ScriptSource implementation
based on Framework's Resource
abstraction.Indicates the 'role' hint for a given bean.
Extension of the
BeanDefinition class, based on an ASM ClassReader,
with support for annotation metadata exposed through the
AnnotatedBeanDefinition interface.Annotation that marks a method to be scheduled.
Bean post-processor that registers methods annotated with
@Scheduled to be invoked by a
TaskScheduler according to the
"fixedRate", "fixedDelay", or "cron" expression provided via the annotation.FactoryBean that sets up
a ScheduledExecutorService
(by default: a ScheduledThreadPoolExecutor)
and exposes it for bean references.JavaBean that describes a scheduled executor task, consisting of the
Runnable and a delay plus period.Variant of
MethodInvokingRunnable meant to be used for processing
of no-arg scheduled methods.A representation of a scheduled task at runtime,
used as a return value for scheduling methods.
Common interface for exposing locally scheduled tasks.
Helper bean for registering tasks with a
TaskScheduler, typically using cron
expressions.Parser for the 'scheduled-tasks' element of the scheduling namespace.
Parser for the 'scheduler' element of the 'task' namespace.
Container annotation that aggregates several
Scheduled annotations.Extension of the
Runnable interface, adding special callbacks
for long-running operations.@Configuration class that registers a ScheduledAnnotationBeanPostProcessor
bean capable of processing @Scheduled annotation.Optional interface to be implemented by
@Configuration classes annotated
with @EnableScheduling.General exception to be thrown on scheduling failures,
such as the scheduler already having shut down.
A
TaskExecutor extension exposing
scheduling characteristics that are relevant to potential task submitters.When used as a type-level annotation in conjunction with
@Component,
@Scope indicates the name of a scope to use for instances of
the annotated type.Enumerates the various scoped-proxy options.
Describes scope characteristics
Strategy interface for resolving the scope of bean definitions.
Exception to be thrown on script compilation failure.
Framework's strategy interface for evaluating a script.
Script definition interface, encapsulating the configuration
of a specific script as well as a factory method for
creating the actual scripted Java
Object.BeanPostProcessor that
handles ScriptFactory definitions,
replacing each factory with the actual scripted Java object generated by it.Interface that defines the source of a script.
Some named search strategies for beans in the bean factory hierarchy.
Interface that allows infrastructure components to provide their own
ObjectNames to the MBeanExporter.Indicates that an annotated class is a "Service"
ClassLoader decorator that shadows an enclosing ClassLoader,
applying registered transformers to all affected classes.
Simple implementation of the
ApplicationEventMulticaster interface.A simple
CacheErrorHandler that does not handle the
exception at all, simply throwing it back at the client.Simple cache manager working against a given collection of caches.
A simple
CacheResolver that resolves the Cache instance(s)
based on a configurable CacheManager and the name of the
cache(s) as provided by getCacheNames().Simplistic implementation of an instrumentable
ClassLoader.Simple JNDI-based implementation of Framework's
BeanFactory interface.A simple key as returned from the
SimpleKeyGenerator.Simple key generator.
LoadTimeWeaver that builds and exposes a
SimpleInstrumentableClassLoader.Models a simple mail message, including data such as the from, to, cc, subject,
and text fields.
Simple subclass of
AbstractReflectiveMBeanInfoAssembler
that always votes yes for method and property inclusion, effectively exposing
all public methods and properties as operations and attributes.A simple thread-backed
Scope implementation.ClassLoader that can be used to load classes without bringing them
into the parent loader.
Simple data holder implementation of the
TriggerContext interface.Straightforward implementation of
Cache.ValueWrapper,
simply holding the value as given at construction and returning it from SimpleValueWrapper.get().Extended variant of the standard
ApplicationListener interface,
exposing further metadata such as the supported event and source type.An extension of the
Lifecycle interface for those objects that require
to be started upon ApplicationContext refresh and/or shutdown in a
particular order.Extended variant of the
Validator interface, adding support for
validation 'hints'.ApplicationListener decorator that filters
events from a specified event source, invoking its delegate listener for
matching ApplicationEvent objects only.Extension of the
RequiredModelMBean class that ensures the
thread context ClassLoader is switched
for the managed resource's ClassLoader before any invocations occur.Standard
ApplicationContext
like Spring's AnnotationConfigApplicationContextStandard implementation of the
BeanExpressionResolver interface,
parsing and evaluating EL using cn.taketoday.expression module.Exception decorating a
ScriptException coming out of
JSR-223 script evaluation, i.e. a ScriptEngine.eval(java.lang.String, javax.script.ScriptContext)
call or Invocable.invokeMethod(java.lang.Object, java.lang.String, java.lang.Object...) /
Invocable.invokeFunction(java.lang.String, java.lang.Object...) call.javax.script (JSR-223) based implementation of Framework's ScriptEvaluator
strategy interface.ScriptFactory implementation based
on the JSR-223 script engine abstraction (as included in Java 6+).Common operations for dealing with a JSR-223
ScriptEngine.ApplicationContext implementation
which supports programmatic registration of beans and messages,
rather than reading bean definitions from external configuration sources.Simple implementation of
MessageSource
which allows messages to be registered programmatically.Static implementation of the
ScriptSource interface,
encapsulating a given String that contains the script source text.Origin for an item loaded from the system environment.Holder class defining a
Runnable to be executed as a task, typically at a
scheduled time or interval.Builder that can be used to configure and create a
TaskExecutor.Callback interface that can be used to customize a
ThreadPoolTaskExecutor.FactoryBean for creating ThreadPoolTaskExecutor instances,
primarily used behind the XML task namespace.Configuration constants for internal sharing across subpackages.
NamespaceHandler for the 'task' namespace.Task scheduler interface that abstracts the scheduling of
Runnables based on different kinds of triggers.Builder that can be used to configure and create a
TaskScheduler.Callback interface that can be used to customize a
ThreadPoolTaskScheduler.Utility methods for decorating tasks with error handling.
Parser implementation for a JSR-310 TemporalAccessor,
using a DateTimeFormatter (the contextual one, if available).Printer implementation for a JSR-310 TemporalAccessor,
using a DateTimeFormatter) (the contextual one, if available).Origin for an item loaded from a text resource.A location (line and column number) within the resource.
JavaBean that allows for configuring a
ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds",
"queueCapacity" properties) and exposing it as a bean reference of its native
ExecutorService type.JavaBean that allows for configuring a
ThreadPoolExecutor
in bean style (through its "corePoolSize", "maxPoolSize", "keepAliveSeconds", "queueCapacity"
properties) and exposing it as a Framework TaskExecutor.Implementation of
TaskScheduler interface, wrapping
a native ScheduledThreadPoolExecutor.LoadTimeWeaver implementation
for Tomcat's new org.apache.tomcat.InstrumentableClassLoader.Common interface for trigger objects that determine the next execution time
of a task that they get associated with.
Context object encapsulating last execution times and last completion time
of a given task.
Provides exclusion
TypeFilters that are loaded from the
BeanFactory and automatically applied to SpringBootApplication
scanning.Collection of utilities for working with
@ComponentScan
type filters.Exception thrown if a type mismatch is encountered for an object
located in a JNDI environment.
Exception thrown when we are unable to register an MBean,
for example because of a naming conflict.
Thrown when a JMX
Notification is unable to be sent.BindException thrown when ConfigurationPropertySource elements were
left unbound.Function used to determine if a
ConfigurationPropertySource should be included
when determining unbound elements.Configurations representing user-defined @Configuration classes (i.e.Variant of JSR-303's
Valid, supporting the
specification of validation groups.Utility class for handling validation annotations.
BindHandler to apply Validators to bound results.A collection of
ObjectErrors caused by bind validation failures.Utility class offering convenient methods for invoking a
Validator
and for rejecting empty fields.A validator for application-specific objects.
ClassFileTransformer-based weaver, allowing for a list of transformers to be
applied on a class byte array.