Quartz集成springMVC 的方案二（持久化任务、集群和分布式）

水深无声 2022-08-12 01:17 68阅读 0赞

Quartz是一个开放源码项目，专注于任务调度器，提供了极为广泛的特性如持久化任务，集群和分布式任务等。 Quartz核心是调度器，还采用多线程管理。

1.持久化任务：当应用程序停止运行时，所有调度信息不被丢失，当你重新启动时，调度信息还存在，这就是持久化任务。

2.集群和分布式处理：当在集群环境下，当有配置Quartz的多个客户端时（节点），采用Quartz的集群和分布式处理时，我们要了解几点好处 1) 一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。2） Quartz调度是通过触发器的类别来识别不同的任务，在不同的节点定义相同的触发器的类别，这样在集群下能稳定的运行，一个节点无法完成的任务，会被集群中拥有相同的任务的节点取代执行。3）分布式 体现在 当相同的任务定时在一个时间点，在那个时间点，不会被两个节点同时执行。

Quartz的 Task（11 张表）实例化采用数据库存储，基于数据库引擎及 High-Available 的策略（集群的一种策略）自动协调每个节点的 Quartz。

delete from qrtz_fired_triggers;
    delete from qrtz_simple_triggers;
    delete from qrtz_simprop_triggers;
    delete from qrtz_cron_triggers;
    delete from qrtz_blob_triggers;
    delete from qrtz_triggers;
    delete from qrtz_job_details;
    delete from qrtz_calendars;
    delete from qrtz_paused_trigger_grps;
    delete from qrtz_locks;
    delete from qrtz_scheduler_state;
     
     
     
    CREATE TABLE qrtz_job_details
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        JOB_NAME  VARCHAR2(200) NOT NULL,
        JOB_GROUP VARCHAR2(200) NOT NULL,
        DESCRIPTION VARCHAR2(250) NULL,
        JOB_CLASS_NAME   VARCHAR2(250) NOT NULL, 
        IS_DURABLE VARCHAR2(1) NOT NULL,
        IS_NONCONCURRENT VARCHAR2(1) NOT NULL,
        IS_UPDATE_DATA VARCHAR2(1) NOT NULL,
        REQUESTS_RECOVERY VARCHAR2(1) NOT NULL,
        JOB_DATA BLOB NULL,
        CONSTRAINT QRTZ_JOB_DETAILS_PK PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
    );
    CREATE TABLE qrtz_triggers
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        TRIGGER_NAME VARCHAR2(200) NOT NULL,
        TRIGGER_GROUP VARCHAR2(200) NOT NULL,
        JOB_NAME  VARCHAR2(200) NOT NULL, 
        JOB_GROUP VARCHAR2(200) NOT NULL,
        DESCRIPTION VARCHAR2(250) NULL,
        NEXT_FIRE_TIME NUMBER(13) NULL,
        PREV_FIRE_TIME NUMBER(13) NULL,
        PRIORITY NUMBER(13) NULL,
        TRIGGER_STATE VARCHAR2(16) NOT NULL,
        TRIGGER_TYPE VARCHAR2(8) NOT NULL,
        START_TIME NUMBER(13) NOT NULL,
        END_TIME NUMBER(13) NULL,
        CALENDAR_NAME VARCHAR2(200) NULL,
        MISFIRE_INSTR NUMBER(2) NULL,
        JOB_DATA BLOB NULL,
        CONSTRAINT QRTZ_TRIGGERS_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        CONSTRAINT QRTZ_TRIGGER_TO_JOBS_FK FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP) 
          REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP) 
    );
    CREATE TABLE qrtz_simple_triggers
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        TRIGGER_NAME VARCHAR2(200) NOT NULL,
        TRIGGER_GROUP VARCHAR2(200) NOT NULL,
        REPEAT_COUNT NUMBER(7) NOT NULL,
        REPEAT_INTERVAL NUMBER(12) NOT NULL,
        TIMES_TRIGGERED NUMBER(10) NOT NULL,
        CONSTRAINT QRTZ_SIMPLE_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        CONSTRAINT QRTZ_SIMPLE_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
    REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_cron_triggers
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        TRIGGER_NAME VARCHAR2(200) NOT NULL,
        TRIGGER_GROUP VARCHAR2(200) NOT NULL,
        CRON_EXPRESSION VARCHAR2(120) NOT NULL,
        TIME_ZONE_ID VARCHAR2(80),
        CONSTRAINT QRTZ_CRON_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        CONSTRAINT QRTZ_CRON_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
          REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_simprop_triggers
      (          
        SCHED_NAME VARCHAR2(120) NOT NULL,
        TRIGGER_NAME VARCHAR2(200) NOT NULL,
        TRIGGER_GROUP VARCHAR2(200) NOT NULL,
        STR_PROP_1 VARCHAR2(512) NULL,
        STR_PROP_2 VARCHAR2(512) NULL,
        STR_PROP_3 VARCHAR2(512) NULL,
        INT_PROP_1 NUMBER(10) NULL,
        INT_PROP_2 NUMBER(10) NULL,
        LONG_PROP_1 NUMBER(13) NULL,
        LONG_PROP_2 NUMBER(13) NULL,
        DEC_PROP_1 NUMERIC(13,4) NULL,
        DEC_PROP_2 NUMERIC(13,4) NULL,
        BOOL_PROP_1 VARCHAR2(1) NULL,
        BOOL_PROP_2 VARCHAR2(1) NULL,
        CONSTRAINT QRTZ_SIMPROP_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        CONSTRAINT QRTZ_SIMPROP_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
          REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_blob_triggers
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        TRIGGER_NAME VARCHAR2(200) NOT NULL,
        TRIGGER_GROUP VARCHAR2(200) NOT NULL,
        BLOB_DATA BLOB NULL,
        CONSTRAINT QRTZ_BLOB_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        CONSTRAINT QRTZ_BLOB_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
            REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_calendars
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        CALENDAR_NAME  VARCHAR2(200) NOT NULL, 
        CALENDAR BLOB NOT NULL,
        CONSTRAINT QRTZ_CALENDARS_PK PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
    );
    CREATE TABLE qrtz_paused_trigger_grps
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        TRIGGER_GROUP  VARCHAR2(200) NOT NULL, 
        CONSTRAINT QRTZ_PAUSED_TRIG_GRPS_PK PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_fired_triggers 
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        ENTRY_ID VARCHAR2(95) NOT NULL,
        TRIGGER_NAME VARCHAR2(200) NOT NULL,
        TRIGGER_GROUP VARCHAR2(200) NOT NULL,
        INSTANCE_NAME VARCHAR2(200) NOT NULL,
        FIRED_TIME NUMBER(13) NOT NULL,
        SCHED_TIME NUMBER(13) NOT NULL,
        PRIORITY NUMBER(13) NOT NULL,
        STATE VARCHAR2(16) NOT NULL,
        JOB_NAME VARCHAR2(200) NULL,
        JOB_GROUP VARCHAR2(200) NULL,
        IS_NONCONCURRENT VARCHAR2(1) NULL,
        REQUESTS_RECOVERY VARCHAR2(1) NULL,
        CONSTRAINT QRTZ_FIRED_TRIGGER_PK PRIMARY KEY (SCHED_NAME,ENTRY_ID)
    );
    CREATE TABLE qrtz_scheduler_state 
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        INSTANCE_NAME VARCHAR2(200) NOT NULL,
        LAST_CHECKIN_TIME NUMBER(13) NOT NULL,
        CHECKIN_INTERVAL NUMBER(13) NOT NULL,
        CONSTRAINT QRTZ_SCHEDULER_STATE_PK PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
    );
    CREATE TABLE qrtz_locks
      (
        SCHED_NAME VARCHAR2(120) NOT NULL,
        LOCK_NAME  VARCHAR2(40) NOT NULL, 
        CONSTRAINT QRTZ_LOCKS_PK PRIMARY KEY (SCHED_NAME,LOCK_NAME)
    );
     
    create index idx_qrtz_j_req_recovery on qrtz_job_details(SCHED_NAME,REQUESTS_RECOVERY);
    create index idx_qrtz_j_grp on qrtz_job_details(SCHED_NAME,JOB_GROUP);
     
    create index idx_qrtz_t_j on qrtz_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);
    create index idx_qrtz_t_jg on qrtz_triggers(SCHED_NAME,JOB_GROUP);
    create index idx_qrtz_t_c on qrtz_triggers(SCHED_NAME,CALENDAR_NAME);
    create index idx_qrtz_t_g on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP);
    create index idx_qrtz_t_state on qrtz_triggers(SCHED_NAME,TRIGGER_STATE);
    create index idx_qrtz_t_n_state on qrtz_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
    create index idx_qrtz_t_n_g_state on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
    create index idx_qrtz_t_next_fire_time on qrtz_triggers(SCHED_NAME,NEXT_FIRE_TIME);
    create index idx_qrtz_t_nft_st on qrtz_triggers(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
    create index idx_qrtz_t_nft_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
    create index idx_qrtz_t_nft_st_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
    create index idx_qrtz_t_nft_st_misfire_grp on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
     
    create index idx_qrtz_ft_trig_inst_name on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME);
    create index idx_qrtz_ft_inst_job_req_rcvry on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
    create index idx_qrtz_ft_j_g on qrtz_fired_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);
    create index idx_qrtz_ft_jg on qrtz_fired_triggers(SCHED_NAME,JOB_GROUP);
    create index idx_qrtz_ft_t_g on qrtz_fired_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
    create index idx_qrtz_ft_tg on qrtz_fired_triggers(SCHED_NAME,TRIGGER_GROUP);

我在新建一个张表，为了方便页面能对每个任务进行管理，能对具体某个任务设置开始时间、结束时间、执行的方法、删除等， 如下面图所示：

![SouthEast][]

![SouthEast 1][]

在这边可以管理开始时间和结束时间和cronExpression值，方便管理对应表的设计：

![SouthEast 2][]

![SouthEast 3][]

表都设计好了，整理Quartz集成springMVC的具体的实现。

对Spring的@component 的说明：@component （把普通pojo实例化到spring容器中，相当于配置文件中的<bean id="" class=""/>）

1.举例两个任务具体实现功能，列如quartzJobA和quartzJobB任务要做什么，新建了两个类和方法。

import org.springframework.stereotype.Component;
    
    @Component("quartzJobA")
    public class Data2ServiceImpl {
    
    	public void run() {
    		System.out.println("=============Data2ServiceImpl=========");
    		
    	}
    }
    
    @Component("quartzJobB")
    public class DataServiceImpl {
    
      
    	public void test() {
    		System.out.println("=============DataServiceImpl=========");
    		
    	}
    
    }

2.Quartz 调度任务所需的配置文件 quartz-job.properties

#Main Scheduler Settings
    org.quartz.scheduler.instanceName=quartzScheduler  
    org.quartz.scheduler.instanceId=AUTO
    org.quartz.scheduler.threadsInheritContextClassLoaderOfInitializer=true
    org.quartz.scheduler.skipUpdateCheck=true
    org.quartz.scheduler.batchTriggerAcquisitionMaxCount=100
    
    org.quartz.threadPool.threadCount=10
    
    #Configure JDBC-JobStoreTX
    org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX
    org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.oracle.OracleDelegate
    org.quartz.jobStore.dataSource=myDS
    org.quartz.jobStore.tablePrefix=QRTZ_
    org.quartz.jobStore.isClustered=true
    org.quartz.jobStore.acquireTriggersWithinLock=true
    org.quartz.jobStore.clusterCheckinInterval = 30000
    
    #Configure DataSources
    org.quartz.dataSource.myDS.driver=com.alibaba.druid.proxy.DruidDriver
    org.quartz.dataSource.myDS.URL=jdbc:wrap-jdbc:filters=default:name=dragoon:jdbc:oracle:thin:@127.0.0.1:1521:test
    org.quartz.dataSource.myDS.user=
    org.quartz.dataSource.myDS.password=
    org.quartz.dataSource.myDS.maxConnections=5
    org.quartz.dataSource.myDS.validationQuery=select 1 from dual

org.quartz.scheduler.instanceName 属性可为任何值，用在 JDBC JobStore 中来唯一标识实例，但是所有集群节点中必须相同

org.quartz.jobStore.class属性为 JobStoreTX，将任务持久化到数据中。因为集群中节点依赖于数据库来传播 Scheduler 实例的状态，你只能在使用 JDBC JobStore 时应用 Quartz 集群。这意味着你必须使用 JobStoreTX 或是 JobStoreCMT 作为 Job 存储；你不能在集群中使用 RAMJobStore

3.实现任务的创建和管理

@Component("schedulerHelper")
    public class SchedulerHelper
    {
    
    	private static final String CONFIG_FILE="quartz-job.properties";
    	private static final String IDENTITY_JOB_PREFIX="job_";
    	private static final String IDENTITY_TRIGGER_PREFIX="trigger_";
            
           @Autowired
        private JobService jobService;//jobService 这个服务是实现管理任务的页面的服务实现
    	private Scheduler scheduler;
    	
    	
    
    	@Autowired
    	private StartJobSchedulerListener startJobSchedulerListener;//实现自己的Scheduler监听器，程序启动时，任务没创建时就创建
    
    	
    	
    	
           /**
    	 * tomcat一启动时，类实例化时就执行
    	 */
    	public void  init()
    	{
    		try{
    		     
                 // 创建一个定时器工厂
    			StdSchedulerFactory sf = new StdSchedulerFactory();
                            //初始化quartz-job.properties配置文件
    			sf.initialize(Thread.currentThread().getContextClassLoader().getResource(CONFIG_FILE).getFile());
    			scheduler = sf.getScheduler();
    			//把jobService放到scheduler上下文，job执行是可以获取并访问。
    			scheduler.getContext().put(SCHEDULER_KEY_JOBSERVICE,jobService);
    			startJobSchedulerListener.setSchedulerHelper(this);
                             //设置自己的监听器
    			scheduler.getListenerManager().addSchedulerListener(startJobSchedulerListener);
                           // 启动定时器
    			scheduler.start();
    			logger.info("====================job scheduler start");			
    		}catch(SchedulerException e){
    			logger.error("error",e);			
    		}
    		
    	}
    	
            
             /**
    	 * 根据jobentity创建并开始任务
    	 */
       public boolean createAndStartJob(JobEntity job)
    	{
    		JobDetail jobDetail=generateJobDetail(job);
    		Trigger trigger=generateTriggerBuilder(job).build();
    		
    		try {
    			scheduler.scheduleJob(jobDetail, trigger);
    			return true;
    		} catch (SchedulerException e) {
    			logger.error("scheduler.scheduleJob",e);
    			return false;
    		}
    	}
            /**
    	 * 清除
    	 */
    	public void clearAllScheduler()
    	{
    		try {
    			scheduler.clear();
    		} catch (SchedulerException e) {
    			logger.error("clearAllScheduler",e);
    		}
    	}
    	
            
             /**
    	 * 根据jobId和类型删除
    	 */
    	public boolean removeJob(Long jobId,String jobType) 
    	{
    		try {
    			scheduler.deleteJob(getJobKey(jobId,jobType));
    			return true;
    		} catch (SchedulerException e) {
    			logger.error("removeJob",e);
    			return false;
    		}		
    	}
    	    
             /**
    	 * 暂停任务
    	 */
    	public boolean pauseJob(Long jobId,String jobType)
    	{
    		try {
    			scheduler.pauseJob(getJobKey(jobId,jobType));
    			return true;
    		} catch (SchedulerException e) {
    			logger.error("resumeJob",e);
    			return false;
    		}
    	}
    	 
            /**
    	 * 马上只执行一次任务
    	 */
    	public boolean executeOneceJob(Long jobId,String jobType)
    	{
    		try {
    			Calendar end=Calendar.getInstance();			
    			TriggerBuilder<SimpleTrigger> simpleTriggerBuilder=TriggerBuilder.newTrigger()
    												.withIdentity(getTriggerKey(jobId,jobType))
    												.forJob(getJobKey(jobId,jobType))
    												.withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(2));
    			end.add(Calendar.SECOND, 2);
    			simpleTriggerBuilder.startAt(end.getTime());
    			end.add(Calendar.SECOND, 5);
    			simpleTriggerBuilder.endAt(end.getTime());
    			JobEntity job=jobService.getJobById(jobId);
    			
    			JobDataMap jobDataMap=new JobDataMap();
    			jobDataMap.put("jobEntity", job);
    			simpleTriggerBuilder.usingJobData(jobDataMap);
    			Trigger trigger=simpleTriggerBuilder.build();
    			
    			scheduler.scheduleJob(trigger);
    			return true;
    		} catch (SchedulerException e) {
    			logger.error("executeOneceJob",e);
    			return false;
    		}
    	}
            /**
    	 * 启动一些scheduler里没有的active的jobDetail
    	 */
    	public void createActiveJobFromDB() throws SchedulerException
    	{
    		List<JobEntity> jobs=jobService.getActiveJob();
    		for(JobEntity job:jobs)
    		{
    			if(scheduler.getJobDetail(getJobKey(job))==null)
    				createAndStartJob(job);
    		}
    	}
            
           /**
    	 * 获得任务的jobKey
    	 */
    	public static JobKey getJobKey(Long jobId,String jobType)
    	{
    		return new JobKey(IDENTITY_JOB_PREFIX+jobId,IDENTITY_JOB_PREFIX+jobType);
    	}
    	
          /**
    	 * 获得任务的jobKey
    	 */
    
    	public static JobKey getJobKey(JobEntity job)
    	{
    		return new JobKey(IDENTITY_JOB_PREFIX+job.getJobId(),IDENTITY_JOB_PREFIX+job.getJobType());
    	}
    	
        /**
    	 * 获得trigger的triggerkey
    	 */
    	public static TriggerKey getTriggerKey(JobEntity job)
    	{
    		return new TriggerKey(IDENTITY_TRIGGER_PREFIX+job.getJobId()+"_"+System.currentTimeMillis(), IDENTITY_TRIGGER_PREFIX+job.getJobType());
    	}
    	
    
            /**
    	 * 获得trigger的triggerkey
    	 */
    	public static TriggerKey getTriggerKey(Long jobId,String jobType)
    	{
    		return new TriggerKey(IDENTITY_TRIGGER_PREFIX+jobId+"_"+System.currentTimeMillis(), IDENTITY_TRIGGER_PREFIX+jobType);
    	}
    	
    	public static JobDetail generateJobDetail(JobEntity job)
    	{
    		JobDataMap jobDataMap=new JobDataMap();
    		jobDataMap.put("jobEntity", job);
    		Class<? extends Job> clazz=null;
    		 clazz=BeanJob.class;
    		return JobBuilder.newJob(clazz)
    			    		.withIdentity(getJobKey(job))
    			    		.usingJobData(jobDataMap)
    			    		.requestRecovery(true).storeDurably(true)
    			    		.build();
    	}
    	
    	
           /**
    	 * 根据jobEntity获得trigger
    	 */
    
    	public static TriggerBuilder<CronTrigger> generateTriggerBuilder(JobEntity job)
    	{
    		TriggerBuilder<CronTrigger> triggerBuilder= TriggerBuilder.newTrigger()
    	    		.withIdentity(getTriggerKey(job))
    				.withSchedule(CronScheduleBuilder.cronSchedule(job.getCronExpr())
    												.withMisfireHandlingInstructionDoNothing());
    		if(job.getSyncBeginTime()!=null)
    			triggerBuilder.startAt(job.getSyncBeginTime());
    		else
    			triggerBuilder.startNow();
    		
    		if(job.getSyncEndTime()!=null)
    			triggerBuilder.endAt(job.getSyncEndTime());
    	
    		return triggerBuilder;
    	}
    	
    	public static JobService getJobService(JobExecutionContext context)
    	{
    		try {
    			return (JobService) context.getScheduler().getContext().get(SchedulerHelper.SCHEDULER_KEY_JOBSERVICE);
    		} catch (SchedulerException e) {
    			logger.error("SchedulerHelper.getJobService",e);
    			return null;
    		}
    	}

4.实现自己的Scheduler监听器，程序启动时，创建scheduler里没有的active的jobDetail

@Component(value="startJobSchedulerListener")
    public class StartJobSchedulerListener extends SchedulerListenerSupport 
    {
    	private SchedulerHelper schedulerHelper;
    	
    	@Override
    	public void schedulerStarted()
    	{
    		try {
    			schedulerHelper.createActiveJobFromDB();
    		} catch (SchedulerException e) {
    			logger.error("createActiveJobFromDB",e);
    		}
    	}
    
    	public SchedulerHelper getSchedulerHelper() {
    		return schedulerHelper;
    	}
    
    	public void setSchedulerHelper(SchedulerHelper schedulerHelper) {
    		this.schedulerHelper = schedulerHelper;
    	}
    
    			
    }

5.实现的是一个job实例对应一个线程并实现页面配置对应的哪个类和方法

public abstract class AbstractEdiJob implements Job 
    {
    	protected JobEntity jobEntity; 
    	protected static final Logger logger=LoggerFactory.getLogger(AbstractEdiJob.class);
    	private Long beginTime;
    		
    	@Override
    	public void execute(JobExecutionContext context) throws JobExecutionException 
    	{
    		JobService jobService=SchedulerHelper.getJobService(context);
    		preExcute(jobService,context);
    		exeucuteInternal(context);
    		postExcute(jobService,context);
    	}
    	
    	abstract public void exeucuteInternal(JobExecutionContext context);
    	
    	public void preExcute(JobService jobService,JobExecutionContext context)
    	{
    		beginTime=System.currentTimeMillis();
    	}
    	
    	public void postExcute(JobService jobService,JobExecutionContext context)
    	{
    		//获得最新的jobEntiry
    		jobEntity=jobService.getJobById(jobEntity.getJobId());
    		if(jobEntity==null)
    		{
    			logger.warn(jobEntity.getJobId()+"job不能存在");
    			return;
    		}
    		if(context.getFireTime()!=null)
    			jobEntity.setRuntimeLast(context.getFireTime());
    		if(context.getNextFireTime()!=null)
    			jobEntity.setRuntimeNext(context.getNextFireTime());
    	/*	else
    			jobEntity.setJobStatus();*/
    		Long times=jobEntity.getRunTimes();
    		jobEntity.setRunTimes((times==null?0l:times)+1);
    		Long duration=jobEntity.getRunDuration();
    		jobEntity.setRunDuration((duration==null?0l:duration)+(System.currentTimeMillis()-beginTime));
    		jobService.updateJob(jobEntity);
    		//jobEntity这里的改变不能改变JobDetail里的JobEntity，因为生产的job是JobDetail的JobEntity的复制
    	}
    
    
    	public void setJobEntity(JobEntity jobEntity) {
    		this.jobEntity = jobEntity;
    	}
    
    
    }

/**
     *执行具体类中的方法
     **/
    public class BeanJob extends AbstractEdiJob 
    {
    	private static Logger logger=LoggerFactory.getLogger(BeanJob.class);
    	@Override
    	public void exeucuteInternal(JobExecutionContext context) 
    	{
    		Object obj=SpringContextUtil.getBean(jobEntity.getJobObject());
    		try {
    			Method method=obj.getClass().getMethod(jobEntity.getJobMethod());
    			method.invoke(obj);
    		} catch (SecurityException e) {
    			logger.error("error",e);
    		} catch (NoSuchMethodException e) {
    			logger.error("error",e);
    		} catch (IllegalArgumentException e) {
    			logger.error("error",e);
    		} catch (IllegalAccessException e) {
    			logger.error("error",e);
    		} catch (InvocationTargetException e) {
    			logger.error("error",e);
    		}
    	}
    
    }

6.新增一个任务时，数据库就保存对应的触发器，变成持久化任务，如图所示：

![SouthEast 4][]

1.用StdSchedulerFactory来获取Scheduler的实例，scheduler有启动(start)、中止(stop)和暂停(pause)方法。  
    2.JobDataMap实例，JobDataMap jobDataMap=new JobDataMap();jobDataMap.put("jobEntity", job);在同一任务的多次执行之间传递数据  
    3.创建JobDetail实例。JobBuilder.newJob(clazz).withIdentity(getJobKey(job)).usingJobData(jobDataMap).requestRecovery(true).storeDurably(true).build();返回JobDetail实例，newJob(clazz)是要执行特定任务的类；withIdentity(getJobKey(job))是job的任务名和组名；usingJobDatausingJobData(jobDataMap)传输数据；

4.创建Trigger实例。TriggerBuilder<CronTrigger> triggerBuilder= TriggerBuilder.newTrigger()  
                                                                                                .withIdentity(getTriggerKey(job))  
                                                                                     .withSchedule(CronScheduleBuilder.cronSchedule(job.getCronExpr())  
                      .withMisfireHandlingInstructionDoNothing());

withIdentity有标示了触发器的名称和组（Quartz调度是通过触发器的类别来识别不同的任务），和withSchedule标示执行的时间表达式

5.最后通过scheduler.scheduleJob()方法调度任务。

[SouthEast]: /images/20220810/b43621a843de44afb9c8439b6d15759d.png
[SouthEast 1]: /images/20220810/1ce91381cbdb463ca2217ff216602169.png
[SouthEast 2]: /images/20220810/f55202e38ac744e6b7834e3b5597c26b.png
[SouthEast 3]: /images/20220810/ceb6b52520774517a9dfbaf40dfc7cd5.png
[SouthEast 4]: /images/20220810/c67a59e676204cadba07eb9a12bf65b6.png