spring boot 整合quartz

引入jar 

<!--引入定时任务-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

1.配置信息

package com.qdwy.qudaowuyoutask.util.quartz;

import lombok.extern.slf4j.Slf4j;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.context.annotation.Configuration;

import java.util.Date;

/**
 * @Author zbf
 * @DATA 2019/11/21 15:40
 * @ClassIntroduction
 */

@Slf4j
@Configuration
public class QuartzConfig {
    /**
     * 任务调度
     */
    private static Scheduler scheduler=null;




    public QuartzConfig() {
        try {
            scheduler = new StdSchedulerFactory().getScheduler();
            log.info("初始化调度器 ");
        } catch (SchedulerException ex) {
            log.error("初始化调度器=> [失败]:" + ex.getLocalizedMessage());
        }

    }

    /**
     * 启动定时任务
     */
    public void start() {
        try {
            scheduler.start();
            log.info("启动调度器 ");
        } catch (SchedulerException e) {
            log.error(e.getMessage(),e);
            log.error("启动调度器=> [失败]");
        }
    }


    /**
     * 新增定时任务
     * @param name 定时任务的名称
     * @param group 定时任务分组
     * @param clazz 需要执行的定时任务类
     * @param cronExpression cron 表达式
     */
    public void addJob(String name, String group, Class<? extends Job> clazz, String cronExpression) {
        try {

            //构造任务
            JobDetail jobDetail= JobBuilder.newJob(clazz)
                    .withIdentity(name,group)
                    .build();

            CronScheduleBuilder cronScheduleBuilder=CronScheduleBuilder
                    .cronSchedule(cronExpression);
            //构造任务触发器
            CronTrigger cronTrigger=TriggerBuilder
                    .newTrigger().withIdentity(name,group)
                    .withSchedule(cronScheduleBuilder).build();
            //将作业添加到调度器
            scheduler.scheduleJob(jobDetail,cronTrigger);

        } catch (SchedulerException e) {
            log.error(e.getMessage(),e);
            log.error("创建作业=> [作业名称：" + name + " 作业组：" + group + "]=> [失败]");
        }
    }

    /**
     * 获取Job信息
     * @param name
     * @param group
     */
    public String getjobInfo(String name,String group) throws SchedulerException {
        TriggerKey triggerKey=new TriggerKey(name,group);
        CronTrigger cronTrigger= (CronTrigger) scheduler.getTrigger(triggerKey);
        return String.format("time:%s,state:%s",cronTrigger.getCronExpression(),
                scheduler.getTriggerState(triggerKey).name());
    }

    /**
     * 修改任务的执行时间
     * @param name
     * @param group
     * @param cron cron表达式
     * @return
     * @throws SchedulerException
     */
    public boolean modifyJob(String name,String group,String cron) throws SchedulerException{
        Date date=null;
        TriggerKey triggerKey=new TriggerKey(name, group);
        CronTrigger cronTrigger= (CronTrigger) scheduler.getTrigger(triggerKey);
        String oldTime=cronTrigger.getCronExpression();
        if (!oldTime.equalsIgnoreCase(cron)){
            CronScheduleBuilder cronScheduleBuilder=CronScheduleBuilder.cronSchedule(cron);
            CronTrigger trigger=TriggerBuilder.newTrigger().withIdentity(name,group)
                    .withSchedule(cronScheduleBuilder).build();
            date=scheduler.rescheduleJob(triggerKey,trigger);
        }
        return date !=null;
    }

    /**
     * 暂停所有任务
     * @throws SchedulerException
     */
    public void pauseAllJob()throws SchedulerException{
        scheduler.pauseAll();
    }

    /**
     * 暂停某个任务
     * @param name
     * @param group
     * @throws SchedulerException
     */
    public void pauseJob(String name,String group)throws SchedulerException{
        JobKey jobKey=new JobKey(name,group);
        JobDetail jobDetail=scheduler.getJobDetail(jobKey);
        if (jobDetail==null)
            return;
        scheduler.pauseJob(jobKey);
    }

    /**
     * 恢复所有任务
     * @throws SchedulerException
     */
    public void resumeAllJob()throws SchedulerException{
        scheduler.resumeAll();
    }
    /**
     * 恢复某个任务
     */
    public void resumeJob(String name,String group)throws SchedulerException{
        JobKey jobKey=new JobKey(name,group);
        JobDetail jobDetail=scheduler.getJobDetail(jobKey);
        if (jobDetail==null)
            return;
        scheduler.resumeJob(jobKey);
    }

    /**
     * 删除某个任务
     * @param name
     * @param group
     * @throws SchedulerException
     */
    public void deleteJob(String name,String group)throws SchedulerException{
        JobKey jobKey=new JobKey(name, group);
        JobDetail jobDetail=scheduler.getJobDetail(jobKey);
        if (jobDetail==null)
            return;
        scheduler.deleteJob(jobKey);
    }
}

 2.和数据库进行交互

package com.qdwy.qudaowuyoutask.util.quartz;

import com.qdwy.qudaowuyou.common.constant.QdwyConstant;
import com.qdwy.qudaowuyoubusiness.business.system.QdwyQuartzService;
import com.qdwy.qudaowuyoubusiness.system.entity.SysQuartz;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections.CollectionUtils;
import org.quartz.Job;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;

import java.util.List;

/**
 * @Author zbf
 * @DATA 2019/11/21 16:04
 * @ClassIntroduction
 */
@Slf4j
@Configuration
public class QuartzListener implements ApplicationListener<ContextRefreshedEvent> {

    @Autowired
    private QuartzConfig quartzConfig;
    @Autowired
    private QdwyQuartzService quartzService;


    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        try {
            //1.查询所有的定时任务信息
            List<SysQuartz> sysQuartz = quartzService.getSysQuartz(QdwyConstant.QDWY_QUARTZ_START);
            if (CollectionUtils.isNotEmpty(sysQuartz)){
                Job job = null;
                for (SysQuartz quartz : sysQuartz) {
                   //根据类路径创建工作对象
                    job = (Job) Class.forName(quartz.getQuartzClass()).newInstance();
                     //将工作任务放入工作空间                   quartzConfig.addJob(quartz.getQuartzClass(),quartz.getQuartzGroup(),job.getClass(),quartz.getQuartzCron());
                }
                //启动定时任务
                quartzConfig.start();
                log.info("[启动定时任务结束...]");
            }
            log.info("[没有可执行的定时任务]");
        } catch (Exception e) {
            log.info("启动定时任务异常"+e.getMessage(),e);
        }

    }
}

3.执行自己的job    

 

package com.qdwy.qudaowuyoutask.task;

import com.qdwy.qudaowuyoubusiness.business.system.QdwyQuartzService;
import com.qdwy.qudaowuyoubusiness.system.entity.SysQuartz;
import com.qdwy.qudaowuyoubusiness.system.entity.SysQuartzLog;
import com.qdwy.qudaowuyoutask.util.bean.QdwyBeanUtil;
import lombok.extern.slf4j.Slf4j;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.time.LocalDateTime;

/**
 * @Author zbf
 * @DATA 2019/11/21 15:45
 * @ClassIntroduction
 */
@Slf4j
public class MyJob1 implements Job {


    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        test();
    }


    public void test(){
        QdwyQuartzService quartzService = QdwyBeanUtil.getBean(QdwyQuartzService.class);
         进行业务逻辑处理
        log.info("定时任务需要执行================......");   
    }

}

4.注意：

        spring boot 中不能直接在实现job的接口引用spring容器中的对象

 

解决方法：

       1.将spring 容器公有，可以拿到spring 容器

           

 

     2.建立自己可以获取spring容器中工具

package com.qdwy.qudaowuyoutask.util.bean;

import org.springframework.context.ConfigurableApplicationContext;

/**
 * @Author zbf
 * @DATA 2019/11/21 18:29
 * @ClassIntroduction
 */
public class QdwyBeanUtil {

    //将管理上下文的applicationContext设置成静态变量，供全局调用
    public static ConfigurableApplicationContext applicationContext;
    //定义一个获取已经实例化bean的方法
    public static <T> T getBean(Class<T> c){
        return applicationContext.getBean(c);
    }

}