springboot简单的整合Quartz实现定时任务

Quartz：这是一个功能比较强大的的调度器，可以让我们的程序在指定时间执行，也可以按照某一个频度执行。quartz是一个完全基于Java实现的任务调度开源框架，可为java应用程序中的作业调度提供了功能强大的机制的调度功能，调度方法丰富多样灵活且任务和触发器可以有多种组合方式。

第一步引入maven

这是quartz的maven springboot的就不贴了-.-

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

第二步工具类

package com.xk.util;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import com.xk.model.SpringScheduledCron;
public class Quartzutil {

	
	 /**
     * @param scheduler   调度器
     * @param springScheduledDao  定时任务信息类
     * @throws Exception
     */
    public static void createScheduleJob(Scheduler scheduler, SpringScheduledCron springScheduledDao){
        try {
            //获取到定时任务的执行类  必须是类的绝对路径名称
            Class<? extends Job> jobClass = (Class<? extends Job>) Class.forName(springScheduledDao.getCronkey());
            // 构建定时任务信息也就是job的key后面通过这个key进行管理
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(springScheduledDao.getCronid()+"").build();
            // 设置定时任务执行方式 也就是周期 cron表达式一般是
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(springScheduledDao.getCronexpression());
            // 构建触发器trigger
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(springScheduledDao.getCronid()+"").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);
            System.out.println("暂停定时任务成功："+jobKey);
        } catch (SchedulerException e) {
            System.out.println("暂停定时任务出错："+e.getMessage());
        }
    }

    /**
     * 根据任务名称恢复定时任务
     * @param scheduler  调度器
     * @param jobName    定时任务名称 key
     * @throws SchedulerException
     */
    public static void resumeScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.resumeJob(jobKey);
            System.out.println("启动定时任务成功："+jobKey);
        } catch (SchedulerException e) {
            System.out.println("启动定时任务出错："+e.getMessage());
        }
    }

    /**
     * 根据任务名称立即运行一次定时任务
     * @param scheduler     调度器
     * @param jobName      定时任务名称 key
     * @throws SchedulerException
     */
    public static void runOnce(Scheduler scheduler, String jobName){
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.triggerJob(jobKey);
            System.out.println("运行定时任务成功");
        } catch (SchedulerException e) {
            System.out.println("运行定时任务出错："+e.getMessage());
        }
    }

    /**
     * 更新定时任务
     * @param scheduler   调度器
     * @param springScheduledDao  定时任务信息类
     * @throws SchedulerException
     */
    public static void updateScheduleJob(Scheduler scheduler, SpringScheduledCron springScheduledDao)  {
        try {
            //获取到对应任务的触发器 key
            TriggerKey triggerKey = TriggerKey.triggerKey(springScheduledDao.getCronid()+"");
            //设置定时任务执行方式 也就是周期
            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(springScheduledDao.getCronexpression());
            //重新构建任务的触发器trigger
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
            //重置对应的job
            scheduler.rescheduleJob(triggerKey, trigger);
            System.out.println("更新定时任务成功");
        } catch (SchedulerException e) {
            System.out.println("更新定时任务出错："+e.getMessage());
        }
    }

    /**
     * 根据定时任务名称从调度器当中删除定时任务
     * @param scheduler 调度器
     * @param jobName   定时任务名称 key
     * @throws SchedulerException
     */
    public static void deleteScheduleJob(Scheduler scheduler, String jobName) {
        JobKey jobKey = JobKey.jobKey(jobName);
        try {
            scheduler.deleteJob(jobKey);
            System.out.println("删除定时任务成功");
        } catch (SchedulerException e) {
            System.out.println("删除定时任务出错："+e.getMessage());
        }
    }
}

第三步创建定时任务类

package com.xk.util;

import org.quartz.JobExecutionContext;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class MyTask extends QuartzJobBean {

    @Override
    protected void executeInternal(JobExecutionContext jobExecutionContext){
    	String key = jobExecutionContext.getJobDetail().getKey().toString();
    	System.err.println(key+"key");
    }
}

如果想项目启动时去加载数据库的定时任务还需配一个监听

package com.xk.util;

import java.util.List;

import org.quartz.Scheduler;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import com.xk.mapper.SpringScheduledDao;
import com.xk.mapper.UserDao;
import com.xk.model.SpringScheduledCron;
@Component
@Order(value = 1)
public class ScheduleJobInitListener implements CommandLineRunner{
//dao层查询数据
	@Autowired
	SpringScheduledDao userinfo;
	//调度器
	 @Autowired
	    private Scheduler scheduler;
	@Override
	public void run(String... args) throws Exception {
		// TODO Auto-generated method stub
		List<SpringScheduledCron> selectList = userinfo.selectList(null);
		  for (SpringScheduledCron task : selectList) {
		    //值为1时创建任务
	            if (task.getStatus()==1) {
	            	QuartzUtils.createScheduleJob(scheduler,task);
	            }
	        }
		
	}

}

其他的就和正常项目一样的去嗲用就可以了
注意在Controller要
//注入任务调度
@Autowired
private Scheduler scheduler;

测试

最后贴一下Controller

 //注入任务调度
    @Autowired
    private Scheduler scheduler;
    
	@Autowired
	SpringScheduledDao springScheduledDao;

 @RequestMapping("updatejsp")
	  @ResponseBody
	  public Map<String, Object> update(SpringScheduledCron springScheduledCron){
		  Map<String, Object> map= new HashMap<>();
		  //1是去启动状态定时任务
		  if(springScheduledCron.getStatus()==1) {
			  springScheduledDao.updateById(springScheduledCron);
			  QuartzUtils.updateScheduleJob(scheduler,springScheduledCron);
		  }else {
//0是停止定时任务有
			  springScheduledDao.updateById(springScheduledCron);
		  }
			map.put("code", 200);
		return map;
	  }

感兴趣的可以试一下很简单的整合~