1、导入相关依赖包
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
<version>2.2.6.RELEASE</version>
</dependency>
<dependency><!-- 该依赖必加,里面有sping对schedule的支持 -->
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz</artifactId>
<version>2.2.3</version>
</dependency>
<dependency>
<groupId>org.quartz-scheduler</groupId>
<artifactId>quartz-jobs</artifactId>
<version>2.2.3</version>
</dependency>
2、创建一个QuartzUtils工具类内容如下
public class QuartzUtils {
/**
* 创建定时任务 定时任务创建之后默认启动状态
*
* @param scheduler 调度器
* @param quartzBean 定时任务信息类
* @throws Exception
*/
public static void createScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {
try {
//获取到定时任务的执行类 必须是类的绝对路径名称
//定时任务类需要是job类的具体实现 QuartzJobBean是job的抽象类。
Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(quartzBean.getJobClass());
// 构建定时任务信息->jobName就是QuartzBean类里面的变量,根据自己实际命明的来
JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(quartzBean.getJobName()).usingJobData("jobName",quartzBean.getJobName()).build();
// 设置定时任务执行方式
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
// 构建触发器trigger
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(quartzBean.getJobName()).withSchedule(scheduleBuilder).build();
scheduler.scheduleJob(jobDetail, trigger);
} catch (ClassNotFoundException e) {
System.out.println("定时任务类路径出错:请输入类的绝对路径");
} catch (SchedulerException e) {
System.out.println("创建定时任务出错:" + e.getMessage());
}
}
/**
* 根据任务名称暂停定时任务
*
* @param scheduler 调度器
* @param jobName 定时任务名称
* @throws SchedulerException
*/
public static void pauseScheduleJob(Scheduler scheduler, String jobName) {
JobKey jobKey = JobKey.jobKey(jobName);
try {
scheduler.pauseJob(jobKey);
} catch (SchedulerException e) {
System.out.println("暂停定时任务出错:" + e.getMessage());
}
}
/**
* 根据任务名称恢复定时任务
*
* @param scheduler 调度器
* @param jobName 定时任务名称
* @throws SchedulerException
*/
public static void resumeScheduleJob(Scheduler scheduler, String jobName) {
JobKey jobKey = JobKey.jobKey(jobName);
try {
scheduler.resumeJob(jobKey);
} catch (SchedulerException e) {
System.out.println("启动定时任务出错:" + e.getMessage());
}
}
/**
* 根据任务名称立即运行一次定时任务
*
* @param scheduler 调度器
* @param jobName 定时任务名称
* @throws SchedulerException
*/
public static void runOnce(Scheduler scheduler, String jobName) {
JobKey jobKey = JobKey.jobKey(jobName);
try {
scheduler.triggerJob(jobKey);
} catch (SchedulerException e) {
System.out.println("运行定时任务出错:" + e.getMessage());
}
}
/**
* 更新定时任务
*
* @param scheduler 调度器
* @param quartzBean 定时任务信息类
* @throws SchedulerException
*/
public static void updateScheduleJob(Scheduler scheduler, QuartzBean quartzBean) {
try {
//获取到对应任务的触发器
TriggerKey triggerKey = TriggerKey.triggerKey(quartzBean.getJobName());
//设置定时任务执行方式
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzBean.getCronExpression());
//重新构建任务的触发器trigger
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
//重置对应的job
scheduler.rescheduleJob(triggerKey, trigger);
} catch (SchedulerException e) {
System.out.println("更新定时任务出错:" + e.getMessage());
}
}
/**
* 根据定时任务名称从调度器当中删除定时任务
*
* @param scheduler 调度器
* @param jobName 定时任务名称
* @throws SchedulerException
*/
public static void deleteScheduleJob(Scheduler scheduler, String jobName) {
JobKey jobKey = JobKey.jobKey(jobName);
try {
scheduler.deleteJob(jobKey);
} catch (SchedulerException e) {
System.out.println("删除定时任务出错:" + e.getMessage());
}
}
}
3、创建一个业务程序类TaskTest并继承QuartzJobBean类
@Configurable
@Component
public class TaskTest extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
//TODO 这里写定时任务的执行逻辑
JobDetail detail = jobExecutionContext.getJobDetail();//获取任务工具类里边传入的参数
String jobName = detail.getJobDataMap().getString("jobName");//因为任务工具类里面写的
是jobName,所以保持一致
System.out.println("动态的定时任务执行时间:"+jobName);
}
}
4、创建一个测试类,测试一下是否可以正常运行TaskTestController,并在启动类加上
@EnableScheduling注解
@RestController
@RequestMapping("/api/quartz/")
public class QuartzController {
@Autowired
private Scheduler scheduler;
@Autowired
private AreaInfoService areaInfoService;
@RequestMapping("/createJob")
@ResponseBody
public String createJob(QuartzBean quartzBean) {
try {
//进行测试所以写死
String classPath=TaskTest.class.toString();
quartzBean.setJobClass(classPath.substring(6,classPath.length()));
UUID uuid = UUID.randomUUID();
quartzBean.setJobName(uuid.toString());
String cron="*/5 * * * * ?";
quartzBean.setCronExpression(cron);
QuartzUtils.createScheduleJob(scheduler, quartzBean);
} catch (Exception e) {
return "创建失败";
}
return "创建成功";
}
@RequestMapping("/pauseJob")
@ResponseBody
public String pauseJob(String jobName) {
try {
QuartzUtils.pauseScheduleJob(scheduler, jobName);
} catch (Exception e) {
return "暂停失败";
}
return "暂停成功";
}
@RequestMapping("/runOnce")
@ResponseBody
public String runOnce(String jobName) {
try {
QuartzUtils.runOnce(scheduler, jobName);
} catch (Exception e) {
return "运行一次失败";
}
return "运行一次成功";
}
@RequestMapping("/resume")
@ResponseBody
public String resume(String jobName) {
try {
QuartzUtils.resumeScheduleJob(scheduler, jobName);
} catch (Exception e) {
return "启动失败";
}
return "启动成功";
}
@RequestMapping("/update")
@ResponseBody
public String update(QuartzBean quartzBean) {
try {
//进行测试所以写死
String classPath=TaskTest.class.toString();
quartzBean.setJobClass(classPath.substring(6,classPath.length()));
quartzBean.setCronExpression("10 * * * * ?");
QuartzUtils.updateScheduleJob(scheduler, quartzBean);
} catch (Exception e) {
return "启动失败";
}
return "启动成功";
}
@GetMapping("deleteScheduleJob")
public String deleteScheduleJob(String jobName){
try{
QuartzUtils.deleteScheduleJob(scheduler,jobName);
}catch (Exception e){
e.printStackTrace();
return "删除失败";
}
return "删除成功";
}
}
5、运行结果
6、这里设置服务器重启或重新部署后,定时器自启
6.1、创建一个QuartzTask类并实现ServletContexeAware接口
@Component
public class QuartzTask implements ServletContextAware {
private static final Logger logger = LoggerFactory.getLogger(DayScheduledTask.class);
@Autowired
private Scheduler scheduler;
@Autowired
private ImmuneReportMapper immuneReportMapper;
/**
* 服务重启自动调用定时器
*
* @param servletContext
*/
@Override
public void setServletContext(ServletContext servletContext) {//根据自己的实际业务场景去写,这是我写的一个样列
logger.info("任务开始创建");
ImmuneReport immuneReport = new ImmuneReport();
List<ImmuneReport> list = immuneReportMapper.list(immuneReport);
if (list.size() > 0) {
ImmuneReport report = list.get(0);
if (report.getReportStatus() == 1) {
QuartzBean quartzBean = new QuartzBean();
quartzBean.setJobName("test");
quartzBean.setJobClass("com.airport.task.DayScheduledTask");
List<String> days = Arrays.stream(report.getReportTime().split(":")).collect(Collectors.toList());
StringBuilder builder = new StringBuilder();
//设置定时器
builder.append(days.get(2)).append(" ").append(days.get(1)).append(" ").append(days.get(0)).append(" * * ?");
quartzBean.setCronExpression(builder.toString());
QuartzUtils.createScheduleJob(scheduler, quartzBean);
builder=null;
quartzBean=null;
}
}
immuneReport=null;
logger.info("任务创建结束");
}
}
到此关于Quartz定时器定时执行业务程序就结束了