spring整合quartz實現動態定時任務

目前的思路是先參考springboot整合quartz

本文代碼參考：

https://www.cnblogs.com/hhhshct/p/9707710.html

https://www.cnblogs.com/hhhshct/p/9708688.html

第一步，加入quartz的依賴

<!--quartz start-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz-jobs</artifactId>
             <version>2.3.0</version>
        </dependency>
        <!--定時任務需要依賴context模塊-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.1.2.RELEASE</version>
        </dependency>
       <!-- quartz end -->   

爲了確保依賴間沒有衝突，我們先啓動一下試試

啓動正常，不報錯，則沒問題。

第二步、導入代碼，我直接copy的上一篇spring boot整合quartz的代碼

上代碼

1.配置類：QuartzConfiguration

@Configuration
@EnableScheduling
public class QuartzConfiguration {
	public static class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {

		private transient AutowireCapableBeanFactory beanFactory;

		@Override
		public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
			beanFactory = applicationContext.getAutowireCapableBeanFactory();
		}

		/**
		 * 將job實例交給spring ioc託管 我們在job實例實現類內可以直接使用spring注入的調用被spring ioc管理的實例
		 *
		 * @param bundle
		 * @return
		 * @throws Exception
		 */
		@Override
		protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
			final Object job = super.createJobInstance(bundle);
			/**
			 * 將job實例交付給spring ioc
			 */
			beanFactory.autowireBean(job);
			return job;
		}

		/**
		 * 配置任務工廠實例
		 *
		 * @return
		 */
		@Bean
		public JobFactory jobFactory() {
			/**
			 * 採用自定義任務工廠 整合spring實例來完成構建任務
			 */
			AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
			return jobFactory;
		}

		/**
		 * 配置任務調度器 使用項目數據源作爲quartz數據源
		 *
		 * @param jobFactory
		 *            自定義配置任務工廠
		 * @param dataSource
		 *            數據源實例
		 * @return
		 * @throws Exception
		 */
		@Bean(destroyMethod = "destroy", autowire = Autowire.NO)
		public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory, DataSource dataSource)
				throws Exception {
			SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
			// 將spring管理job自定義工廠交由調度器維護
			schedulerFactoryBean.setJobFactory(jobFactory);
			// 設置覆蓋已存在的任務
			schedulerFactoryBean.setOverwriteExistingJobs(true);
			// 項目啓動完成後，等待2秒後開始執行調度器初始化
			schedulerFactoryBean.setStartupDelay(2);
			// 設置調度器自動運行
			schedulerFactoryBean.setAutoStartup(true);
			// 設置數據源，使用與項目統一數據源
			schedulerFactoryBean.setDataSource(dataSource);
			// 設置上下文spring bean name
			schedulerFactoryBean.setApplicationContextSchedulerContextKey("applicationContext");
			// 設置配置文件位置
			schedulerFactoryBean.setConfigLocation(new ClassPathResource("/quartz.properties"));
			return schedulerFactoryBean;
		}
	}
}

2.配置文件：quartz.properties

org.quartz.scheduler.instanceName = schedulerFactoryBean

org.quartz.scheduler.instanceId = AUTO

org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX

org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate

org.quartz.jobStore.tablePrefix = QRTZ_

#開啓分佈式部署
org.quartz.jobStore.isClustered = true
#分佈式節點有效性檢查時間間隔，單位：毫秒
org.quartz.jobStore.clusterCheckinInterval = 10000

org.quartz.jobStore.useProperties = false

org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool

org.quartz.threadPool.threadCount = 10

org.quartz.threadPool.threadPriority = 5

#配置是否啓動自動加載數據庫內的定時任務，默認true
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true

3.QuartzService

public interface QuartzService {
	  /**
     * 增加一個job
     * 
     * @param jobClass
     *            任務實現類
     * @param jobName
     *            任務名稱
     * @param jobGroupName
     *            任務組名
     * @param jobTime
     *            時間表達式 (這是每隔多少秒爲一次任務)
     * @param jobTimes
     *            運行的次數 （<0:表示不限次數）
     */
	 public void addJob(Class<? extends QuartzJobBean> jobClass, String jobName, String jobGroupName, int jobTime,
	            int jobTimes);
	 
	 /**
	     * 增加一個job
	     * 
	     * @param jobClass
	     *            任務實現類
	     * @param jobName
	     *            任務名稱
	     * @param jobGroupName
	     *            任務組名
	     * @param jobTime
	     *            時間表達式 （如：0/5 * * * * ? ）
	     */
	    public void addJob(Class<? extends QuartzJobBean> jobClass, String jobName, String jobGroupName, String jobTime) ;
	 
	    /**
	     * 修改 一個job的 時間表達式
	     * 
	     * @param jobName
	     * @param jobGroupName
	     * @param jobTime
	     */
	    public void updateJob(String jobName, String jobGroupName, String jobTime);
	    
	    /**
	     * 刪除任務一個job
	     * 
	     * @param jobName
	     *            任務名稱
	     * @param jobGroupName
	     *            任務組名
	     */
	    public void deleteJob(String jobName, String jobGroupName);
	    
	    /**
	     * 暫停一個job
	     * 
	     * @param jobName
	     * @param jobGroupName
	     */
	    public void pauseJob(String jobName, String jobGroupName);
	    
	    /**
	     * 恢復一個job
	     * 
	     * @param jobName
	     * @param jobGroupName
	     */
	    public void resumeJob(String jobName, String jobGroupName) ;
	    
	    /**
	     * 立即執行一個job
	     * 
	     * @param jobName
	     * @param jobGroupName
	     */
	    public void runAJobNow(String jobName, String jobGroupName);
	    
	    /**
	     * 獲取所有計劃中的任務列表
	     * 
	     * @return
	     */
	    public List<Map<String, Object>> queryAllJob();
	    
	    /**
	     * 獲取所有正在運行的job
	     * 
	     * @return
	     */
	    public List<Map<String, Object>> queryRunJob() ;
}

4.QuartzServiceImpl

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.PostConstruct;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.DateBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobExecutionContext;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.DateBuilder.IntervalUnit;
import org.quartz.impl.matchers.GroupMatcher;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.QuartzJobBean;
import org.springframework.stereotype.Service;



/**
 * @Description
 * @author 
 * @date 2019年9月26日 下午1:58:59
 */
@Service
public class QuartzServiceImpl implements QuartzService{

	@Autowired
	private Scheduler scheduler;

	@PostConstruct
	public void startScheduler() {
		try {
			scheduler.start();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}

	@Override
	 public void addJob(Class<? extends QuartzJobBean> jobClass, String jobName, String jobGroupName, int jobTime,
	            int jobTimes) {
	        try {
	            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)// 任務名稱和組構成任務key
	                    .build();
	            // 使用simpleTrigger規則
	            Trigger trigger = null;
	            if (jobTimes < 0) {
	                trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)
	                        .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1).withIntervalInSeconds(jobTime))
	                        .startNow().build();
	            } else {
	                trigger = TriggerBuilder
	                        .newTrigger().withIdentity(jobName, jobGroupName).withSchedule(SimpleScheduleBuilder
	                                .repeatSecondlyForever(1).withIntervalInSeconds(jobTime).withRepeatCount(jobTimes))
	                        .startNow().build();
	            }
	            scheduler.scheduleJob(jobDetail, trigger);
	        } catch (SchedulerException e) {
	            e.printStackTrace();
	        }
	    }

	@Override
	 public void addJob(Class<? extends QuartzJobBean> jobClass, String jobName, String jobGroupName, String jobTime) {
        try {
            // 創建jobDetail實例，綁定Job實現類
            // 指明job的名稱，所在組的名稱，以及綁定job類
            JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroupName)// 任務名稱和組構成任務key
                    .build();
            // 定義調度觸發規則
            //獲取
            // 使用cornTrigger規則
            Trigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)// 觸發器key
                    .startAt(DateBuilder.futureDate(1, IntervalUnit.SECOND))
                    .withSchedule(CronScheduleBuilder.cronSchedule(jobTime)).startAt(triggerStartTime).build();
            // 把作業和觸發器註冊到任務調度中
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
	@Override
	 public void updateJob(String jobName, String jobGroupName, String jobTime) {
        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                    .withSchedule(CronScheduleBuilder.cronSchedule(jobTime)).build();
            // 重啓觸發器
            scheduler.rescheduleJob(triggerKey, trigger);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

	@Override
	   public void deleteJob(String jobName, String jobGroupName) {
        try {
            scheduler.deleteJob(new JobKey(jobName, jobGroupName));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

	@Override
	public void pauseJob(String jobName, String jobGroupName) {
        try {
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            scheduler.pauseJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

	@Override
	public void resumeJob(String jobName, String jobGroupName) {
        try {
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            scheduler.resumeJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }
	@Override
	 public void runAJobNow(String jobName, String jobGroupName) {
        try {
            JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
            scheduler.triggerJob(jobKey);
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

	@Override
	 public List<Map<String, Object>> queryAllJob() {
        List<Map<String, Object>> jobList = null;
        try {
            GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();
            Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
            jobList = new ArrayList<Map<String, Object>>();
            for (JobKey jobKey : jobKeys) {
                List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
                for (Trigger trigger : triggers) {
                    Map<String, Object> map = new HashMap<>();
                    map.put("jobName", jobKey.getName());
                    map.put("jobGroupName", jobKey.getGroup());
                    map.put("description", "觸發器:" + trigger.getKey());
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                    map.put("jobStatus", triggerState.name());
                    if (trigger instanceof CronTrigger) {
                        CronTrigger cronTrigger = (CronTrigger) trigger;
                        String cronExpression = cronTrigger.getCronExpression();
                        map.put("jobTime", cronExpression);
                    }
                    jobList.add(map);
                }
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return jobList;
    }


	@Override
	  public List<Map<String, Object>> queryRunJob() {
        List<Map<String, Object>> jobList = null;
        try {
            List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
            jobList = new ArrayList<Map<String, Object>>(executingJobs.size());
            for (JobExecutionContext executingJob : executingJobs) {
                Map<String, Object> map = new HashMap<String, Object>();
                JobDetail jobDetail = executingJob.getJobDetail();
                JobKey jobKey = jobDetail.getKey();
                Trigger trigger = executingJob.getTrigger();
                map.put("jobName", jobKey.getName());
                map.put("jobGroupName", jobKey.getGroup());
                map.put("description", "觸發器:" + trigger.getKey());
                Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());
                map.put("jobStatus", triggerState.name());
                if (trigger instanceof CronTrigger) {
                    CronTrigger cronTrigger = (CronTrigger) trigger;
                    String cronExpression = cronTrigger.getCronExpression();
                    map.put("jobTime", cronExpression);
                }
                jobList.add(map);
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
        return jobList;
    }


}

5.TestJob01

import java.util.Date;

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.scheduling.quartz.QuartzJobBean;

/**
 * @Description
 * @author 
 * @date 2019年9月26日 下午1:56:26
 */
public class TestJob01 extends  QuartzJobBean{

	@Override
	protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
		System.out.println(new Date()+"    job執行,"+" context:"+context);
	}

}

6.TestController

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;



/**
 * @Description
 * @author 
 * @date 2019年9月25日 下午4:30:31
 */
@RestController
public class TestController {

	@Autowired
	private QuartzService quartzService;
	
	 @RequestMapping("/addjob")
	    public void startJob(String type) {
	        if("TestJob1".equals(type)) {
	            quartzService.addJob(Testjob1.class, "job1", "test", "0/5 * * * * ?");
	            
	        }else {
	            quartzService.addJob(Testjob1.class, "job3", "test", "0/5 * * * * ?");
	        }
	    }
	    
	    @RequestMapping("/updatejob")
	    public void updatejob() {
	            quartzService.updateJob("job1", "test", "0/10 * * * * ?");
	    }
	    
	    @RequestMapping("/deletejob")
	    public void deletejob() {
	            quartzService.deleteJob("job1", "test");
	    }
	    
	    @RequestMapping("/pauseJob")
	    public void pauseJob() {
	            quartzService.pauseJob("job1", "test");
	    }
	    
	    @RequestMapping("/resumeJob")
	    public void resumeJob() {
	            quartzService.resumeJob("job1", "test");
	    }
	    
	    @RequestMapping("/queryAllJob")
	    public Object queryAllJob() {
	            return quartzService.queryAllJob();
	    }
	    

	    @RequestMapping("/queryRunJob")
	    public Object queryRunJob() {
	            return quartzService.queryRunJob();
	    }
	
}

好了就這麼多，歡迎評論互相學習~

 

關於集羣怎麼關閉，

我還不知道集羣怎麼關閉，有知道的小夥伴告訴下我

我是先把分佈式模式設置爲false

然後調用了shutdown方法

	@Override
	public void startJobs() {
		try {
            scheduler.start();
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

	}

	@Override
	public void shutdownJobs() {
	  try {
		if (!scheduler.isShutdown()) {
               scheduler.shutdown();
           }
       } catch (Exception e) {
           throw new RuntimeException(e);
       }

	}