在Quartz中想要实现动态任务定义，可以通过创建任务的时候的动态灵活参数的方式来实现对于调用策略动态配置从而实现了动态执行任务的操作。下面我们就来介绍一下SpringBoot整合Quartz实现动态Job的定义。

添加依赖

在POM文件中添加Quartz和Spring Boot的依赖，如下所示。

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

配置Quartz Scheduler

接下来，需要定义一个QuartzSchedulerConfig配置类，用来对Quartz Scheduler进行初始化操作，如下所示。

import org.quartz.Scheduler;
import org.quartz.spi.JobFactory;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

@Configuration
public class QuartzSchedulerConfig {

    @Bean
    public Scheduler scheduler(JobFactory jobFactory) throws Exception {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        factory.setJobFactory(jobFactory);
        factory.afterPropertiesSet();
        Scheduler scheduler = factory.getScheduler();
        scheduler.start();
        return scheduler;
    }
}

定义动态Job类

继承Job接口定一个用来执行动态任务的DynamicJob类，代码如下所示。

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;

@Component
public class DynamicJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        String jobParam = (String) context.getJobDetail().getJobDataMap().get("param");
        System.out.println("Dynamic Job executed with param: " + jobParam);
    }
}

定义动态Job服务类

定义一个用来处理动态Job的服务类，并且要确保DynamicJobService类有一个方法来处理任务调度，如下所示。

import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class DynamicJobService {

    @Autowired
    private Scheduler scheduler;

    public void scheduleDynamicJob(String jobName, String jobParam, String cronExpression) throws SchedulerException {
        JobDataMap jobDataMap = new JobDataMap();
        jobDataMap.put("param", jobParam);

        JobDetail jobDetail = JobBuilder.newJob(DynamicJob.class)
                .withIdentity(jobName)
                .usingJobData(jobDataMap)
                .build();

        Trigger trigger = TriggerBuilder.newTrigger()
                .forJob(jobDetail)
                .withIdentity(jobName + "Trigger")
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();

        scheduler.scheduleJob(jobDetail, trigger);
    }
}

控制层代码实现

接下来就需要创建RESTFul接口调用的控制层类，如下所示。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/jobs")
public class JobController {

    @Autowired
    private DynamicJobService dynamicJobService;

    @PostMapping("/schedule")
    public String scheduleJob(
            @RequestParam String jobName,
            @RequestParam String jobParam,
            @RequestParam String cronExpression) {
        try {
            dynamicJobService.scheduleDynamicJob(jobName, jobParam, cronExpression);
            return "Job scheduled successfully";
        } catch (Exception e) {
            return "Error scheduling job: " + e.getMessage();
        }
    }
}

创建完成之后，接下来我们就可以启动项目然后调用http://localhost:8080/api/jobs/schedule接口，并且这个接口接收了三个参数。

• jobName: 任意任务名称，例如 "dynamicJob1"
• jobParam: 动态参数，例如 "Dynamic Param 1"
• cronExpression: Cron表达式，例如 "0/30 * * * * ?"

如下所示，可以发送如下的请求。

curl -X POST "http://localhost:8080/api/jobs/schedule" \
    -d "jobName=dynamicJob1" \
    -d "jobParam=Dynamic Param 1" \
    -d "cronExpression=0/30 * * * * ?"

这个请求将每30秒调度一次任务，执行 DynamicJob 的 execute 方法，并打印传递的参数 "Dynamic Param 1"。

总结

这样我们就实现了一个动态Job的发布和管理。当客户端调用了参数并且传递请求参数 jobName, jobParam, 和cronExpression传递给DynamicJobService的scheduleDynamicJob 方法之后。

在scheduleDynamicJob方法中会创建一个JobDataMap实例，并将请求参数jobParam 存储在其中，接下来创建一个JobDetail实例，并且指定DynamicJob作为逻辑处理实现类，然后通过JobDataMap来传递一个参数。

接下来就是创建了一个Trigger实例对象，通过cronExpression参数作为定时任务的触发时间，这样Quartz的Scheduler会将JobDetail和Trigger注册到调度器中。

当cronExpression参数指定的时间到了之后，就会触发任务调度，每当触发任务调度的时候，就会触发DynamicJob的execute方法，然后从 JobExecutionContext 中获取任务参数，并执行相应的逻辑。在上面的例子中展示的就是一个简单的参数打印操作。当然在实际使用场景中我们可以添加更加复杂的处理逻辑。