Java back-end development: Using Java Quartz for API scheduled task management

Java backend development is a very broad and popular field because Java language is widely used in enterprise-level application development. In this field, developers need to master numerous technologies and tools to achieve high-quality software writing. One of the important technologies is the management of API scheduled tasks, and Java Quartz is a noteworthy tool for achieving this task.

Java Quartz is an open source job scheduling framework, which can be used to implement various scheduling needs in Java applications. This framework has very powerful functions and can implement scheduling tasks based on different standards such as time, date, week, month, year, etc., and can also send task execution results to applications as events.

For developers, using Java Quartz is very simple and convenient. We only need to introduce its corresponding dependency library and configure some parameters to use it to manage API scheduled tasks. Below, we will introduce some methods of using Java Quartz to manage API scheduled tasks.

1. Add dependent libraries and configuration files

First, we need to introduce Java Quartz’s dependent libraries into our project. You can use Maven to manage these dependencies. Add the following content to the project pom.xml file:

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

where x.x.x is the Java Quartz version number. We can check the latest version on the official website of Java Quartz.

After introducing the dependent library, we need to create a configuration file to configure the parameters of Java Quartz. For specific configuration parameters, you can view the official documentation of Java Quartz. Here we give a simple configuration file example:

# Quartz properties
org.quartz.scheduler.wait_for_jobs_to_complete = true
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount = 5

# JobStore properties
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.dataSource = myDS
org.quartz.jobStore.tablePrefix = QRTZ_
org.quartz.jobStore.isClustered = false

# DataSource properties
org.quartz.dataSource.myDS.driver = com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL = jdbc:mysql://localhost:3306/quartz
org.quartz.dataSource.myDS.user = quartz
org.quartz.dataSource.myDS.password = password

In this configuration file, we set the thread pool size to 5, use the MySQL database as the data storage of Quartz, the data table prefix is ​​QRTZ_, and also set Quartz's configuration of waiting for task completion.

2. Create API scheduled tasks

Next, we need to create API scheduled tasks. This task can be a simple function call or a complex operation, such as sending emails, generating reports, etc.

In Java Quartz, we can implement API scheduled tasks by creating a task class that implements the Job interface. In this task class, we need to implement the execute method to complete specific scheduling task operations.

The following is a simple example:

package com.example.quartz;

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

public class MyJob implements Job {
 
    public void execute(JobExecutionContext context)
            throws JobExecutionException {
 
        System.out.println("Hello Quartz!");
 
    }
 
}

In this task class, we use System.out.println to print a message.

3. Configuring triggers for API scheduled tasks

After creating the task class, we need to create a trigger to decide when to run the task. In Java Quartz, a trigger is a component used to specify when a task will be executed. They can schedule tasks based on different criteria, such as time or date.

Java Quartz supports many different types of triggers. In this article, we introduce the most commonly used trigger types: SimpleTrigger, CronTrigger, DailyTimeIntervalTrigger.

Among them, SimpleTrigger is the simplest trigger type. It will only be executed once, or multiple times based on certain parameters. CronTrigger is a trigger based on Cron expressions, and we can use it to schedule tasks based on date or time patterns. DailyTimeIntervalTrigger is a trigger based on relative or absolute time intervals, which can be used to perform tasks regularly, such as every day, every hour, every minute, etc.

Below we will give a simple CronTrigger example:

package com.example.quartz;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class CronTriggerExample {
    public static void main(String[] args) throws Exception {

        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();

        CronTrigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?"))
                .build();

        Scheduler scheduler = new StdSchedulerFactory().getScheduler();
        scheduler.start();
        scheduler.scheduleJob(job, trigger);
    }
}

In this example, we create a CronTrigger that will run every 5 seconds. This trigger will schedule the task with a Job instance as a parameter. This task is an instance of the MyJob class.

4. Run API scheduled task

Finally, we need to run this task. We can use the Scheduler class of Java Quartz to start the task and specify the corresponding task scheduling time. The Scheduler class provides many methods and properties for controlling task execution, such as pauseJob(), resumeJob(), shutdown(), etc.

The following is a simple example of starting an API scheduled task:

package com.example.quartz;

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class QuartzTest {
    public static void main(String[] args) throws Exception {

        SchedulerFactory sf = new StdSchedulerFactory();
        Scheduler scheduler = sf.getScheduler();

        // start the scheduler
        scheduler.start();

        // define the job and tie it to our MyJob class
        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();

        // Trigger the job to run now, and then every 40 seconds
        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .startNow()
                .withSchedule(SimpleScheduleBuilder.simpleSchedule()
                        .withIntervalInSeconds(40)
                        .repeatForever())
                .build();

        // Tell quartz to schedule the job using our trigger
        scheduler.scheduleJob(job, trigger);

        // wait until Quartz has finished executing jobs
        Thread.sleep(60000);

        // shutdown the scheduler
        scheduler.shutdown(true);
    }
}

In this example, we use a SimpleTrigger, which schedules the task now, and then schedules it again every 40 seconds Task. At the end of the main method, we sleep the thread for 60 seconds and then use the scheduler.shutdown(true) method to stop the task.

In this way, we can easily implement API scheduled task management. Whether in the product development process or in daily operation and maintenance, Java Quartz is a tool worthy of serious attention.

The above is the detailed content of Java back-end development: Using Java Quartz for API scheduled task management. For more information, please follow other related articles on the PHP Chinese website!