springboot+vue+quartz 动态定时任务

好的，动态定时任务一般需要以下几个步骤：

1. 在后端使用 SpringBoot 和 Quartz，定义一个定时任务类，继承自 Quartz 的 Job 接口，并实现其中的 execute 方法。

2. 在定时任务类中，编写需要执行的任务逻辑。

3. 在定时任务类中，添加一些参数，用于动态设置定时任务的执行时间和执行频率。这些参数可以通过注解或者配置文件进行设置。

4. 在前端使用 Vue，创建一个页面，用于展示所有已经添加的定时任务，并且可以动态添加、修改和删除定时任务。

5. 在前端页面中，使用 axios 或者其他 AJAX 库，向后端发送添加、修改和删除定时任务的请求。

6. 后端接收到前端的请求后，根据请求的参数，动态创建、修改或删除 Quartz 定时任务。

具体实现可以参照以下步骤：

1. 在后端使用 SpringBoot 和 Quartz，定义一个定时任务类，如下所示：

@Component
public class MyJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 编写需要执行的任务逻辑
    }
}

2. 在定时任务类中，添加一些参数，用于动态设置定时任务的执行时间和执行频率，如下所示：

@Component
public class MyJob implements Job {

    @Value("${job.trigger.cron}")
    private String cronExpression;

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 编写需要执行的任务逻辑
    }

    public void setCronExpression(String cronExpression) {
        this.cronExpression = cronExpression;
    }
}

在这里，我们使用了 @Value 注解来从配置文件中读取 cron 表达式，然后通过 setter 方法将其设置到定时任务类中。

3. 在前端使用 Vue，创建一个页面，用于展示所有已经添加的定时任务，并且可以动态添加、修改和删除定时任务。具体实现可以参考以下代码：

<template>
  <div>
    <h2>定时任务列表</h2>
    <table>
      <thead>
        <tr>
          <th>ID</th>
          <th>名称</th>
          <th>状态</th>
          <th>操作</th>
        </tr>
      </thead>
      <tbody>
        <tr v-for="job in jobs" :key="job.id">
          <td>{{ job.id }}</td>
          <td>{{ job.name }}</td>
          <td>{{ job.status }}</td>
          <td>
            <button @click="editJob(job)">编辑</button>
            <button @click="deleteJob(job)">删除</button>
          </td>
        </tr>
      </tbody>
    </table>
    <button @click="addJob()">添加定时任务</button>
    <div v-if="showEditDialog">
      <h3>{{ dialogTitle }}</h3>
      <form>
        <div>
          <label>名称：</label>
          <input type="text" v-model="job.name">
        </div>
        <div>
          <label>状态：</label>
          <select v-model="job.status">
            <option value="启用">启用</option>
            <option value="停用">停用</option>
          </select>
        </div>
        <div>
          <label>执行时间：</label>
          <input type="text" v-model="job.trigger.cron">
        </div>
        <button @click="saveJob()">保存</button>
        <button @click="closeDialog()">关闭</button>
      </form>
    </div>
  </div>
</template>

<script>
import axios from 'axios'

export default {
  data() {
    return {
      jobs: [],
      job: {
        id: null,
        name: '',
        status: '启用',
        trigger: {
          cron: ''
        }
      },
      showEditDialog: false,
      dialogTitle: ''
    }
  },
  created() {
    this.getJobs()
  },
  methods: {
    getJobs() {
      axios.get('/api/jobs')
        .then(response => {
          this.jobs = response.data
        })
        .catch(error => {
          console.log(error)
        })
    },
    addJob() {
      this.job.id = null
      this.job.name = ''
      this.job.status = '启用'
      this.job.trigger.cron = ''
      this.dialogTitle = '添加定时任务'
      this.showEditDialog = true
    },
    editJob(job) {
      this.job.id = job.id
      this.job.name = job.name
      this.job.status = job.status
      this.job.trigger.cron = job.trigger.cron
      this.dialogTitle = '编辑定时任务'
      this.showEditDialog = true
    },
    saveJob() {
      if (this.job.id == null) {
        axios.post('/api/jobs', this.job)
          .then(response => {
            this.getJobs()
            this.showEditDialog = false
          })
          .catch(error => {
            console.log(error)
          })
      } else {
        axios.put('/api/jobs/' + this.job.id, this.job)
          .then(response => {
            this.getJobs()
            this.showEditDialog = false
          })
          .catch(error => {
            console.log(error)
          })
      }
    },
    deleteJob(job) {
      axios.delete('/api/jobs/' + job.id)
        .then(response => {
          this.getJobs()
        })
        .catch(error => {
          console.log(error)
        })
    },
    closeDialog() {
      this.showEditDialog = false
    }
  }
}
</script>

在这里，我们使用了 axios 库来向后端发送 HTTP 请求，并且使用了 v-for 和 v-model 指令来实现页面数据的绑定和循环展示。

4. 在后端使用 SpringBoot 和 Quartz，创建一个 RESTful API，用于接收前端页面发送的添加、修改和删除定时任务的请求。具体实现可以参考以下代码：

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

    @Autowired
    private Scheduler scheduler;

    @GetMapping("")
    public List<JobDetail> getAllJobs() throws SchedulerException {
        List<JobDetail> jobs = new ArrayList<>();
        for (String groupName : scheduler.getJobGroupNames()) {
            for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
                JobDetail jobDetail = scheduler.getJobDetail(jobKey);
                jobs.add(jobDetail);
            }
        }
        return jobs;
    }

    @PostMapping("")
    public void addJob(@RequestBody JobDetail jobDetail) throws SchedulerException {
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        String jobName = jobDataMap.getString("jobName");
        String jobGroup = jobDataMap.getString("jobGroup");
        String jobClass = jobDataMap.getString("jobClass");
        String cronExpression = jobDataMap.getString("cronExpression");

        JobDetail newJob = JobBuilder.newJob()
                .withIdentity(jobName, jobGroup)
                .ofType((Class<? extends Job>) Class.forName(jobClass))
                .build();

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

        scheduler.scheduleJob(newJob, trigger);
    }

    @PutMapping("/{id}")
    public void updateJob(@PathVariable("id") String id, @RequestBody JobDetail jobDetail) throws SchedulerException {
        JobDataMap jobDataMap = jobDetail.getJobDataMap();
        String jobName = jobDataMap.getString("jobName");
        String jobGroup = jobDataMap.getString("jobGroup");
        String jobClass = jobDataMap.getString("jobClass");
        String cronExpression = jobDataMap.getString("cronExpression");

        JobKey jobKey = new JobKey(jobName, jobGroup);
        JobDetail oldJob = scheduler.getJobDetail(jobKey);

        JobDetail newJob = JobBuilder.newJob()
                .withIdentity(jobName, jobGroup)
                .ofType((Class<? extends Job>) Class.forName(jobClass))
                .build();
        newJob.getJobDataMap().putAll(oldJob.getJobDataMap());

        TriggerKey triggerKey = new TriggerKey(jobName + "Trigger", jobGroup);
        Trigger oldTrigger = scheduler.getTrigger(triggerKey);

        Trigger newTrigger = TriggerBuilder.newTrigger()
                .withIdentity(jobName + "Trigger", jobGroup)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();

        scheduler.scheduleJob(newJob, newTrigger);
    }

    @DeleteMapping("/{id}")
    public void deleteJob(@PathVariable("id") String id) throws SchedulerException {
        String[] ids = id.split(":");
        String jobName = ids[0];
        String jobGroup = ids[1];

        JobKey jobKey = new JobKey(jobName, jobGroup);
        scheduler.deleteJob(jobKey);
    }
}

在这里，我们使用了 Quartz 的 Scheduler 接口来动态创建、修改和删除定时任务，并且使用了 @RequestBody、@PostMapping、@PutMapping 和 @DeleteMapping 注解来接收前端页面发送的请求。

5. 最后，在 SpringBoot 应用程序的配置文件中，添加 Quartz 的相关配置，如下所示：

quartz:
  job-store-type: memory
  properties:
    org:
      quartz:
        scheduler:
          instanceName: myScheduler
          instanceId: AUTO
          jobFactory:
            class: org.springframework.scheduling.quartz.SpringBeanJobFactory
          jobStore:
            class: org.quartz.simpl.RAMJobStore
          threadPool:
            class: org.quartz.simpl.SimpleThreadPool
            threadCount: 10
            threadPriority: 5
            threadsInheritContextClassLoaderOfInitializingThread: true

在这里，我们设置了 Quartz 的存储类型为内存存储，以及一些基本的配置项，如线程池大小和线程优先级等。

以上就是动态定时任务的实现步骤，希望对你有所帮助！