# All Classes and Interfaces

Class
Description
AbstractFallbackJCacheOperationSource
Abstract implementation of `JCacheOperationSource` that caches operations for methods and implements a fallback policy: 1.
AbstractJCacheConfiguration
Abstract JSR-107 specific `@Configuration` class providing common structure for enabling JSR-107 annotation-driven cache management capability.
AbstractTransactionSupportingCacheManager
Base class for CacheManager implementations that want to support built-in awareness of Spring-managed transactions.
AdaptableJobFactory
`JobFactory` implementation that supports `Runnable` objects as well as standard Quartz `Job` instances.
AnnotationJCacheOperationSource
Implementation of the `JCacheOperationSource` interface that reads the JSR-107 `CacheResult`, `CachePut`, `CacheRemove` and `CacheRemoveAll` annotations.
BeanFactoryJCacheOperationSourceAdvisor
Advisor driven by a `JCacheOperationSource`, used to include a cache advice bean for methods that are cacheable.
CaffeineCache
Spring `Cache` adapter implementation on top of a Caffeine `Cache` instance.
CaffeineCacheManager
`CacheManager` implementation that lazily builds `CaffeineCache` instances for each `CaffeineCacheManager.getCache(java.lang.String)` request.
ConfigurableMimeFileTypeMap
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.
CronTriggerFactoryBean
A Spring `FactoryBean` for creating a Quartz `CronTrigger` instance, supporting bean-style usage for trigger configuration.
DefaultJCacheOperationSource
The default `JCacheOperationSource` implementation delegating default operations to configurable services with sensible defaults when not present.
DelegatingJob
Simple Quartz `Job` adapter that delegates to a given `Runnable` instance.
FreeMarkerConfigurationFactory
Factory that configures a FreeMarker `Configuration`.
FreeMarkerConfigurationFactoryBean
Factory bean that creates a FreeMarker `Configuration` and provides it as a bean reference.
FreeMarkerTemplateUtils
Utility class for working with FreeMarker.
InternetAddressEditor
Editor for `java.mail.internet.InternetAddress`, to directly populate an InternetAddress property.
JavaMailSender
Extended `MailSender` interface for JavaMail, supporting MIME messages both as direct arguments and through preparation callbacks.
JavaMailSenderImpl
Production implementation of the `JavaMailSender` interface, supporting both JavaMail `MimeMessages` and Spring `SimpleMailMessages`.
JCacheAspectSupport
Base class for JSR-107 caching aspects, such as the `JCacheInterceptor` or an AspectJ aspect.
JCacheCache
`Cache` implementation on top of a `javax.cache.Cache` instance.
JCacheCacheManager
`CacheManager` implementation backed by a JCache `javax.cache.CacheManager`.
JCacheConfigurer
Extension of `CachingConfigurer` for the JSR-107 implementation.
JCacheConfigurerSupport
Deprecated.
as of 6.0 in favor of implementing `JCacheConfigurer` directly
JCacheInterceptor
AOP Alliance MethodInterceptor for declarative cache management using JSR-107 caching annotations.
JCacheManagerFactoryBean
`FactoryBean` for a JCache `javax.cache.CacheManager`, obtaining a pre-defined `CacheManager` by name through the standard JCache `javax.cache.Caching` class.
JCacheOperation<A extends Annotation>
Model the base of JSR-107 cache operation through an interface contract.
JCacheOperationSource
Interface used by `JCacheInterceptor`.
JobDetailFactoryBean
A Spring `FactoryBean` for creating a Quartz `JobDetail` instance, supporting bean-style usage for JobDetail configuration.
JobMethodInvocationFailedException
Unchecked exception that wraps an exception thrown from a target method.
LocalDataSourceJobStore
Subclass of Quartz's `JobStoreCMT` class that delegates to a Spring-managed `DataSource` instead of using a Quartz-managed JDBC connection pool.
LocalTaskExecutorThreadPool
Quartz `ThreadPool` adapter that delegates to a Spring-managed `Executor` instance, specified on `SchedulerFactoryBean`.
MailAuthenticationException
Exception thrown on failed authentication.
MailException
Base class for all mail exceptions.
MailMessage
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.
MailParseException
Exception thrown if illegal message properties are encountered.
MailPreparationException
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.
MailSender
This interface defines a strategy for sending simple mails.
MailSendException
Exception thrown when a mail sending error is encountered.
MethodInvokingJobDetailFactoryBean
`FactoryBean` that exposes a `JobDetail` object which delegates job execution to a specified (static or non-static) method.
MethodInvokingJobDetailFactoryBean.MethodInvokingJob
Quartz Job implementation that invokes a specified method.
MethodInvokingJobDetailFactoryBean.StatefulMethodInvokingJob
Extension of the MethodInvokingJob, implementing the StatefulJob interface.
MimeMailMessage
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.
MimeMessageHelper
Helper class for populating a `MimeMessage`.
MimeMessagePreparator
Callback interface for the preparation of JavaMail MIME messages.
ProxyJCacheConfiguration
`@Configuration` class that registers the Spring infrastructure beans necessary to enable proxy-based annotation-driven JSR-107 cache management.
QuartzJobBean
Simple implementation of the Quartz Job interface, applying the passed-in JobDataMap and also the SchedulerContext as bean property values.
ResourceLoaderClassLoadHelper
Wrapper that adapts from the Quartz `ClassLoadHelper` interface onto Spring's `ResourceLoader` interface.
SchedulerAccessor
Common base class for accessing a Quartz Scheduler, i.e.
SchedulerAccessorBean
Spring bean-style class for accessing a Quartz Scheduler, i.e.
SchedulerContextAware
Callback interface to be implemented by Spring-managed Quartz artifacts that need access to the SchedulerContext (without having natural access to it).
SchedulerFactoryBean
`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.
SimpleExceptionCacheResolver
A simple `CacheResolver` that resolves the exception cache based on a configurable `CacheManager` and the name of the cache: `CacheResultOperation.getExceptionCacheName()`.
SimpleMailMessage
Models a simple mail message, including data such as the from, to, cc, subject, and text fields.
SimpleThreadPoolTaskExecutor
Subclass of Quartz's SimpleThreadPool that implements Spring's `TaskExecutor` interface and listens to Spring lifecycle callbacks.
SimpleTriggerFactoryBean
A Spring `FactoryBean` for creating a Quartz `SimpleTrigger` instance, supporting bean-style usage for trigger configuration.
SpringBeanJobFactory
Subclass of `AdaptableJobFactory` that also supports Spring-style dependency injection on bean properties.
SpringTemplateLoader
FreeMarker `TemplateLoader` adapter that loads template files via a Spring `ResourceLoader`.
TransactionAwareCacheDecorator
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.
TransactionAwareCacheManagerProxy
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.