Quartz

1.Quartz总结

2.Quartz核心组件API

• 任务
  
• 调度器
  
• 调度器实现类
  
• 触发器
  
• 任务详情
  
• 钥匙
  
• Quartz运行时上下文JobExecutionContext
  
• 调度器工厂
  

3.Quartz的建造者

4.Quartz的监听器

• 调度器的监听器
  
• 触发器的监听器
  
• 任务的监听器
  

5.SpringBoot整合Quartz

• 搭建SpringBoot基础环境并导入Quartz依赖

<!--Quartz任务调度的包 -->
   <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz</artifactId>
        <version>2.2.1</version>
    </dependency>
    <dependency>
        <groupId>org.quartz-scheduler</groupId>
        <artifactId>quartz-jobs</artifactId>
        <version>2.2.1</version>
    </dependency>
<!--常用工具类-->
    <dependency>
          <groupId>org.apache.commons</groupId>
          <artifactId>commons-lang3</artifactId>
          <version>3.10</version>
      </dependency>

• 编写Job接口实现类Job1 和Job2

import org.apache.commons.lang3.time.DateFormatUtils;
import org.quartz.*;

import java.util.Date;

//@PersistJobDataAfterExecution注解：开启job1对象复用(可选)
@PersistJobDataAfterExecution
//默认调度器执行完任务后，任务就被释放了，也就说每次执行job1都在new
public class Job1 implements Job {
    //JobExecutionContext 任务执行上下文
    @Override
    public void execute(JobExecutionContext context)
    {
        System.out.println("写业务逻辑的地方...."+ DateFormatUtils.format(new Date(),"HH:mm:ss"));
        JobKey jobKey = context.getJobDetail().getKey();
        String jobName = jobKey.getName();
        String jobGroup = jobKey.getGroup();
        Class<? extends JobKey> jobClass = jobKey.getClass();
        System.out.printf("当前任务信息::jobName=%s,jobGroup=%s,jobClass=%s\n",jobName,jobGroup,jobClass);
        
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();
        int count = (int)jobDataMap.get("count");
        jobDataMap.put("count",++count);
        System.out.println("JOB1_COUNT_INFO = " + count);

        JobDataMap triggerMap = context.getTrigger().getJobDataMap();
        System.out.println("triggerMap = " +  triggerMap.get("message"));
    }
}

import org.apache.commons.lang3.time.DateFormatUtils;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;


public class Job2 implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("Job2....."+ DateFormatUtils.format(new Date(),"HH:mm:ss"));
    }
}

• 编写任务监听器接口的实现类（局部监听或全局监听）‘

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.JobListener;

public class MyJobListener implements JobListener {
    @Override
    public String getName()
    {
        String simpleName = this.getClass().getSimpleName();
        System.out.println("getName()监听器的名称..."+simpleName);
        return simpleName;
    }

    @Override
    public void jobToBeExecuted(JobExecutionContext context)
    {
        String jobName = context.getJobDetail().getKey().getName();
        System.out.println("jobToBeExecuted()要执行的工作 = " + jobName);
    }

    @Override
    public void jobExecutionVetoed(JobExecutionContext context) {
        String jobName = context.getJobDetail().getKey().getName();
        System.out.println("jobExecutionVetoed()工作执行否决 = " + jobName);
    }

    @Override
    public void jobWasExecuted(JobExecutionContext context, JobExecutionException e) {
        String jobName = context.getJobDetail().getKey().getName();
        System.out.println("jobWasExecuted()工作被执行完 = " + jobName);
    }
}

• 编写Quartz的Service层

import org.quartz.*;
import org.quartz.impl.matchers.KeyMatcher;
import org.springframework.context.annotation.Configuration;

import javax.annotation.Resource;
import java.util.Date;

@Configuration
public class QuartzScheduler {
    @Resource
    private Scheduler scheduler;
    //通用开启任务方法
    public void startJob(Scheduler scheduler,Class<?extends Job> jobClazz,String jobName,String jobGroup) throws SchedulerException {
        //JobBuilder构建jobDetail
        JobDetail jobDetail = JobBuilder.newJob(jobClazz)
                //任务的name:唯一名字,  group:分组名
                .withIdentity(jobName, jobGroup)
                .usingJobData("count",0)
                .build();
        //基于表达式构建触发器
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");

        CronTrigger cronTrigger =
                TriggerBuilder.newTrigger()
                 //触发器的name:唯一名字,  group:分组名
                .withIdentity(jobName, jobGroup)
                .usingJobData("message","cronTrigger")
                .withSchedule(cronScheduleBuilder).build();
        scheduler.scheduleJob(jobDetail,cronTrigger);
    }
    //1.开始执行所有任务
    public void startAllJob() throws SchedulerException {
        ListenerManager listenerManager = scheduler.getListenerManager();
        //全局监听
        // listenerManager.addJobListener(new MyJobListener(), EverythingMatcher.allJobs());
        //局部监听
        listenerManager.addJobListener(new MyJobListener(), KeyMatcher.keyEquals(JobKey.jobKey("job1","group1")));
        startJob(scheduler,Job1.class,"job1","group1");
        startJob(scheduler,Job2.class,"job2","group1");
        scheduler.start();
    }
    //2.获取Job信息
    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());
    }
    //3.暂停某个任务
    public boolean pauseJob(String name,String group) throws SchedulerException {
        JobKey jobKey = new JobKey(name, group);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (null==jobDetail) return false;
        scheduler.pauseJob(jobKey);
        return true;
    }
    //4.恢复所有任务
    public void resumeAllJob() throws SchedulerException{
        scheduler.resumeAll();
    }
    //5.修改某个任务的执行时间
    public boolean modifyJob(String name,String group,String time)throws SchedulerException{
        Date date = null;
        TriggerKey triggerKey = new TriggerKey(name, group);
        CronTrigger cronTrigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        String oldTime = cronTrigger.getCronExpression();
        if (!oldTime.equalsIgnoreCase(time))
        {
            CronScheduleBuilder cronScheduleBuilder =
                    CronScheduleBuilder.cronSchedule(time);
            CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(name, group)
                    .withSchedule(cronScheduleBuilder).build();
            date = scheduler.rescheduleJob(triggerKey, trigger);

        }
        return date != null;
    }
    //6.删除某个任务
    public boolean deleteJob(String name,String group) throws SchedulerException{
        JobKey jobKey = new JobKey(name, group);
        JobDetail jobDetail = scheduler.getJobDetail(jobKey);
        if (null==jobDetail) return false;
        return scheduler.deleteJob(jobKey);
    }
    //7.暂停所有任务
    public void pauseAllJob()throws SchedulerException{
        scheduler.pauseAll();
    }
}

• 编写应用监听器，向IOC容器注入调度器，程序启动的时候开启所有任务

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;

import javax.annotation.Resource;

@Configuration
public class ApplicationStartQuartzJobListener
        implements ApplicationListener<ContextRefreshedEvent>
{
    @Resource
    private QuartzScheduler quartzScheduler;
    //程序初始化，启动quartzScheduler的任务
    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        try
        {
            quartzScheduler.startAllJob();
            System.out.println("quartzScheduler启动任务....");
        }
        catch (SchedulerException e)
        {
            e.printStackTrace();
        }
    }
    //程序初始化 注入Scheduler
    @Bean
    public Scheduler scheduler()throws SchedulerException{
        StdSchedulerFactory schedulerFactoryBean = new StdSchedulerFactory();
        return schedulerFactoryBean.getScheduler();
    }
}

• 编写任务调度Web

import org.quartz.SchedulerException;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;

@RestController
@RequestMapping("/quartz")
public class QuartzApiController {
    @Resource
    private QuartzScheduler quartzScheduler;

    //1.开始执行所有任务
    @RequestMapping("/startJob")
    public String startJob() {
        try
        {
            quartzScheduler.startAllJob();
            return "200";
        }
        catch (SchedulerException e)
        {
            e.printStackTrace();
            return "500";
        }
    }
    //2.获取Job信息
    @RequestMapping("/getJobInfo")
    public  String getJobInfo(String name,String group){
        try
        {
            return quartzScheduler.getJobInfo(name, group);
        }
        catch (SchedulerException e)
        {
            e.printStackTrace();
            return "null";
        }
    }
    //3.暂停某个任务
    @RequestMapping("/pauseJob")
    public String pauseJob(String name,String group) {
        try
        {
            boolean pauseJob = quartzScheduler.pauseJob(name, group);
            return pauseJob?"200":"500";
        }
        catch (SchedulerException e)
        {
            e.printStackTrace();
            return "500";
        }
    }
    //4.恢复所有任务
    @RequestMapping("/resumeAllJob")
    public String resumeAllJob(){
        try
        {
            quartzScheduler.resumeAllJob();
            return "200";
        }
        catch (SchedulerException e)
        {
            e.printStackTrace();
            return "500";
        }
    }
    //5.修改某个任务的执行时间
    @PostMapping("/modifyJob")
    public String modifyJob(String name,String group,String time){
        String decodeTime = null;
        System.out.println("time = " + time);
        try {
            decodeTime = URLDecoder.decode(time, "UTF-8");
              System.out.println("decodeTime = " + decodeTime);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        try
        {
            if (decodeTime!=null){
                boolean result = quartzScheduler.modifyJob(name, group, decodeTime);
                return result?"200":"500";
            }
            return "500";
        }
        catch (SchedulerException e)
        {
            e.printStackTrace();
            return "500";
        }
    }
    //6.删除某个任务
    @RequestMapping("/deleteJob")
    public String deleteJob(String name,String group){
        try
        {
            boolean result = quartzScheduler.deleteJob(name, group);
            return result?"200":"500";
        }
        catch (SchedulerException e)
        {
            e.printStackTrace();
            return "500";
        }
    }
    //7.暂停所有任务
    @RequestMapping("/pauseAllJob")
    public String pauseAllJob(){
        try {
            quartzScheduler.pauseAllJob();
            return "200";
        } catch (SchedulerException e) {
            e.printStackTrace();
            return "500";
        }
    }
}

6.Cron表达式

• Cron表达式在线插件

http://cron.qqe2.com/