SpringBoot动态定时任务(完整版)

Spring Boot提供了很好的支持来创建定时任务。但是，有时候我们需要动态地创建和管理定时任务，而不是在代码中硬编码它们。在这种情况下，我们可以使用Spring Boot的动态定时任务功能。

下面是一个完整的示例，演示如何使用Spring Boot创建一个动态定时任务。

首先，我们需要添加以下依赖项到我们的pom.xml文件中：

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

接下来，我们需要创建一个定时任务实体类，它将存储有关我们要创建的定时任务的所有信息。在本例中，我们将创建一个名为ScheduledTask的实体类，它将包含以下属性：

- id：任务ID
- name：任务名称
- cronExpression：任务的Cron表达式
- className：要执行的任务类的全限定名
- methodName：要执行的任务方法的名称

下面是ScheduledTask类的代码：

@Entity
public class ScheduledTask {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;
    private String cronExpression;
    private String className;
    private String methodName;

    // getters and setters
}

接下来，我们需要创建一个JobDetailFactory类，它将负责创建JobDetail对象，该对象将指定要执行的任务类和方法。下面是JobDetailFactory类的代码：

public class JobDetailFactory {
    public static JobDetail createJobDetail(Class<?> jobClass, String jobName) {
        return JobBuilder.newJob(jobClass)
                .withIdentity(jobName)
                .storeDurably()
                .build();
    }
}

接下来，我们需要创建一个TriggerFactory类，它将负责创建Trigger对象，该对象将指定要执行任务的时间。在本例中，我们将使用CronTrigger来指定任务的执行时间。下面是TriggerFactory类的代码：

public class TriggerFactory {
    public static CronTrigger createCronTrigger(String cronExpression) {
        return TriggerBuilder.newTrigger()
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();
    }
}

现在，我们可以创建一个ScheduledTaskService类，它将负责实际创建和管理定时任务。ScheduledTaskService类将依赖于JobDetailFactory和TriggerFactory类来创建JobDetail和Trigger对象。它还将使用SchedulerFactoryBean类来获取Scheduler对象，该对象将用于实际执行任务。下面是ScheduledTaskService类的代码：

@Service
public class ScheduledTaskService {
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;

    public void scheduleTask(ScheduledTask task) throws Exception {
        JobDetail jobDetail = JobDetailFactory.createJobDetail(getJobClass(task.getClassName()), task.getName());
        CronTrigger trigger = TriggerFactory.createCronTrigger(task.getCronExpression());

        schedulerFactoryBean.getScheduler().scheduleJob(jobDetail, trigger);
    }

    public void rescheduleTask(ScheduledTask task) throws Exception {
        TriggerKey triggerKey = new TriggerKey(task.getName());
        CronTrigger oldTrigger = (CronTrigger) schedulerFactoryBean.getScheduler().getTrigger(triggerKey);

        CronTrigger newTrigger = TriggerFactory.createCronTrigger(task.getCronExpression());

        schedulerFactoryBean.getScheduler().rescheduleJob(triggerKey, newTrigger);
    }

    public void unscheduleTask(ScheduledTask task) throws Exception {
        TriggerKey triggerKey = new TriggerKey(task.getName());
        schedulerFactoryBean.getScheduler().unscheduleJob(triggerKey);
        schedulerFactoryBean.getScheduler().deleteJob(JobKey.jobKey(task.getName()));
    }

    private Class<?> getJobClass(String className) throws ClassNotFoundException {
        return Class.forName(className);
    }
}

最后，我们需要创建一个RestController类，它将充当我们的API，用于创建、更新、删除定时任务。下面是ScheduledTaskController类的代码：

@RestController
@RequestMapping("/tasks")
public class ScheduledTaskController {
    @Autowired
    private ScheduledTaskService scheduledTaskService;

    @PostMapping
    public ResponseEntity<?> createTask(@RequestBody ScheduledTask task) {
        try {
            scheduledTaskService.scheduleTask(task);
            return ResponseEntity.ok().build();
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    @PutMapping("/{taskId}")
    public ResponseEntity<?> updateTask(@PathVariable("taskId") Long taskId, @RequestBody ScheduledTask task) {
        try {
            ScheduledTask existingTask = new ScheduledTask();
            existingTask.setId(taskId);

            scheduledTaskService.rescheduleTask(task);
            return ResponseEntity.ok().build();
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }

    @DeleteMapping("/{taskId}")
    public ResponseEntity<?> deleteTask(@PathVariable("taskId") Long taskId) {
        try {
            ScheduledTask task = new ScheduledTask();
            task.setId(taskId);

            scheduledTaskService.unscheduleTask(task);
            return ResponseEntity.ok().build();
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
        }
    }
}

现在我们已经完成了动态定时任务的实现。我们可以使用POST请求创建新的定时任务，使用PUT请求更新现有的定时任务，并使用DELETE请求删除现有的定时任务。