This quick tutorial will teach you how to use Quartz Scheduler in a Spring Boot application in less than 5 minutes!

Start by creating your project with the spring shell so to include quartz, jpa and h2 dependencies (replace with your actual JDBC driver implementation):

spring init -dquartz,h2,jpa demo-quartz 

Here is the list of dependencies that will be added:

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

        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>


        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

Now the classes. Let's add first two Job classes that will be triggered by Quartz scheduler:

package com.masterspringboot.quartz.job;

import org.quartz.Job;
import org.quartz.JobExecutionContext;

public class JobOne implements Job {

    @Override
    public void execute(JobExecutionContext context) {
        System.out.println("Hello from Job One!");
    }
}

And the other one:

package com.masterspringboot.quartz.job;

import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;

public class JobTwo implements Job {
    @Override
    public void execute(JobExecutionContext context) {

        JobDataMap jobDataMap = context.getMergedJobDataMap();
        String data = jobDataMap.getString("somedata");
        System.out.println("Job Two fired with data: "+data);
    }
}

Now a @Configuration class that will create the triggers for the execution of Jobs:

package com.masterspringboot.quartz.job;

import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.UUID;


@Configuration
public class ConfigureQuartzJob {

    @Bean
    public JobDetail jobADetails() {
        return JobBuilder.newJob(JobOne.class).withIdentity("sampleJobA")
                .storeDurably().build();
    }

    @Bean
    public Trigger jobATrigger(JobDetail jobADetails) {

        return TriggerBuilder.newTrigger().forJob(jobADetails)

                .withIdentity("TriggerA")
                .withSchedule(CronScheduleBuilder.cronSchedule("0/20 * * ? * * *"))
                .build();
    }


    @Bean
    public JobDetail jobBDetails() {
        return JobBuilder.newJob(JobTwo.class).withIdentity("sampleJobB")
                .storeDurably().build();
    }

    @Bean
    public Trigger jobBTrigger(JobDetail jobBDetails) {

        JobDataMap jobDataMap = new JobDataMap();

        jobDataMap.put("somedata", UUID.randomUUID().toString());

        return TriggerBuilder.newTrigger().forJob(jobBDetails)

                .withIdentity("TriggerB")

                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * ? * * *"))
                .usingJobData(jobDataMap)
                .build();
    }


}

Please notice we are using a CronScheduleBuilder with a Cron expression to fire the jobs. We also added for the TriggerB a sample JobData into it.

That's all. Include a Main class as well:

package com.masterspringboot.quartz;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SampleQuartzApplication {

    public static void main(String[] args) {
        SpringApplication.run(SampleQuartzApplication.class, args);
    }

}

In order to choose where jobs are stored, we will define "jdbc" as storage. It will use H2 as option

spring.quartz.job-store-type=jdbc
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
spring.quartz.properties.org.quartz.threadPool.threadCount = 5

If you prefer an in-memory storage, you can opt for:

org.quartz.jobStore.class=org.quartz.simpl.RAMJobStore
spring.quartz.job-store-type=memory

That's all! run your application and you will see in the Console the logs from the jobs:

Hello from Job One!
Hello from Job One!
Job data: b5df5e15-de9e-47d4-aa43-28cb0ee8e754
Hello from Job One!
Hello from Job One!
Hello from Job One!

Using another database for Quartz

Using another database requires adding the right dependency in your project, for example "mysql". Here is a sample Quartz configuration which uses mysql:

spring.datasource.platform=org.hibernate.dialect.MySQL5Dialect
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/quartz_demo_db
spring.datasource.username=root
spring.datasource.password=admin
spring.jpa.open-in-view=false
spring.jpa.show-sql=true
spring.quartz.job-store-type=jdbc
spring.quartz.jdbc.initialize-schema=never

Source code for this article: https://github.com/fmarchioni/masterspringboot/tree/master/quartz/quartz-example-master

FREE WildFly Application Server - JBoss - Quarkus - Drools Tutorials