Spring Boot Configuration

import org.springframework.boot.context.properties.bind.Binder;
import org.springframework.boot.context.properties.source.ConfigurationPropertySources;
import org.springframework.boot.quartz.autoconfigure.QuartzJdbcProperties;
import org.springframework.boot.quartz.autoconfigure.QuartzProperties;
import org.springframework.core.env.StandardEnvironment;

class QuartzDefaultsTest {

    static String dump() {
        Binder binder = new Binder(ConfigurationPropertySources.get(new StandardEnvironment()));
        QuartzProperties q = binder.bindOrCreate("spring.quartz", QuartzProperties.class);
        QuartzJdbcProperties j = binder.bindOrCreate("spring.quartz.jdbc", QuartzJdbcProperties.class);
        return "job-store-type=" + q.getJobStoreType() + "\nscheduler-name=" + q.getSchedulerName()
                + "\nauto-startup=" + q.isAutoStartup() + "\nstartup-delay=" + q.getStartupDelay()
                + "\nwait-for-jobs-to-complete-on-shutdown=" + q.isWaitForJobsToCompleteOnShutdown()
                + "\noverwrite-existing-jobs=" + q.isOverwriteExistingJobs() + "\nproperties=" + q.getProperties()
                + "\njdbc.initialize-schema=" + j.getInitializeSchema() + "\njdbc.schema=" + j.getSchema()
                + "\njdbc.platform=" + j.getPlatform() + "\njdbc.continue-on-error=" + j.isContinueOnError()
                + "\njdbc.comment-prefix=" + j.getCommentPrefix();
    }
}

job-store-type=MEMORY
scheduler-name=null
auto-startup=true
startup-delay=PT0S
wait-for-jobs-to-complete-on-shutdown=false
overwrite-existing-jobs=false
properties={}
jdbc.initialize-schema=EMBEDDED
jdbc.schema=classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql
jdbc.platform=null
jdbc.continue-on-error=true
jdbc.comment-prefix=[#, --]

spring:
  quartz:
    job-store-type: memory                      # memory or jdbc
    # scheduler-name:                           # no default: the bean name quartzScheduler is used
    auto-startup: true
    startup-delay: 0s
    wait-for-jobs-to-complete-on-shutdown: false
    overwrite-existing-jobs: false
    properties: {}                              # raw org.quartz.* keys, passed through unchanged
    jdbc:
      initialize-schema: embedded               # always, embedded or never
      schema: classpath:org/quartz/impl/jdbcjobstore/tables_@@platform@@.sql
      # platform:                               # auto-detected from the DataSource
      continue-on-error: true
      comment-prefix:
        - "#"
        - "--"

management:
  endpoint:
    quartz:
      show-values: never                        # never, always or when-authorized
      # roles:                                  # empty: every authenticated user

spring:
  quartz:
    properties:
      org.quartz.scheduler.instanceId: AUTO                       # cluster nodes: a generated id
      org.quartz.scheduler.idleWaitTime: "30000"                  # maximum sleep of the scheduler thread, ms
      org.quartz.threadPool.threadCount: "10"                     # SimpleThreadPool size (Spring's default is 10)
      org.quartz.jobStore.misfireThreshold: "60000"               # how late a trigger may be before it is a misfire
      org.quartz.jobStore.isClustered: "true"                     # JDBC store only
      org.quartz.jobStore.clusterCheckinInterval: "5000"          # JDBC store only
      org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.PostgreSQLDelegate   # JDBC store only

import org.springframework.boot.quartz.autoconfigure.SchedulerFactoryBeanCustomizer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@Configuration(proxyBeanMethods = false)
class QuartzFileConfiguration {

    @Bean
    SchedulerFactoryBeanCustomizer quartzPropertiesFile() {
        return factory -> factory.setConfigLocation(new ClassPathResource("quartz.properties"));
    }
}

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;

@Configuration(proxyBeanMethods = false)
class ExecutorBeanConfiguration {

    @Bean(name = "myExecutor")
    ThreadPoolTaskExecutor myExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setThreadNamePrefix("my-exec-");
        executor.setCorePoolSize(2);
        executor.setMaxPoolSize(2);
        return executor;
    }
}

import java.util.Properties;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
class ReportsSchedulerConfiguration {

    /** Not an autowire candidate: injecting Scheduler keeps getting Boot's scheduler. Look this one up by name. */
    @Bean(destroyMethod = "shutdown", autowireCandidate = false)
    Scheduler reportsScheduler() throws SchedulerException {
        Properties properties = new Properties();
        properties.setProperty("org.quartz.scheduler.instanceName", "ReportsScheduler");
        properties.setProperty("org.quartz.threadPool.threadCount", "2");
        Scheduler scheduler = new StdSchedulerFactory(properties).getScheduler();
        scheduler.start();
        return scheduler;
    }
}

import java.util.List;

import org.quartz.JobDetail;
import org.quartz.Trigger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration(proxyBeanMethods = false)
class TwoFactoryBeans {

    @Bean
    @Primary
    SchedulerFactoryBean bookshelfScheduler(List<JobDetail> jobs, List<Trigger> triggers) {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();   // Boot's customizers do not run for this one
        factory.setJobDetails(jobs.toArray(new JobDetail[0]));
        factory.setTriggers(triggers.toArray(new Trigger[0]));
        return factory;
    }

    @Bean
    SchedulerFactoryBean reportsScheduler() {
        return new SchedulerFactoryBean();
    }
}

package bookshelf;

import java.time.Duration;
import java.util.TimeZone;

import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties("bookshelf.schedule")
public record ScheduleProperties(TimeZone zone, Duration cacheRefreshInterval, String overdueCron,
        String weeklyCron, String retentionCron) {
}

package bookshelf;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration(proxyBeanMethods = false)
@EnableConfigurationProperties(ScheduleProperties.class)
class BookshelfSchedule {

    @Bean JobDetail cacheRefreshJob() {
        return JobBuilder.newJob(CacheRefreshJob.class).withIdentity("cacheRefresh", "bookshelf").storeDurably().build();
    }

    @Bean Trigger cacheRefreshTrigger(JobDetail cacheRefreshJob, ScheduleProperties p) {
        return TriggerBuilder.newTrigger().forJob(cacheRefreshJob).withIdentity("cacheRefreshTrigger", "bookshelf")
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInMilliseconds(p.cacheRefreshInterval().toMillis()).repeatForever()
                        .withMisfireHandlingInstructionNextWithRemainingCount()).build();
    }

    @Bean JobDetail overdueLoanRemindersJob() {
        return JobBuilder.newJob(OverdueLoanRemindersJob.class).withIdentity("overdueLoanReminders", "bookshelf")
                .usingJobData("runs", 0).storeDurably().build();
    }

    @Bean Trigger overdueLoanRemindersTrigger(JobDetail overdueLoanRemindersJob, ScheduleProperties p) {
        return cron(overdueLoanRemindersJob, "overdueLoanRemindersTrigger", p.overdueCron(), p);
    }

    @Bean JobDetail weeklyStatisticsJob() {
        return JobBuilder.newJob(WeeklyStatisticsJob.class).withIdentity("weeklyStatistics", "bookshelf").storeDurably().build();
    }

    @Bean Trigger weeklyStatisticsTrigger(JobDetail weeklyStatisticsJob, ScheduleProperties p) {
        return cron(weeklyStatisticsJob, "weeklyStatisticsTrigger", p.weeklyCron(), p);
    }

    @Bean JobDetail retentionCleanupJob() {
        return JobBuilder.newJob(RetentionCleanupJob.class).withIdentity("retentionCleanup", "bookshelf").storeDurably().build();
    }

    @Bean Trigger retentionCleanupTrigger(JobDetail retentionCleanupJob, ScheduleProperties p) {
        return cron(retentionCleanupJob, "retentionCleanupTrigger", p.retentionCron(), p);
    }

    private static Trigger cron(JobDetail job, String name, String expression, ScheduleProperties p) {
        return TriggerBuilder.newTrigger().forJob(job).withIdentity(name, "bookshelf")
                .withSchedule(CronScheduleBuilder.cronSchedule(expression).inTimeZone(p.zone())).build();
    }
}

package bookshelf;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;

@Component
class JobAuditListener implements JobListener {

    private static final Logger log = LoggerFactory.getLogger(JobAuditListener.class);

    @Override public String getName() { return "bookshelf-audit"; }

    @Override public void jobToBeExecuted(JobExecutionContext context) {
        log.info("starting {} on {}", context.getJobDetail().getKey(), Thread.currentThread().getName());
    }

    @Override public void jobExecutionVetoed(JobExecutionContext context) { }

    @Override public void jobWasExecuted(JobExecutionContext context, JobExecutionException error) {
        log.info("finished {} in {} ms{}", context.getJobDetail().getKey(), context.getJobRunTime(),
                error == null ? "" : " with " + error.getMessage());
    }
}

spring:
  application:
    name: bookshelf-service
  quartz:
    scheduler-name: BookshelfScheduler
    wait-for-jobs-to-complete-on-shutdown: true
    overwrite-existing-jobs: false

bookshelf:
  schedule:
    zone: Europe/Madrid
    cache-refresh-interval: 5m
    overdue-cron: "0 0 2 ? * MON-FRI"
    weekly-cron: "0 0 6 ? * MON"
    retention-cron: "0 30 3 LW * ?"        # last weekday of the month

management:
  endpoints:
    web:
      exposure:
        include: health,quartz

spring:
  quartz:
    job-store-type: memory
    startup-delay: 3s
    properties:
      org.quartz.threadPool.threadCount: "3"

bookshelf:
  schedule:
    cache-refresh-interval: 10s
    overdue-cron: "0/15 * * * * ?"

management:
  endpoint:
    quartz:
      show-values: always            # job data is visible in /actuator/quartz: development only

spring:
  quartz:
    job-store-type: memory
    auto-startup: false
    properties:
      org.quartz.threadPool.threadCount: "2"

spring:
  datasource:
    url: ${DB_URL}
    username: ${DB_USER}
    password: ${DB_PASSWORD}
    hikari:
      maximum-pool-size: 16
  quartz:
    job-store-type: jdbc
    jdbc:
      initialize-schema: never           # the migration tool owns the QRTZ_ tables
    properties:
      org.quartz.scheduler.instanceId: AUTO
      org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.PostgreSQLDelegate
      org.quartz.jobStore.isClustered: "true"
      org.quartz.jobStore.clusterCheckinInterval: "5000"
      org.quartz.jobStore.misfireThreshold: "60000"
      # threadCount is left at Spring's default of 10; do not set it when the virtual profile is active

java -jar bookshelf.jar --spring.profiles.active=dev
DB_URL=jdbc:postgresql://db:5432/bookshelf DB_USER=bookshelf DB_PASSWORD=... \
  java -jar bookshelf.jar --spring.profiles.active=prod,virtual

import org.quartz.Scheduler;
import org.quartz.SchedulerMetaData;

static String describe(Scheduler scheduler) throws Exception {
    SchedulerMetaData md = scheduler.getMetaData();
    return "schedulerName=" + md.getSchedulerName()
            + "\ninstanceId=" + md.getSchedulerInstanceId()
            + "\njobStoreClass=" + md.getJobStoreClass().getName()
            + "\nthreadPoolClass=" + md.getThreadPoolClass().getName()
            + "\nthreadPoolSize=" + md.getThreadPoolSize()
            + "\nsupportsPersistence=" + md.isJobStoreSupportsPersistence()
            + "\nclustered=" + md.isJobStoreClustered();
}

default (memory)            schedulerName=BookshelfScheduler, instanceId=NON_CLUSTERED, jobStoreClass=org.quartz.simpl.RAMJobStore,
                            threadPoolClass=org.quartz.simpl.SimpleThreadPool, threadPoolSize=10, supportsPersistence=false, clustered=false
task executor set           ... threadPoolClass=org.springframework.scheduling.quartz.LocalTaskExecutorThreadPool, threadPoolSize=-1
prod (JDBC, clustered)      ... jobStoreClass=org.springframework.scheduling.quartz.LocalDataSourceJobStore, supportsPersistence=true, clustered=true