or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

caching.mdindex.mdmail.mdscheduling.mdtemplates.md
tile.json

tessl/maven-org-springframework--spring-context-support

Spring Framework integration support for caching (Caffeine, JCache), mail (JavaMail), scheduling (Quartz), and template engines (FreeMarker)

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.springframework/spring-context-support@6.2.x

To install, run

npx @tessl/cli install tessl/maven-org-springframework--spring-context-support@6.2.0

index.mddocs/

Spring Context Support

Spring Context Support provides comprehensive integration support for external libraries and frameworks, enabling seamless integration of caching, mail, scheduling, and template processing capabilities into Spring applications. It bridges Spring's core dependency injection and application context features with popular third-party libraries.

Package Information

  • Package Name: spring-context-support

  • Package Type: maven

  • Language: Java

  • Installation:

    <dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-context-support</artifactId>
  <version>6.2.8</version>
</dependency>

    Gradle:

    implementation("org.springframework:spring-context-support:6.2.8")

Core Imports

// Cache support
import org.springframework.cache.caffeine.CaffeineCacheManager;
import org.springframework.cache.jcache.JCacheCacheManager;
import org.springframework.cache.transaction.TransactionAwareCacheManagerProxy;

// Mail support
import org.springframework.mail.MailSender;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.javamail.JavaMailSenderImpl;
import org.springframework.mail.javamail.MimeMessageHelper;

// Scheduling support
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;

// Template support
import org.springframework.ui.freemarker.FreeMarkerConfigurationFactory;
import org.springframework.ui.freemarker.FreeMarkerConfigurationFactoryBean;

Basic Usage

// Cache configuration
@Configuration
@EnableCaching
public class CacheConfig {
    
    @Bean
    public CacheManager cacheManager() {
        CaffeineCacheManager cacheManager = new CaffeineCacheManager();
        cacheManager.setCaffeine(Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(Duration.ofMinutes(10)));
        return cacheManager;
    }
}

// Mail configuration
@Configuration
public class MailConfig {
    
    @Bean
    public JavaMailSender mailSender() {
        JavaMailSenderImpl mailSender = new JavaMailSenderImpl();
        mailSender.setHost("smtp.example.com");
        mailSender.setPort(587);
        mailSender.setUsername("user@example.com");
        mailSender.setPassword("password");
        return mailSender;
    }
}

// Using mail sender
@Service
public class EmailService {
    
    @Autowired
    private JavaMailSender mailSender;
    
    public void sendEmail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
        mailSender.send(message);
    }
}

Architecture

Spring Context Support is organized around four main integration areas:

  • Caching: Provides implementations for Caffeine and JCache/JSR-107 cache providers, plus transaction-aware caching decorators
  • Mail: Offers abstraction layer over JavaMail with support for simple text messages and complex MIME messages
  • Scheduling: Integrates with Quartz scheduler for enterprise-grade job scheduling and management
  • Templates: Enables FreeMarker template engine integration for server-side rendering

Each area provides both high-level convenience APIs and lower-level configuration options for advanced use cases.

Capabilities

Caching Support

Comprehensive caching integration with multiple providers including Caffeine, JCache/JSR-107, and transaction-aware caching. Enables high-performance caching strategies with Spring's declarative caching annotations.

// Caffeine Cache Manager
public class CaffeineCacheManager extends AbstractCacheManager {
    public void setCaffeine(Caffeine<Object, Object> caffeine);
    public void setAsyncCacheMode(boolean asyncCacheMode);
    public void setAllowNullValues(boolean allowNullValues);
}

// JCache Manager
public class JCacheCacheManager extends AbstractTransactionSupportingCacheManager {
    public void setCacheManager(javax.cache.CacheManager cacheManager);
    public javax.cache.CacheManager getCacheManager();
}

// Transaction-aware caching
public class TransactionAwareCacheManagerProxy implements CacheManager, InitializingBean {
    public void setTargetCacheManager(CacheManager targetCacheManager);
}

Caching Support

Mail Integration

Complete mail functionality from simple text messages to complex MIME messages with attachments. Provides abstraction over JavaMail with Spring-friendly configuration and error handling.

// Core mail interfaces
public interface MailSender {
    void send(SimpleMailMessage simpleMessage) throws MailException;
    void send(SimpleMailMessage... simpleMessages) throws MailException;
}

public interface JavaMailSender extends MailSender {
    MimeMessage createMimeMessage();
    MimeMessage createMimeMessage(InputStream contentStream) throws MailException;
    void send(MimeMessage mimeMessage) throws MailException;
    void send(MimeMessage... mimeMessages) throws MailException;
    void send(MimeMessagePreparator mimeMessagePreparator) throws MailException;
    void send(MimeMessagePreparator... mimeMessagePreparators) throws MailException;
}

// Main implementation
public class JavaMailSenderImpl implements JavaMailSender {
    public void setHost(String host);
    public void setPort(int port);
    public void setUsername(String username);
    public void setPassword(String password);
    public void setJavaMailProperties(Properties javaMailProperties);
}

Mail Integration

Quartz Scheduling

Enterprise-grade job scheduling integration with Quartz Scheduler. Supports cron-based triggers, method-invoking jobs, and full Spring dependency injection for scheduled tasks.

// Main scheduler factory
public class SchedulerFactoryBean implements FactoryBean<Scheduler>, BeanNameAware, 
        ApplicationContextAware, InitializingBean, DisposableBean, SmartLifecycle {
    public void setConfigLocation(Resource configLocation);
    public void setQuartzProperties(Properties quartzProperties);
    public void setTriggers(Trigger... triggers);
    public void setJobDetails(JobDetail... jobDetails);
    public void setAutoStartup(boolean autoStartup);
}

// Job creation
public class JobDetailFactoryBean implements FactoryBean<JobDetail>, BeanNameAware, InitializingBean {
    public void setJobClass(Class<? extends Job> jobClass);
    public void setJobDataAsMap(Map<String, ?> jobDataAsMap);
}

// Base job class
public abstract class QuartzJobBean implements Job {
    protected abstract void executeInternal(JobExecutionContext context) throws JobExecutionException;
}

Quartz Scheduling

FreeMarker Templates

Template engine integration for server-side rendering with FreeMarker. Provides factory beans for configuration and utilities for template processing in web and non-web contexts.

// Configuration factory
public class FreeMarkerConfigurationFactory {
    public void setTemplateLoaderPath(String templateLoaderPath);
    public void setTemplateLoaderPaths(String... templateLoaderPaths);
    public void setFreemarkerSettings(Properties settings);
    public void setDefaultEncoding(String defaultEncoding);
    public Configuration createConfiguration() throws IOException, TemplateException;
}

// Factory Bean wrapper
public class FreeMarkerConfigurationFactoryBean extends FreeMarkerConfigurationFactory 
        implements FactoryBean<Configuration>, InitializingBean, ResourceLoaderAware {
}

// Template utilities
public abstract class FreeMarkerTemplateUtils {
    public static String processTemplateIntoString(Template template, Object model) 
            throws IOException, TemplateException;
}

FreeMarker Templates

Exception Handling

All modules provide comprehensive exception hierarchies extending from Spring's base exception classes:

  • Mail exceptions: MailException base class with MailAuthenticationException, MailSendException, MailParseException, MailPreparationException
  • Scheduling exceptions: JobMethodInvocationFailedException for method-invoking job failures
  • Cache exceptions: Standard Spring Cache abstraction exceptions
  • Template exceptions: Standard FreeMarker TemplateException and IOException