spring-quartz

Quartz对任务调度的领域问题进行了高度的抽象，提出了调度器、任务和触发器这3个核心的概念

1. Job : 是一个接口，只有一个方法void execute(JobExecutionContext context)，开发者实现该接口定义运行任务，JobExecutionContext类提供了调度上下文的各种信息。Job运行时的信息保存在JobDataMap实例中；
2. JobDetail : Quartz在每次执行Job时，都重新创建一个Job实例，所以它不直接接受一个Job的实例，相反它接收一个Job实现类，以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息，如Job名字、描述、关联监听器等信息，JobDetail承担了这一角色。
   通过该类的构造函数可以更具体地了解它的功用：JobDetail(java.lang.String name, java.lang.String group, java.lang.Class jobClass)，该构造函数要求指定Job的实现类，以及任务在Scheduler中的组名和Job名称；
3. Trigger : 是一个类，描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当仅需触发一次或者以固定时间间隔周期执行，SimpleTrigger是最适合的选择；而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案：如每早晨9:00执行，周一、周三、周五下午5:00执行等；
4. Calendar ： org.quartz.Calendar和java.util.Calendar不同，它是一些日历特定时间点的集合（可以简单地将org.quartz.Calendar看作java.util.Calendar的集合——java.util.Calendar代表一个日历时间点，无特殊说明后面的Calendar即指org.quartz.Calendar）。一个Trigger可以和多个Calendar关联，以便排除或包含某些时间点。
   假设，我们安排每周星期一早上10:00执行任务，但是如果碰到法定的节日，任务则不执行，这时就需要在Trigger触发机制的基础上使用Calendar进行定点排除。针对不同时间段类型，Quartz在org.quartz.impl.calendar包下提供了若干个Calendar的实现类，如AnnualCalendar、MonthlyCalendar、WeeklyCalendar分别针对每年、每月和每周进行定义；
5. Schduler ： 代表一个Quartz的独立运行容器，Trigger和JobDetail可以注册到Scheduler中，两者在Scheduler中拥有各自的组及名称，组及名称是Scheduler查找定位容器中某一对象的依据，Trigger的组及名称必须唯一，JobDetail的组和名称也必须唯一（但可以和Trigger的组和名称相同，因为它们是不同类型的）。Scheduler定义了多个接口方法，允许外部通过组及名称访问和控制容器中Trigger和JobDetail。
   Scheduler可以将Trigger绑定到某一JobDetail中，这样当Trigger触发时，对应的Job就被执行。一个Job可以对应多个Trigger，但一个Trigger只能对应一个Job。可以通过SchedulerFactory创建一个Scheduler实例。Scheduler拥有一个SchedulerContext，它类似于ServletContext，保存着Scheduler上下文信息，Job和Trigger都可以访问SchedulerContext内的信息。SchedulerContext内部通过一个Map，以键值对的方式维护这些上下文数据，SchedulerContext为保存和获取数据提供了多个put()和getXxx()的方法。可以通过Scheduler# getContext()获取对应的SchedulerContext实例；
6. ThreadPool ： 

   Scheduler使用一个线程池作为任务运行的基础设施，任务通过共享线程池中的线程提高运行效率。

   Job有一个StatefulJob子接口，代表有状态的任务，该接口是一个没有方法的标签接口，其目的是让Quartz知道任务的类型，以便采用不同的执行方案。无状态任务在执行时拥有自己的JobDataMap拷贝，对JobDataMap的更改不会影响下次的执行。而有状态任务共享共享同一个JobDataMap实例，每次任务执行对JobDataMap所做的更改会保存下来，后面的执行可以看到这个更改，也即每次执行任务后都会对后面的执行发生影响。

   正因为这个原因，无状态的Job可以并发执行，而有状态的StatefulJob不能并发执行，这意味着如果前次的StatefulJob还没有执行完毕，下一次的任务将阻塞等待，直到前次任务执行完毕。有状态任务比无状态任务需要考虑更多的因素，程序往往拥有更高的复杂度，因此除非必要，应该尽量使用无状态的Job。

   如果Quartz使用了数据库持久化任务调度信息，无状态的JobDataMap仅会在Scheduler注册任务时保持一次，而有状态任务对应的JobDataMap在每次执行任务后都会进行保存。

   Trigger自身也可以拥有一个JobDataMap，其关联的Job可以通过JobExecutionContext#getTrigger().getJobDataMap()获取Trigger中的JobDataMap。不管是有状态还是无状态的任务，在任务执行期间对Trigger的JobDataMap所做的更改都不会进行持久，也即不会对下次的执行产生影响。

   Quartz拥有完善的事件和监听体系，大部分组件都拥有事件，如任务执行前事件、任务执行后事件、触发器触发前事件、触发后事件、调度器开始事件、关闭事件等等，可以注册相应的监听器处理感兴趣的事件。

下面介绍一个spring 集成 quartz的例子：

　　1. maven引入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>

　　　2.  quartz默认会读取 resource下面的 quartz.properties 配置文件

　　

#quartz instancen name 名字任意定
#任意的String，对于调度器自己并没有意义。但是当多个调度器实例用在一个程序里时，他就可以用来为客户端代码区别每个调度器。如果你用集群这个特性，你必须为在集群里的每个实例用一样的名字，实现逻辑上的一样的调度器。
org.quartz.scheduler.instanceName=cron
#任意的String，如果在一个集群里多个实例是一个逻辑上一样的调度器时，每个实例的这项属性必须唯一。你可以设置这项为“AUTO”从而自动收集ID。
org.quartz.scheduler.instanceId=AUTO


#设置线程池
#通常使用org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount=5
#org.quartz.threadPool.threadPriority在 Thread.MIN_PRIORITY (1) 和Thread.MAX_PRIORITY (10)之间
org.quartz.threadPool.threadPriority=5





#
org.quartz.jobStore.isClustered=true
org.quartz.jobStore.clusterCheckinInterval=20000
#




#采用缓存模式
#org.quzrta.jobStore.class=org.quartz.simpl.RAMJobStore
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties=true
#在触发器被认为没有触发之前，调度器能承受一个触发器再次触发的一个毫秒级数字。
org.quartz.jobStore.misfireThreshold=60000


#采用db存储模式，采用db模式的情况下需要订单DataSource 并导入quartz的表结构，设置表的前缀
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.tablePrefix=QRTZ_
org.quartz.jobStore.dataSource=myDS


#定义DataSource
org.quartz.dataSource.myDS.driver=com.mysql.jdbc.Driver
org.quartz.dataSource.myDS.URL=jdbc:mysql://loacalhost/quartz
org.quartz.dataSource.myDS.user=1111
org.quartz.dataSource.myDS.password=111
org.quartz.dataSource.myDS.maxConnections=5

　　　3. 定义一个job，实现job的接口

　　　　

public class MySimpleJob implements Job{

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("1111111111111111111111111111111111111111111111");
        JobKey jobKey = jobExecutionContext.getJobDetail().getKey();
        System.out.println(jobKey+" triggered. time is:" + (new Date()));
    }
}

　　4. 运用test方法测试各种quartz方法

　　

@RunWith(SpringRunner.class)
@SpringBootTest
public class QuartzApplicationTests {

    @Test
    public void contextLoads() {}

    /**
     * 基本的测试
     * @throws SchedulerException
     */
    @Test
    public void testSimple() throws SchedulerException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.start();
        scheduler.shutdown();
    }

    /**
     * 测试simpleTrigger
     * @throws InterruptedException
     */
    @Test
    public void testQuartz() throws InterruptedException {



        Trigger trigger = newTrigger()
                .withIdentity("trigger1", "group1")
                .startNow()
                .withSchedule(simpleSchedule()
                        .withIntervalInSeconds(40)
                        .repeatForever())
                .build();
        com.quartz.huanl.MySimpleJob mySimpleJob = new com.quartz.huanl.MySimpleJob();
        JobDetail job = newJob(mySimpleJob.getClass())
                .withIdentity("job1", "group1")
                .build();


        try {
            Scheduler scheduler = new StdSchedulerFactory().getScheduler();
            scheduler.start();
            scheduler.scheduleJob(job, trigger);

            Thread.sleep(90L * 1000L);
            scheduler.shutdown(true);
        } catch (SchedulerException e1) {
            e1.printStackTrace();
        }



    }

    /**
     * 测试cronTrigger
     */
    @Test
    public void testQuartzCron(){
        com.quartz.huanl.MySimpleJob mySimpleJob = new com.quartz.huanl.MySimpleJob();
        JobDetail job = newJob(mySimpleJob.getClass())
                .withIdentity("job2", "group2")
                .build();

        CronTrigger trigger = newTrigger()
                .withIdentity("trigger2", "group2")
                .withSchedule(cronSchedule("0/1 * * * * ?"))
                .build();

        SchedulerFactory sf = new StdSchedulerFactory();
        try {
            Scheduler sched = sf.getScheduler();
            sched.scheduleJob(job, trigger);
            sched.start();
            Thread.sleep(300L * 1000L);
            sched.shutdown(true);
        } catch (SchedulerException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    /**
     * 测试去除特定的日期的Trigger
     * @throws SchedulerException
     * @throws InterruptedException
     */
    @Test
    public void testQuartzCalendar() throws SchedulerException, InterruptedException {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();

        //由于每年的日期都是固定的因此用 org.quartz.Calendar 来存储
        AnnualCalendar holidays = new AnnualCalendar();

        //去除劳动节
        java.util.Calendar laborDay = new GregorianCalendar();
        laborDay.add(Calendar.MONDAY, 5);
        laborDay.add(Calendar.DATE, 1);


        //去除国庆节
        Calendar nationalDay = new GregorianCalendar();
        nationalDay.add(Calendar.MONTH, 10);
        nationalDay.add(Calendar.DATE, 1);

        //去除每小时的 10 20 30 40 50 秒
        ///Calendar seconds10 = new GregorianCalendar();
        //seconds10.set(Calendar.HOUR, 9);
       // seconds10.set(Calendar.MINUTE, 14);



        ArrayList<Calendar> calendars = new ArrayList<Calendar>();
        calendars.add(laborDay);
        calendars.add(nationalDay);
        //calendars.add(seconds10);

        //去除特定的日期
        holidays.setDaysExcluded(calendars);

        scheduler.addCalendar("holidays", holidays, false, false);

        JobDetail jobDetail = newJob(MySimpleJob.class).
                withIdentity("job1", "group1")
                .build();

        CronTrigger cronTrigger = newTrigger()
                .withIdentity("trigger1", "group1")
                .modifiedByCalendar("holidays")
                .withSchedule(cronSchedule("0/1 * * * * ?"))
                .build();

        scheduler.scheduleJob(jobDetail, cronTrigger);
        scheduler.start();
        Thread.sleep(300L * 1000L);
        scheduler.shutdown(true);


    }

    /**
     * 从故障中恢复
     * @throws SchedulerException
     * @throws InterruptedException
     */
    @Test
    public void testRecoveryFromDb() throws SchedulerException, InterruptedException {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();

        //获取所有的 trigger group的名字
        List<String> triggerGroups = scheduler.getTriggerGroupNames();
        //对groups 进行遍历
        for (String triggerGroup : triggerGroups){
            //将string triggerGroup name 转换为 GroupMatcher ，从中获取所有的triggerKeys
            Set<TriggerKey> triggerKeys = scheduler.getTriggerKeys(GroupMatcher.triggerGroupEquals(triggerGroup));
            //对当前group下面的所有 triggerKey进行遍历
            for (TriggerKey triggerKey : triggerKeys){
                //根据triggerKey获取trigger
                Trigger tg = scheduler.getTrigger(triggerKey);
                //恢复job
                scheduler.rescheduleJob(triggerKey, tg);
            }

        }
        scheduler.start();
        Thread.sleep(300L * 1000L);
        scheduler.shutdown(true);
//        List<String> jobGroupNames = scheduler.getJobGroupNames();
//        for (String jobGroupName : jobGroupNames){
//            Set<JobKey> jobNames = scheduler.getJobKeys(GroupMatcher.jobGroupEquals(jobGroupName));
//            for (JobKey jobName: jobNames){
//                JobDetail jobDetail = scheduler.getJobDetail(jobName);
//
//            }
//        }
    }


}