All Classes and Interfaces
Class
Description
Abstract implementation of
JCacheOperationSource
that caches operations
for methods and implements a fallback policy: 1.Abstract JSR-107 specific
@Configuration
class providing common
structure for enabling JSR-107 annotation-driven cache management capability.Base class for CacheManager implementations that want to support built-in
awareness of Spring-managed transactions.
Implementation of the
JCacheOperationSource
interface that reads
the JSR-107 CacheResult
, CachePut
, CacheRemove
and
CacheRemoveAll
annotations.Advisor driven by a
JCacheOperationSource
, used to include a
cache advice bean for methods that are cacheable.Spring
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.Spring-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.A Spring
FactoryBean
for creating a Quartz CronTrigger
instance, supporting bean-style usage for trigger configuration.The default
JCacheOperationSource
implementation delegating
default operations to configurable services with sensible defaults
when not present.Factory that configures a FreeMarker
Configuration
.Factory bean that creates a FreeMarker
Configuration
and provides it
as a bean reference.Utility class for working with FreeMarker.
Editor for
java.mail.internet.InternetAddress
,
to directly populate an InternetAddress property.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 Spring
SimpleMailMessages
.Base class for JSR-107 caching aspects, such as the
JCacheInterceptor
or an AspectJ aspect.Cache
implementation on top of a
javax.cache.Cache
instance.CacheManager
implementation
backed by a JCache javax.cache.CacheManager
.Extension of
CachingConfigurer
for the JSR-107 implementation.Deprecated.
AOP Alliance MethodInterceptor for declarative cache
management using JSR-107 caching annotations.
FactoryBean
for a JCache javax.cache.CacheManager
,
obtaining a pre-defined CacheManager
by name through the standard
JCache javax.cache.Caching
class.Model the base of JSR-107 cache operation through an interface contract.
Interface used by
JCacheInterceptor
.A Spring
FactoryBean
for creating a Quartz JobDetail
instance, supporting bean-style usage for JobDetail configuration.Unchecked exception that wraps an exception thrown from a target method.
Subclass of Quartz's
JobStoreCMT
class that delegates to a Spring-managed
DataSource
instead of using a Quartz-managed JDBC connection pool.Quartz
ThreadPool
adapter that delegates to a Spring-managed
Executor
instance, specified on SchedulerFactoryBean
.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.
FactoryBean
that exposes a
JobDetail
object which delegates job execution to a
specified (static or non-static) method.Quartz Job implementation that invokes a specified method.
Extension of the MethodInvokingJob, implementing the StatefulJob interface.
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.
@Configuration
class that registers the Spring infrastructure beans necessary
to enable proxy-based annotation-driven JSR-107 cache management.Simple implementation of the Quartz Job interface, applying the
passed-in JobDataMap and also the SchedulerContext as bean property
values.
Wrapper that adapts from the Quartz
ClassLoadHelper
interface
onto Spring's ResourceLoader
interface.Common base class for accessing a Quartz Scheduler, i.e.
Spring bean-style class for accessing a Quartz Scheduler, i.e.
Callback interface to be implemented by Spring-managed
Quartz artifacts that need access to the SchedulerContext
(without having natural access to it).
FactoryBean
that creates and configures a Quartz Scheduler
,
manages its lifecycle as part of the Spring application context, and exposes the
Scheduler as bean reference for dependency injection.A simple
CacheResolver
that resolves the exception cache
based on a configurable CacheManager
and the name of the
cache: CacheResultOperation.getExceptionCacheName()
.Models a simple mail message, including data such as the from, to, cc, subject,
and text fields.
Subclass of Quartz's SimpleThreadPool that implements Spring's
TaskExecutor
interface
and listens to Spring lifecycle callbacks.A Spring
FactoryBean
for creating a Quartz SimpleTrigger
instance, supporting bean-style usage for trigger configuration.Subclass of
AdaptableJobFactory
that also supports Spring-style
dependency injection on bean properties.FreeMarker
TemplateLoader
adapter that loads template files via a
Spring ResourceLoader
.Cache decorator which synchronizes its
TransactionAwareCacheDecorator.put(java.lang.Object, java.lang.Object)
, TransactionAwareCacheDecorator.evict(java.lang.Object)
and
TransactionAwareCacheDecorator.clear()
operations with Spring-managed transactions (through Spring's
TransactionSynchronizationManager
), performing the actual cache
put/evict/clear operation only in the after-commit phase of a successful
transaction.Proxy for a target
CacheManager
, exposing transaction-aware Cache
objects
which synchronize their Cache.put(java.lang.Object, java.lang.Object)
operations with Spring-managed transactions
(through Spring's TransactionSynchronizationManager
),
performing the actual cache put operation only in the after-commit phase of a successful transaction.
JCacheConfigurer
directly