Quartz简介

Quartz简介

Quartz是Job Scheduling(任务调度)领域的开源项目，可单独使用，也可和JavaSE,EE进行组合，是一个任务调度管理系统，可在特定的时间内执行特定的任务,如想在Java中使用Quartz,则只需将Quartz的jar包导入到项目中即可.

Quartz相关介绍

Jobs:任务

是实际想要执行的操作，只需要实现Job接口即可.

package com.dong.controller;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class jobtask implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        //所要执行的操作
    }
}

JobDetail对象：

    public static void main(String[] args) {
        JobDetail jobtask = newJob(jobTask.class)
                .withIdentity("jobone","jobA")
                .build();
    }

JobDetail对象，在上面的实例中，引入了JobBuilder类的静态方法newJob来创建job实例，withIdentity用来表示job的名字和所属组，build()方法则返回一个JobDetail实例.

JobDetail的源码解释为：

/**
 *Conveys the detail properties of a given <code>Job</code> instance. JobDetails are
 * to be created/defined with {@link JobBuilder}.
 * 
 * <p>
 * Quartz does not store an actual instance of a <code>Job</code> class, but
 * instead allows you to define an instance of one, through the use of a <code>JobDetail</code>.
 * </p>
**/

即Quartz不能存储Job实例，当Quartz需要Job的信息时，可定义JobDetail来存储Job属性，JobDetail通过JobBuilder创建.

 public static JobBuilder newJob(Class <? extends Job> jobClass) {
        JobBuilder b = new JobBuilder();
        b.ofType(jobClass);
        return b;
    }

Job的调度是通过scheduler实例，scheduler传入JobDetail对象和Trigger对象，JobDetail对象则在构造的过程中传入Job对象的class对象，可以看出这里使用反射的机制进行创建Job对象，当每次调用execute方法，则创建一个Job对象，然后丢弃该对象的引用，因此，Job对象必须有一个空参的构造器，其次，Job对象的属性值不会保存，如果想在Job对象执行中使用配置和属性，则可以使用JobDataMap.

public class jobTask implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        String name =context.getJobDetail().getJobDataMap().getString("name");
        System.out.println("name");
    }

    public static void main(String[] args) {
        JobDetail jobtask = newJob(jobTask.class)
                .withIdentity("jobone","jobA")
                .usingJobData("name","land")
                .build();
    }
}

JobDataMap可以包含数据对象，可在Job执行过程中，使用该对象的数据.

Trigger:触发器

Trigger公共属性：TriggerKey属性，表明Trigger身份，jobKey:Trigger被触发时被执行的Job身份，startTime属性：设置第一次触发时间，endTime属性：触发失效时间.错过触发misfire.

Trigger优先级，默认为5，可以是任意数值，注意只有同一时刻触发的trigger之间才会比较优先级.

calendar:不是Java的日历对象，这个对象用于从trigger的调度计划中排除时间段,创建Calendar需要实现Calendar接口，然后实例化改对象，并添加到scheduler对象中.对于一整天的排除，则可以使用HolidayCalendar对象，方法modifiedByCalendar()方法将在任务调度时，排除在该时间段的任务.

   public static void main(String[] args) {
        HolidayCalendar holidayCalendar = new HolidayCalendar();
        holidayCalendar.addExcludedDate("xxx");
        Trigger trigger = newTrigger()
                .withIdentity("triggerone")
                .forJob("job")
                .withSchedule(dailyAtHourAndMinute(12,00))
                .modifiedByCalendar("holidayCalendar")
                .build();
    }

Trigger两个子类有Siimple Trigger,Cron Trigger.

Simple Trigger:在特定的时间点支持，或者在特定的时间点执行，然后以特定的时间间隔执行.

CronTrigger 基于日历概念，使用CronTrigger需要指定时间表，Cron Expressions是用来定义日历的表达式，“0 0 12？* WED“ - 这意味着”每个星期三下午12:00“。

创建和Triigger对象相同，可以通过设置触发器的名字，开始时间，结束时间，执行次数，调度器，指定Job来实现任务的触发操作.

TriggerListeners和JobListeners:前者用来监听触发器，后者用来监听Job.***只需要实现TriggerListener或JobListeners接口即可，可以扩展JobListenerSupport类或TriggerListenerSupport类, listener与调度程序的ListenerManager一起注册，并配有描述listener希望接收事件的job/触发器的Matcher。

SchedulerListener***，包含各种监听Shceduler的事件，和TriggerListenners与JobListeners类型，需要注册到调度程序的ListennerManager。以JobListener为例：

package com.dong.controller;

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

public class JobLis implements JobListener {
    @Override
    public String getName() {
        return "jobpre";
    }
    @Override
    public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {
        String name = jobExecutionContext.getJobDetail().getJobDataMap().getString("name");
        System.out.println("Job Start >...");

    }
    @Override
    public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {
    }
    @Override
    public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException e) {
        System.out.println("Job end >....");
    }
}

可通过jobExecutionContext来获取Job在运行时的一些数据.

Schedule:调度器

可通过StdSchedulerFactory,DirectSchedulerFactory来实现，也可通过schedulerFactory获取.

SchedulerFactoryBean schedulerFactory = new SchedulerFactoryBean();
Scheduler scheduler = schedulerFactory.getScheduler();

Quartz在使用前，需要进行实例化，可以使用SchedulerFactory进行实例化，以工厂模式生成一个实例对象，scheduler实例化后，可启动，暂停，停止.除非scheduler启动，才可以进行相应的任务执行操作.

完整的任务调度案例：使用Maven方式创建工程

1.创建工程，pom.xml导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.dong.quartz</groupId>
    <artifactId>quartz_helloworld</artifactId>
    <version>1.0-SNAPSHOT</version>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
            <exclusions>
                <exclusion>
                    <artifactId>slf4j-api</artifactId>
                    <groupId>org.slf4j</groupId>
                </exclusion>
            </exclusions>
        </dependency>

        <!-- 添加Scheduled坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

        <!-- Sprng tx 坐标 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
        </dependency>
    </dependencies>

</project>

    2.创建Job类

package com.dong.controller;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;

@Component
public class JobIns implements Job {
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("执行 Ququ  ...." );
    }
}

3.创建JobListeners

package com.dong.controller;

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

public class JobLis implements JobListener {
    @Override
    public String getName() {
        return "jobpre";
    }
    @Override
    public void jobToBeExecuted(JobExecutionContext jobExecutionContext) {
        String name = jobExecutionContext.getJobDetail().getJobDataMap().getString("name");
        System.out.println("Job Start >...");
    }
    @Override
    public void jobExecutionVetoed(JobExecutionContext jobExecutionContext) {
    }
    @Override
    public void jobWasExecuted(JobExecutionContext jobExecutionContext, JobExecutionException e) {
        System.out.println("Job end >....");
    }
}

4.创建Trigger Listenner

package com.dong.controller;

import org.quartz.JobExecutionContext;
import org.quartz.Trigger;
import org.quartz.TriggerListener;

public class TriggerLis implements TriggerListener {
    @Override
    public String getName() {
        return "triggerpre";
    }
    @Override
    public void triggerFired(Trigger trigger, JobExecutionContext jobExecutionContext) {
    }
    @Override
    public boolean vetoJobExecution(Trigger trigger, JobExecutionContext jobExecutionContext) {
        return false;
    }
    @Override
    public void triggerMisfired(Trigger trigger) {
    }
    @Override
    public void triggerComplete(Trigger trigger, JobExecutionContext jobExecutionContext, Trigger.CompletedExecutionInstruction completedExecutionInstruction) {
        System.out.println("trigger complete > .....");
    }
}

5.创建配合类，Simplejob,Trigger,Scheduler

package com.dong.config;

import com.dong.controller.JobLis;
import com.dong.controller.TriggerLis;
import com.dong.controller.JobIns;
import org.quartz.Scheduler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

@Configuration
public class QuartzConfig {
        @Bean
        public JobDetailFactoryBean jobDetailFactoryBean(){
            JobDetailFactoryBean jobDetailFactory = new JobDetailFactoryBean();
            jobDetailFactory.setJobClass(JobIns.class);
            return jobDetailFactory;
        }
        @Bean
        public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactory){
            SimpleTriggerFactoryBean simpleTriggerFactory = new SimpleTriggerFactoryBean();
            simpleTriggerFactory.setJobDetail(jobDetailFactory.getObject());
            simpleTriggerFactory.setRepeatInterval(2000);
            simpleTriggerFactory.setRepeatCount(20);
            return simpleTriggerFactory;
        }
        @Bean
        public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactory){
            SchedulerFactoryBean schedulerFactory = new SchedulerFactoryBean();
            schedulerFactory.setTriggers(simpleTriggerFactory.getObject());
            schedulerFactory.setGlobalJobListeners(new JobLis());
            schedulerFactory.setGlobalTriggerListeners(new TriggerLis());
            return schedulerFactory;
        }
}

    6.创建启动类

package com.dong.boot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.stereotype.Component;

@SpringBootApplication
@EnableScheduling
@ComponentScan("com.dong.*")
public class application {
    public static void main(String[] args) {
        SpringApplication.run(application.class,args);
    }
}

7.运行结果为：

Job Start >...
执行 Ququ  ....
Job end >....
trigger complete > .....
Job Start >...
执行 Ququ  ....
Job end >....
trigger complete > .....

         如有异议，敬请指出，与君共勉.