@SpringBootApplication
@EnableScheduling   // enable once, preferably on the main class
public class MyApp {}

# application.yml
myapp:
  scheduler:
    cleanup-cron: "0 30 2 * * ?"   # 02:30 AM every day
    poll-rate: 15s                # ISO‑8601 duration

@Component
@ConfigurationProperties(prefix = "myapp.scheduler")
public class SchedulerProperties {
    private String cleanupCron;
    private Duration pollRate;
    // getters/setters
}

@Component
@RequiredArgsConstructor
public class CleanupTask {

    private final SchedulerProperties props;

    @Scheduled(cron = "#{@schedulerProperties.cleanupCron}")
    public void cleanOldRecords() {
        // …
    }

    @Scheduled(fixedDelayString = "#{@schedulerProperties.pollRate.toMillis()}")
    public void pollExternalApi() {
        // …
    }
}

@Configuration
@EnableScheduling
public class SchedulingConfig {

    @Bean
    public TaskScheduler taskScheduler(@Value("${myapp.scheduler.pool-size:5}") int poolSize) {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(poolSize);
        scheduler.setThreadNamePrefix("myapp-scheduler-");
        scheduler.setAwaitTerminationSeconds(30);
        scheduler.setWaitForTasksToCompleteOnShutdown(true);
        return scheduler;
    }
}

@Component
@RequiredArgsConstructor
public class ReportScheduler {

    private final ApplicationEventPublisher publisher;

    @Scheduled(cron = "0 0 3 * * ?")   // 03:00 AM daily
    public void scheduleReportGeneration() {
        publisher.publishEvent(new GenerateReportEvent(LocalDate.now()));
    }
}

@Component
@RequiredArgsConstructor
public class ReportGenerator {

    @Async("reportExecutor")   // custom executor bean
    @EventListener
    public void onGenerateReport(GenerateReportEvent event) {
        // heavy processing, DB writes, file I/O …
    }
}

@Scheduled(fixedRateString = "PT10S")
public void poll() {
    try {
        // … business logic
    } catch (Exception ex) {
        log.error("Polling failed", ex);
        // optional: alerting, metrics increment
    }
}

@Bean
public ThreadPoolTaskScheduler taskScheduler() {
    ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
    scheduler.setErrorHandler(t -> log.error("Scheduled task error", t));
    // …
    return scheduler;
}

@Scheduled(cron = "0 0 2 * * ?", zone = "America/New_York")
public void nightlyJob() { … }

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

spring:
  quartz:
    job-store-type: jdbc
    jdbc:
      initialize-schema: always   # creates tables on startup (dev)
    properties:
      org.quartz.threadPool.threadCount: 10
      org.quartz.scheduler.instanceId: AUTO
      org.quartz.scheduler.instanceName: MyAppScheduler
      org.quartz.jobStore.isClustered: true

@PersistJobDataAfterExecution
@DisallowConcurrentExecution   // prevents overlapping runs for the same job key
public class EmailDigestJob implements Job {

    @Autowired
    private EmailService emailService;   // injected lazily via SpringBeanJobFactory

    @Override
    public void execute(JobExecutionContext ctx) {
        JobDataMap data = ctx.getMergedJobDataMap();
        String tenantId = data.getString("tenantId");
        emailService.sendDigest(tenantId);
    }
}

@Service** (or a @Component) **
@RequiredArgsConstructor
public class QuartzScheduler {

    private final Scheduler scheduler;

    public void scheduleDailyDigest(String tenantId) throws SchedulerException {
        JobDetail job = JobBuilder.newJob(EmailDigestJob.class)
                .withIdentity("digest-" + tenantId, "digest")
                .usingJobData("tenantId", tenantId)
                .build();

        Trigger trigger = TriggerBuilder.newTrigger()
                .forJob(job)
                .withIdentity("trigger-" + tenantId, "digest")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0 8 ? * MON-FRI")
                        .inTimeZone(TimeZone.getTimeZone("UTC")))
                .build();

        scheduler.scheduleJob(job, trigger);
    }
}

.withSchedule(CronScheduleBuilder
    .cronSchedule("0 0/5 * * * ?")
    .withMisfireHandlingInstructionDoNothing())

@Component
@RequiredArgsConstructor
public class DistributedTask {

    private final JdbcTemplate jdbc;
    private final LockProvider lockProvider; // from spring‑integration‑jdbc

    @Scheduled(cronMisfire = ???) // not needed; lock decides execution
    public void runIfLeader() {
        Lock lock = lockProvider.obtainLock(new LockConfiguration(
                Instant.now().plusSeconds(30), // lock timeout
                "myapp-distributed-task"));
        if (lock != null) {
            try {
                // critical work
            } finally {
                lock.unlock();
            }
        }
    }
}

@Bean
public LockProvider redisLockProvider(RedisConnectionFactory factory) {
    return new RedisLockProvider(factory);
}

spring.quartz.properties.org.quartz.jobStore.isClustered: true

@Component
@RequiredArgsConstructor
public class CleanupTask {

    private final MeterRegistry registry;

    @Scheduled(cron = "${myapp.scheduler.cleanup-cron}")
    public void run() {
        Timer.Sample sample = Timer.start(registry);
        try {
            // … actual work
            sample.stop(registry.timer("myapp.scheduled.cleanup", "status", "success"));
        } catch (Exception ex) {
            sample.stop(registry.timer("myapp.scheduled.cleanup", "status", "error"));
            throw ex; // or swallow as per 2.5
        }
    }
}

@SpringBootTest
class CleanupTaskTest {

    @Autowired CleanupTask task;
    @MockBean EmailService emailService; // dependency

    @Test
    void runDeletesOldRecords() {
        // given: pre‑populate repository with test data …

        task.run(); // call directly, no scheduling delay

        // then: verify repository state
        verify(emailService).sendDigest(anyString());
    }
}