SpringBoot入门十七,添加Quartz定时任务支持

一、环境配置

　　项目基本配置参考SpringBoot入门一,使用myEclipse新建一个SpringBoot项目,使用myEclipse新建一个SpringBoot项目即可。下面开始Quartz整合

二、pom.xml主要配置信息

    
    
        org.springframework.boot
        spring-boot-starter-parent
        2.0.7.RELEASE
        
    

    
    
        UTF-8
        UTF-8
        1.8
        
        -Dfile.encoding=UTF-8
    

    
        
        
        
            org.springframework.boot
            spring-boot-starter-web
        

        
        
            org.springframework.boot
            spring-boot-starter-jdbc
        

        
        
            org.springframework.boot
            spring-boot-starter-thymeleaf
        

        
        
            org.springframework.boot
            spring-boot-starter-tomcat
            provided
        

        
        
            mysql
            mysql-connector-java
        

        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            1.3.2
        

        
        
            com.github.pagehelper
            pagehelper-spring-boot-starter
            1.2.7
        

        
        
            com.alibaba
            fastjson
            1.2.49
        

        
        
            org.springframework.boot
            spring-boot-starter-quartz
        
    

三、配置文件中添加以下配置信息

# mybatis配置
## 配置文件的路径
## mybatis.config-location=mybatis-config.xml
## mybatis映射文件位置
mybatis.mapper-locations=classpath:mybatis/mapping/*/*.xml
## mybatis自动映射实体类别名,多个包以","分割即可
mybatis.type-aliases-package=com.qfx.system.entity,com.qfx.system.vo

# quartz任务配置
spring.quartz.job-store-type=jdbc
spring.quartz.properties.org.quartz.scheduler.instanceName=clusteredScheduler
spring.quartz.properties.org.quartz.scheduler.instanceId=AUTO
spring.quartz.properties.org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
spring.quartz.properties.org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
spring.quartz.properties.org.quartz.jobStore.tablePrefix=QRTZ_
spring.quartz.properties.org.quartz.jobStore.isClustered=true
spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval=2000
spring.quartz.properties.org.quartz.jobStore.useProperties=false
spring.quartz.properties.org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
spring.quartz.properties.org.quartz.threadPool.threadCount=10
spring.quartz.properties.org.quartz.threadPool.threadPriority=5
spring.quartz.properties.org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true

四、编写QrtzJobDetailsMapper.xml

    
        select
            job.job_name as jobName,job.job_group as jobGroup,job.description as description,
            job.job_class_name as jobClassName,cron.cron_expression as cronExpression,
            tri.trigger_name as triggerName,tri.trigger_state as triggerState,
            job.job_name as oldJobName,job.job_group as oldJobGroup
        from
            qrtz_job_details as job
        left join
            qrtz_triggers as tri on job.job_group = tri.job_group and job.job_name = tri.job_name
        left join
            qrtz_cron_triggers as cron on job.job_group = cron.trigger_group and cron.trigger_name = tri.trigger_name
        where
            tri.trigger_type = 'cron'
            
                and job.job_name = #{jobName,jdbcType=VARCHAR}
            
    

五、编写QuartzService.java，Controller接受参数信息直接调用对应的方法即可

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.ObjectAlreadyExistsException;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.qfx.common.bean.MessageBean;
import com.qfx.common.service.BaseService;
import com.qfx.common.utils.Page;
import com.qfx.system.dao.QrtzJobDetailsDao;
import com.qfx.system.vo.QuartzEntity;

/**
 * 
描述:Quartz业务操作类
 * 
 * @author qfx  2019年8月16日 
 */
@Service
public class QuartzService extends BaseService {

    @Autowired
    QrtzJobDetailsDao qrtzJobDetailsDao;
    @Autowired
    private Scheduler scheduler;

    /**
     * 
功能:获取定时任务列表
     * 
     * @author qfx  @date 2019年8月16日
     * @return 
     */
    public Map list() {
        // 获取从request中传递过来的参数信息
        Map paramMap = getMaps();
        // 获取分页信息
        Page page = getPage(paramMap);
        PageHelper.startPage(page.getCurrentPage(), page.getPageSize());
        List list = qrtzJobDetailsDao.selectAll(paramMap);

        PageInfo pageInfo = new PageInfo(list);
        //获得总条数
        long total = pageInfo.getTotal();

        Map dataMap = new HashMap();
        dataMap.put("code", 0);
        dataMap.put("count", total);
        dataMap.put("data", pageInfo.getList());

        return dataMap;
    }

    /**
     * 
功能:验证任务名称是否已经存在
     * 
     * @author qfx  @date 2019年8月16日
     * @return 
     */
    public MessageBean validateJobName() {
        MessageBean messageBean = new MessageBean();
        int count = Integer.parseInt(list().get("count").toString());
        if (count > 0) {
            messageBean.setResult(false);
            messageBean.setMessage("当前任务名称已存在");
        }
        return messageBean;
    }

    // ==================== 往下为Quartz业务方法 ====================

    /**
     * 
功能:重新编辑定时任务
     * 
     * @author qfx  @date 2019年8月16日
     * @param quartz
     * @return 
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    public MessageBean edit(QuartzEntity quartz) {
        MessageBean messageBean = new MessageBean();
        String processingType ="新增";
        try {
            JobDataMap jobDataMap = null;
            // 1.验证是否是修改操作,如果是,则删除旧的任务
            if(quartz.getOldJobGroup()!= null && quartz.getOldJobGroup()!= ""){
                processingType = "修改";
                JobKey key =JobKey.jobKey(quartz.getOldJobName(),quartz.getOldJobGroup());
                JobDetail jobDetail = scheduler.getJobDetail(key);
                jobDataMap = jobDetail.getJobDataMap();
                for (String key1 : jobDataMap.keySet()) {
                    System.out.println(key1 + ":" + jobDataMap.get(key1));
                }
                key = new JobKey(quartz.getOldJobName(),quartz.getOldJobGroup());
                scheduler.deleteJob(key);
            }
            // 2.开始构建新的定时任务
            Class cls = Class.forName(quartz.getJobClassName()) ;
            cls.newInstance();
            // 2.1 构建新的job信息
            JobDetail job = JobBuilder.newJob(cls)
                    .withIdentity(quartz.getJobName(), quartz.getJobGroup())    //job名称和分组名称
                    .withDescription(quartz.getDescription())   //描述信息
                    .build();
            // 2.2 添加JobDataMap数据,如果没有则不需要配置
//          JobDataMap jobDataMap = new JobDataMap();
//          jobDataMap.put("userName", "zhangsan");
//          jobDataMap.put("age", 18);
//          job.getJobDataMap().putAll(jobDataMap);
            if (jobDataMap != null) {
                job.getJobDataMap().putAll(jobDataMap);
            }

            // 2.3 设置触发时间点
            CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder
                    .cronSchedule(quartz.getCronExpression())
                    // 表示等待下次Cron触发频率到达时刻开始按照Cron频率依次执行(即暂停期间的不再执行,去掉则表示补充执行)
                    .withMisfireHandlingInstructionDoNothing();
            // 2.4 设置触发器
            Trigger trigger = TriggerBuilder
                    .newTrigger()
                    .withIdentity("trigger" + quartz.getJobName(),quartz.getJobGroup()) //job名称和分组名称
//                  // 使用 Cron 表达式时,StartNow 方法不会起任何效果,Cron 有其自己的执行时间。目前看来 StartNow 应该只适用于 SimpleTrigger 触发器
//                  .startNow() // 一旦加入scheduler,立即生效()
                    .withSchedule(cronScheduleBuilder) //执行时间
                    .build();
            // 2.5 交由Scheduler安排触发
            scheduler.scheduleJob(job, trigger);
            messageBean.setMessage("定时任务[" + quartz.getJobName() + "]" + processingType +"成功~!");
        } catch (ClassNotFoundException e) {
            messageBean.setResult(false);
            messageBean.setMessage("要" + processingType +"的任务类[" + quartz.getJobClassName() + "]不存在,定时任务" + processingType +"失败~!");
            e.printStackTrace();
        } catch(ObjectAlreadyExistsException e){
            messageBean.setResult(false);
            messageBean.setMessage("当前分组定时任务[" + quartz.getJobName() + "]已存在,操作失败~!");
            e.printStackTrace();
        } catch (Exception e) {
            messageBean.setResult(false);
            messageBean.setMessage(processingType +"定时任务[" + quartz.getJobName() + "]发生异常,操作失败~!");
            e.printStackTrace();
        }
        return messageBean;
    }

    /**
     * 
功能:删除一个定时任务
     * 
     * @author qfx  @date 2019年8月16日
     * @param quartz
     * @return 
     */
    public MessageBean del(QuartzEntity quartz) {
        MessageBean messageBean = new MessageBean();
        try {  
            TriggerKey triggerKey = TriggerKey.triggerKey(quartz.getJobName(), quartz.getJobGroup());  
            // 停止触发器  
            scheduler.pauseTrigger(triggerKey);  
            // 移除触发器  
            scheduler.unscheduleJob(triggerKey);  
            // 删除任务  
            scheduler.deleteJob(JobKey.jobKey(quartz.getJobName(), quartz.getJobGroup()));  
            System.out.println("removeJob:"+JobKey.jobKey(quartz.getJobName()));
            messageBean.setMessage("定时任务[" + quartz.getJobName() + "]删除成功~!");
        } catch (Exception e) {
            messageBean.setResult(false);
            messageBean.setMessage("删除定时任务[" + quartz.getJobName() + "]发生异常,操作失败~!");
            e.printStackTrace();
        }  
        return messageBean;
    }

    /**
     * 
功能:暂停一个定时任务
     * 
     * @author qfx  @date 2019年8月16日
     * @param quartz
     * @return 
     */
    public MessageBean pause(QuartzEntity quartz) {
        MessageBean messageBean = new MessageBean();
        try {
            JobKey key = new JobKey(quartz.getJobName(), quartz.getJobGroup());
            scheduler.pauseJob(key);
            messageBean.setMessage("定时任务[" + quartz.getJobName() + "]停止成功~!");
        } catch (SchedulerException e) {
            messageBean.setResult(false);
            messageBean.setMessage("停止定时任务[" + quartz.getJobName() + "]发生异常,操作失败~!");
            e.printStackTrace();
        }
        return messageBean;
    }

    /**
     * 
功能:重新开始一个定时任务
     * 
     * @author qfx  @date 2019年8月16日
     * @param quartz
     * @return 
     */
    public MessageBean resume(QuartzEntity quartz) {
        MessageBean messageBean = new MessageBean();
        try {
             JobKey key = new JobKey(quartz.getJobName(),quartz.getJobGroup());
             scheduler.resumeJob(key);
             messageBean.setMessage("定时任务[" + quartz.getJobName() + "]恢复成功~!");
        } catch (SchedulerException e) {
            messageBean.setResult(false);
            messageBean.setMessage("恢复定时任务[" + quartz.getJobName() + "]发生异常,操作失败~!");
            e.printStackTrace();
        }
        return messageBean;
    }

    /**
     * 
功能:暂停所有定时任务
     * 
     * @author qfx  @date 2019年8月16日
     * @return 
     */
    public MessageBean pauseAll() {
        MessageBean messageBean = new MessageBean();
        try {
            if (!scheduler.isShutdown()) {  
                scheduler.pauseAll(); 
            }
            messageBean.setMessage("定时任务全部暂停执行成功~!");
        } catch (SchedulerException e) {
            messageBean.setResult(false);
            messageBean.setMessage("定时任务全部暂停执行发生异常,操作失败~!");
            e.printStackTrace();
        }  
        return messageBean;
    }

    /**
     * 
功能:重新开启所有定时任务
     * 
     * @author qfx  @date 2019年8月16日
     * @return 
     */
    public MessageBean resumeAll() {
        MessageBean messageBean = new MessageBean();
        try {
            scheduler.resumeAll();
            messageBean.setMessage("定时任务全部开启执行成功~!");
        } catch (SchedulerException e) {
            messageBean.setResult(false);
            messageBean.setMessage("定时任务全部开启执行发生异常,操作失败~!");
            e.printStackTrace();
        }  
        return messageBean;
    }
}

六、编写测试定时任务

// 测试任务一
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class TaskTest01 extends QuartzJobBean {
    private final Logger log = LoggerFactory.getLogger(this.getClass());

    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        log.info("[{}]执行了一条新的任务", this.getClass().getName());
    }
}

// 测试任务二
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class TaskTest02 extends QuartzJobBean {
    private final Logger log = LoggerFactory.getLogger(this.getClass());

    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        log.info("[{}]执行了一条新的任务", this.getClass().getName());
    }
}

// 测试任务三
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

public class TaskTest03 extends QuartzJobBean {
    private final Logger log = LoggerFactory.getLogger(this.getClass());

    @Override
    protected void executeInternal(JobExecutionContext arg0) throws JobExecutionException {
        log.info("[{}]执行了一条新的任务", this.getClass().getName());
    }
}

七、启动测试

从页面上进行操作测试

后台显示信息,可以看到三个定时任务都已经在正常运行了

8、源码

移步码云下载