tessl/maven-org-springframework-boot--spring-boot-starter-quartz

Starter for using the Quartz scheduler in Spring Boot applications with auto-configuration support

—

Pending

Overview

Eval results

Files

Auto-configuration

Name: tessl/maven-org-springframework-boot--spring-boot-starter-quartz
Author: tessl

Core auto-configuration classes that automatically set up Quartz Scheduler when the starter is present on the classpath. Handles scheduler factory bean creation, job store configuration, and seamless Spring integration.

Capabilities

QuartzAutoConfiguration

Main auto-configuration class that sets up the Quartz Scheduler with Spring Boot's opinionated defaults.

/**
 * Auto-configuration for Quartz Scheduler integration with Spring Boot
 * Activates when Scheduler, SchedulerFactoryBean, and PlatformTransactionManager are on classpath
 * Runs after DataSource, JPA, and database migration auto-configurations
 */
@AutoConfiguration(after = { 
    DataSourceAutoConfiguration.class, 
    HibernateJpaAutoConfiguration.class,
    LiquibaseAutoConfiguration.class, 
    FlywayAutoConfiguration.class 
})
@ConditionalOnClass({ Scheduler.class, SchedulerFactoryBean.class, PlatformTransactionManager.class })
@EnableConfigurationProperties(QuartzProperties.class)
public class QuartzAutoConfiguration {

    /**
     * Creates and configures the main Quartz SchedulerFactoryBean
     * @param properties QuartzProperties configuration
     * @param customizers Optional customizers for advanced configuration
     * @param jobDetails JobDetail beans to register with scheduler
     * @param calendars Calendar beans to register with scheduler  
     * @param triggers Trigger beans to register with scheduler
     * @param applicationContext Spring application context for job factory
     * @return Configured SchedulerFactoryBean
     */
    @Bean
    @ConditionalOnMissingBean
    public SchedulerFactoryBean quartzScheduler(
        QuartzProperties properties,
        ObjectProvider<SchedulerFactoryBeanCustomizer> customizers,
        ObjectProvider<JobDetail> jobDetails,
        Map<String, Calendar> calendars,
        ObjectProvider<Trigger> triggers,
        ApplicationContext applicationContext
    );
}

Usage Examples:

// Basic configuration - no additional setup needed
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
        // Quartz scheduler automatically configured and started
    }
}

// Custom job and trigger beans are automatically registered
@Configuration
public class JobConfiguration {
    
    @Bean
    public JobDetail myJobDetail() {
        return JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "myGroup")
                .storeDurably()
                .build();
    }
    
    @Bean
    public Trigger myTrigger() {
        return TriggerBuilder.newTrigger()
                .forJob(myJobDetail())
                .withIdentity("myTrigger", "myGroup")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0 12 * * ?"))
                .build();
    }
}

JDBC Store Configuration

Nested configuration class that handles JDBC job store setup when database persistence is required.

/**
 * Configuration for JDBC-based job store
 * Activates when DataSource is available and spring.quartz.job-store-type=jdbc
 */
@Configuration(proxyBeanMethods = false)
@ConditionalOnSingleCandidate(DataSource.class)
@ConditionalOnProperty(name = "spring.quartz.job-store-type", havingValue = "jdbc")
@Import(DatabaseInitializationDependencyConfigurer.class)
protected static class JdbcStoreTypeConfiguration {

    /**
     * Customizer that configures DataSource and TransactionManager for Quartz
     * @param properties Quartz configuration properties
     * @param dataSource Primary DataSource (or @QuartzDataSource if available)
     * @param quartzDataSource Optional dedicated DataSource for Quartz
     * @param transactionManager Primary transaction manager
     * @param quartzTransactionManager Optional dedicated transaction manager
     * @return SchedulerFactoryBeanCustomizer for JDBC configuration
     */
    @Bean
    @Order(0)
    public SchedulerFactoryBeanCustomizer dataSourceCustomizer(
        QuartzProperties properties, 
        DataSource dataSource,
        @QuartzDataSource ObjectProvider<DataSource> quartzDataSource,
        ObjectProvider<PlatformTransactionManager> transactionManager,
        @QuartzTransactionManager ObjectProvider<PlatformTransactionManager> quartzTransactionManager
    );

    /**
     * Database initializer for Quartz schema setup
     * @param dataSource DataSource for schema initialization
     * @param quartzDataSource Optional dedicated Quartz DataSource
     * @param properties Quartz configuration properties
     * @return QuartzDataSourceScriptDatabaseInitializer
     */
    @Bean
    @ConditionalOnMissingBean
    @Conditional(OnQuartzDatasourceInitializationCondition.class)
    public QuartzDataSourceScriptDatabaseInitializer quartzDataSourceScriptDatabaseInitializer(
        DataSource dataSource, 
        @QuartzDataSource ObjectProvider<DataSource> quartzDataSource,
        QuartzProperties properties
    );
}

Usage Examples:

// JDBC job store with dedicated DataSource
@Configuration
public class QuartzDataSourceConfiguration {
    
    @Bean
    @QuartzDataSource
    @ConfigurationProperties("spring.datasource.quartz")
    public DataSourceProperties quartzDataSourceProperties() {
        return new DataSourceProperties();
    }
    
    @Bean
    @QuartzDataSource
    public DataSource quartzDataSource() {
        return quartzDataSourceProperties()
                .initializeDataSourceBuilder()
                .build();
    }
    
    @Bean
    @QuartzTransactionManager
    public PlatformTransactionManager quartzTransactionManager(
            @QuartzDataSource DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

Database Initialization

Classes responsible for Quartz database schema initialization and dependency management.

/**
 * Handles database schema initialization for Quartz JDBC job store
 * Extends DataSourceScriptDatabaseInitializer for Quartz-specific schema setup
 */
public class QuartzDataSourceScriptDatabaseInitializer 
    extends DataSourceScriptDatabaseInitializer {
    
    /**
     * Creates database initializer with DataSource and configuration
     * @param dataSource DataSource for initialization  
     * @param properties Quartz properties containing schema settings
     */
    public QuartzDataSourceScriptDatabaseInitializer(
        DataSource dataSource, 
        QuartzProperties properties
    );
    
    /**
     * Gets database initialization settings from Quartz properties
     * @return DatabaseInitializationSettings configured for Quartz
     */
    protected DatabaseInitializationSettings getDatabaseInitializationSettings();
}

/**
 * Detects if Scheduler depends on database initialization for proper ordering
 * Implements DependsOnDatabaseInitializationDetector interface
 */
public class SchedulerDependsOnDatabaseInitializationDetector 
    implements DependsOnDatabaseInitializationDetector {
    
    /**
     * Detects scheduler factory bean dependency on database initialization
     * @param beanFactory Bean factory to check for dependencies
     * @param configurer Database initialization dependency configurer
     */
    void detect(ConfigurableListableBeanFactory beanFactory, 
               DatabaseInitializationDependencyConfigurer configurer);
}

/**
 * Conditional class for checking Quartz DataSource initialization requirements
 */
public class OnQuartzDatasourceInitializationCondition implements Condition {
    /**
     * Evaluates if Quartz database initialization should occur
     * @param context Condition context with environment and bean factory
     * @param metadata Annotation metadata from conditional annotation
     * @return true if initialization should occur
     */
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata);
}

Configuration Integration

The auto-configuration integrates with Spring Boot's configuration system:

# Enable auto-configuration (default when starter is present)
spring.quartz.auto-startup=true

# Configure job store type to activate JDBC configuration
spring.quartz.job-store-type=jdbc

# Database initialization
spring.quartz.jdbc.initialize-schema=embedded
spring.quartz.jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql

# Advanced Quartz properties
spring.quartz.properties.org.quartz.scheduler.instanceName=MyScheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
spring.quartz.properties.org.quartz.jobStore.class=org.springframework.scheduling.quartz.LocalDataSourceJobStore

Error Handling

The auto-configuration handles common error scenarios:

Missing DataSource: Falls back to in-memory job store
Database initialization failures: Provides clear error messages about schema setup
Conflicting configurations: Uses Spring Boot's conditional annotations to prevent conflicts
Startup timing: Ensures proper ordering with database migrations and JPA initialization

Install with Tessl CLI

npx tessl i tessl/maven-org-springframework-boot--spring-boot-starter-quartz

docs

actuator-integration.md

auto-configuration.md

configuration-properties.md

index.md

scheduler-customization.md

tile.json

tessl/maven-org-springframework-boot--spring-boot-starter-quartz