初识定时器quartz

start=============
1.java 的定时器 Timer 这个比较简单
2.spring的定时器 schedule 这个也比较简单
3.quartz 今天主要说这个任务调度器
quartz主要接口分为：
Scheduler - 与调度程序交互的主要API。
Job - 由希望由调度程序执行的组件实现的接口。
JobDetail - 用于定义作业的实例。
Trigger（即触发器） - 定义执行给定作业的计划的组件。
JobBuilder - 用于定义/构建JobDetail实例，用于定义作业的实例。
TriggerBuilder - 用于定义/构建触发器实例。
简单配置
springboot 2.0之后可直接加入此依赖

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

#quartz配置可直接在properties配置
#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=1000
#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
#spring.quartz.job-store-type=jdbc
也可以通过手动硬编码配置
package com.ermeng.quartz.config;

import org.quartz.Scheduler;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;

import javax.sql.DataSource;
import java.io.IOException;
import java.util.Properties;

@Configuration
public class quartzconfig {
/* @Bean
public Properties quartzProperties() throws IOException {
PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
propertiesFactoryBean.setLocation(new ClassPathResource("/config/quartz.properties"));
propertiesFactoryBean.afterPropertiesSet();
return propertiesFactoryBean.getObject();
}*/

@Bean
public SchedulerFactoryBean scheduler(DataSource dataSource) {
    SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
    try {
        Properties properties = new Properties();
        //properties = quartzProperties();
        //也可以通过properties来手动硬编码配置quartz
        properties.setProperty("spring.quartz.properties.org.quartz.scheduler.instanceName","clusteredScheduler");
        properties.setProperty("spring.quartz.properties.org.quartz.scheduler.instanceId","auto");
        properties.setProperty("spring.quartz.properties.org.quartz.jobStore.class","org.quartz.impl.jdbcjobstore.JobStoreTX");
        properties.setProperty("spring.quartz.properties.org.quartz.jobStore.driverDelegateClass","org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
        properties.setProperty("spring.quartz.properties.org.quartz.jobStore.tablePrefix","QRTZ_");
        properties.setProperty("spring.quartz.properties.org.quartz.jobStore.isClustered","true");
        properties.setProperty("spring.quartz.properties.org.quartz.jobStore.clusterCheckinInterval","1000");
        properties.setProperty("spring.quartz.properties.org.quartz.jobStore.useProperties","false");
        properties.setProperty("spring.quartz.properties.org.quartz.threadPool.class","org.quartz.simpl.SimpleThreadPool");
        properties.setProperty("org.quartz.simpl.SimpleThreadPool","10");
        properties.setProperty("spring.quartz.properties.org.quartz.threadPool.threadPriority","5");
        properties.setProperty("spring.quartz.properties.org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread","true");
        properties.setProperty("spring.quartz.job-store-type","jdbc");
        schedulerFactoryBean.setDataSource(dataSource);
        schedulerFactoryBean.setOverwriteExistingJobs(true);
        schedulerFactoryBean.setAutoStartup(true);
        schedulerFactoryBean.setStartupDelay(5);
        schedulerFactoryBean.setQuartzProperties(properties);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return schedulerFactoryBean;
}

}

必须有的一些数据表
1.qrtz_blob_triggers : 以Blob 类型存储的触发器。
2.qrtz_calendars：存放日历信息， quartz可配置一个日历来指定一个时间范围。
3.qrtz_cron_triggers：存放cron类型的触发器。
4.qrtz_fired_triggers：存放已触发的触发器。
5.qrtz_job_details：存放一个jobDetail信息。
6.qrtz_job_listeners：job监听器。
7.qrtz_locks： 存储程序的悲观锁的信息(假如使用了悲观锁)。
8.qrtz_paused_trigger_graps：存放暂停掉的触发器。
9.qrtz_scheduler_state：调度器状态。
10.qrtz_simple_triggers：简单触发器的信息。
11.qrtz_triggers：触发器的基本信息。
CREATE TABLE QRTZ_JOB_DETAILS(
SCHED_NAME VARCHAR(120) NOT NULL,
JOB_NAME VARCHAR(200) NOT NULL,##job的名字
JOB_GROUP VARCHAR(200) NOT NULL,##job的所属组的名字
DESCRIPTION VARCHAR(250) NULL,
JOB_CLASS_NAME VARCHAR(250) NOT NULL,##job实现类的完全包名,quartz就是根据这个路径到classpath找到该job类
IS_DURABLE VARCHAR(1) NOT NULL,#是否持久化,把该属性设置为1，quartz会把job持久化到数据库中
IS_NONCONCURRENT VARCHAR(1) NOT NULL,
IS_UPDATE_DATA VARCHAR(1) NOT NULL,
REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
JOB_DATA BLOB NULL,#一个blob字段，存放持久化job对象
PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

#保存trigger信息 触发器信息表
CREATE TABLE QRTZ_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,#trigger的名字,
TRIGGER_GROUP VARCHAR(200) NOT NULL,#trigger所属组的名字
JOB_NAME VARCHAR(200) NOT NULL,#qrtz_job_details表job_name的外键
JOB_GROUP VARCHAR(200) NOT NULL,#qrtz_job_details表job_group的外键
DESCRIPTION VARCHAR(250) NULL,
NEXT_FIRE_TIME BIGINT(13) NULL,
PREV_FIRE_TIME BIGINT(13) NULL,
PRIORITY INTEGER NULL,
TRIGGER_STATE VARCHAR(16) NOT NULL,#:当前trigger状态，设置为ACQUIRED,如果设置为WAITING,则job不会触发
TRIGGER_TYPE VARCHAR(8) NOT NULL,#CRON
START_TIME BIGINT(13) NOT NULL,
END_TIME BIGINT(13) NULL,
CALENDAR_NAME VARCHAR(200) NULL,
MISFIRE_INSTR SMALLINT(2) NULL,
JOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP))
ENGINE=InnoDB;

#存储cron表达式表
CREATE TABLE QRTZ_CRON_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,#triggers表trigger_name的外键
TRIGGER_GROUP VARCHAR(200) NOT NULL,# qrtz_triggers表trigger_group的外键
CRON_EXPRESSION VARCHAR(120) NOT NULL,#cron表达式
TIME_ZONE_ID VARCHAR(80),
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPLE_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
REPEAT_COUNT BIGINT(7) NOT NULL,
REPEAT_INTERVAL BIGINT(12) NOT NULL,
TIMES_TRIGGERED BIGINT(10) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SIMPROP_TRIGGERS
(
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
STR_PROP_1 VARCHAR(512) NULL,
STR_PROP_2 VARCHAR(512) NULL,
STR_PROP_3 VARCHAR(512) NULL,
INT_PROP_1 INT NULL,
INT_PROP_2 INT NULL,
LONG_PROP_1 BIGINT NULL,
LONG_PROP_2 BIGINT NULL,
DEC_PROP_1 NUMERIC(13,4) NULL,
DEC_PROP_2 NUMERIC(13,4) NULL,
BOOL_PROP_1 VARCHAR(1) NULL,
BOOL_PROP_2 VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_BLOB_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
BLOB_DATA BLOB NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
INDEX (SCHED_NAME,TRIGGER_NAME, TRIGGER_GROUP),
FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_CALENDARS (
SCHED_NAME VARCHAR(120) NOT NULL,
CALENDAR_NAME VARCHAR(200) NOT NULL,
CALENDAR BLOB NOT NULL,
PRIMARY KEY (SCHED_NAME,CALENDAR_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS (
SCHED_NAME VARCHAR(120) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP))
ENGINE=InnoDB;

CREATE TABLE QRTZ_FIRED_TRIGGERS (
SCHED_NAME VARCHAR(120) NOT NULL,
ENTRY_ID VARCHAR(95) NOT NULL,
TRIGGER_NAME VARCHAR(200) NOT NULL,
TRIGGER_GROUP VARCHAR(200) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
FIRED_TIME BIGINT(13) NOT NULL,
SCHED_TIME BIGINT(13) NOT NULL,
PRIORITY INTEGER NOT NULL,
STATE VARCHAR(16) NOT NULL,
JOB_NAME VARCHAR(200) NULL,
JOB_GROUP VARCHAR(200) NULL,
IS_NONCONCURRENT VARCHAR(1) NULL,
REQUESTS_RECOVERY VARCHAR(1) NULL,
PRIMARY KEY (SCHED_NAME,ENTRY_ID))
ENGINE=InnoDB;

CREATE TABLE QRTZ_SCHEDULER_STATE (
SCHED_NAME VARCHAR(120) NOT NULL,
INSTANCE_NAME VARCHAR(200) NOT NULL,
LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
CHECKIN_INTERVAL BIGINT(13) NOT NULL,
PRIMARY KEY (SCHED_NAME,INSTANCE_NAME))
ENGINE=InnoDB;

CREATE TABLE QRTZ_LOCKS (
SCHED_NAME VARCHAR(120) NOT NULL,
LOCK_NAME VARCHAR(40) NOT NULL,
PRIMARY KEY (SCHED_NAME,LOCK_NAME))
ENGINE=InnoDB;
下面这个配置可以将任务存到数据库时间前后端动态效果 吧类名以及方法名存到任务里和数据库里，通过用java的反射技术来实现动态的效果
package com.ermeng.quartz.job;

import com.alibaba.fastjson.JSONObject;
import com.ermeng.quartz.domain.TestByJob;
import com.ermeng.utils.SpringBeanUtils;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

import java.lang.reflect.Method;

public class QuartzJob extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
System.out.println("=定时任务开始执行啦========");
try {
String json = jobExecutionContext.getMergedJobDataMap().getString(“JOB_PARAM_KEY”);
TestByJob testByJob = JSONObject.parseObject(json, TestByJob.class);
Object object = SpringBeanUtils.getBean(testByJob.getJobClass());
Method method = object.getClass().getDeclaredMethod(testByJob.getJobMethod());
method.invoke(object);
} catch (Exception n) {
n.printStackTrace();
}
}
}
简单例子 创建一个任务
@Autowired
private Scheduler scheduler;

	{  TestByJob testByJob = new TestByJob();
        testByJob.setStatus(0);
        testByJob.setCrontext("*/5 * * * * ?");
        testByJob.setJobClass("myJobServiceImpl");
        testByJob.setJobMethod("addjob");
        quartzJobJPA.save(testByJob);
        Integer jobid = testByJob.getId();
        //创建一个job对象
        JobDetail jobDetail = JobBuilder.newJob(QuartzJob.class).withIdentity("JOB_" + jobid).build();
        //获取corn表达式
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(testByJob.getCrontext()).withMisfireHandlingInstructionDoNothing();
        //创建触发器
        CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("TRIGGER_" + jobid)
                .withSchedule(cronScheduleBuilder)将cron表达式配置到触发器
                .build();
        //将对象josn序列化存储到Job的getJobDataMap()方法中，为后续根据获取属性执行对应的类的任务
        jobDetail.getJobDataMap().put("JOB_PARAM_KEY", JSON.toJSONString(testByJob));
        scheduler.scheduleJob(jobDetail, cronTrigger);
        if (testByJob.getStatus() == 0) {
            scheduler.pauseJob(JobKey.jobKey("JOB_" + jobid));
        } else {
            scheduler.resumeJob(JobKey.jobKey("JOB_" + jobid));
        }
    } catch (SchedulerException s) {
        s.printStackTrace();
    }
    }
    scheduler 里面有很多方法主要作用
       scheduler.pauseJob(JobKey）暂定一个任务
       scheduler.resumeJob(JobKey)开始一个任务
          scheduler.deleteJob(JobKey)删除一个任务
          更新的话也在这些基础之上

=end=======
好的就给大家分享到这！