springboot+quartz以持久化的方式實現定時任務
篇幅較長，耐心的人總能得到最後的答案
小生第一次用quartz做定時任務，不足之處多多諒解。
首先
在springboot專案裡做定時任務是比較簡單的，最簡單的實現方式是使用@Scheduled註解，
然後在application啟動類上使用@EnableScheduling開啟定時任務。
示例
@SpringBootApplication
@EnableScheduling
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
// cron為每秒執行一次
@Scheduled(cron = "* * * * * ?")
public void print(){
System.out.println("執行定時任務");
}
}
結果
執行定時任務
執行定時任務
執行定時任務
執行定時任務
執行定時任務
執行定時任務
執行定時任務
執行定時任務
簡單的定時任務就可以用這種方式來做，cron表示式的結果為任務執行的間隔時間。這裡放幾個線上生成cron表示式的連結西施-王昭君-貂蟬-楊玉環四大美女！香不香
然而
實際開發中，我們的任務可能有很多，且需要手動操作單個/全部的任務，比如新增、開啟、停止、繼續等等操作。那麼伴隨著(千牛B類。。。)的BGM有請quartz登場。
quartz
整合
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
quartz的三要素
排程器Scheduler
啟動觸發器去執行任務
觸發器Trigger
用來定義Job（任務）觸發條件、觸發時間，觸發間隔，終止時間等
任務job
具體要執行的任務內容
使用
使用quartz是需要配置檔案的，quartz.properties
在quartz的jar包的org.quartz包下可以找到預設的配置檔案quartz.properties
# Default Properties file for use by StdSchedulerFactory
# to create a Quartz Scheduler Instance, if a different
# properties file is not explicitly specified.
#
# 名字
org.quartz.scheduler.instanceName: DefaultQuartzScheduler
org.quartz.scheduler.rmi.export: false
org.quartz.scheduler.rmi.proxy: false
org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
# 例項化ThreadPool時，使用的執行緒類為SimpleThreadPool
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
# 執行緒總個數
org.quartz.threadPool.threadCount: 10
# 執行緒的優先順序
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
org.quartz.jobStore.misfireThreshold: 60000
# 持久化方式，預設持久化在記憶體中，後面我們使用db的方式
org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
quartz任務持久化到db則需要一些官方定義的資料庫表，表的sql檔案可以在quartz的jar包裡找到
座標org.quartz.impl.jdbcjobstore，可以看到裡面有很多sql檔案，有各種資料庫的，我們們用MySQL的，我們們不需要手動執行sql語句，後面我們們在啟動專案的時候自動初始化。
建立我們自己的properties檔案
# 例項化ThreadPool時，使用的執行緒類為SimpleThreadPool
org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
# threadCount和threadPriority將以setter的形式注入ThreadPool例項
# 併發個數
org.quartz.threadPool.threadCount=10
# 優先順序
org.quartz.threadPool.threadPriority=5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
org.quartz.jobStore.misfireThreshold=5000
#持久化使用的類
org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
#資料庫中表的字首
org.quartz.jobStore.tablePrefix=QRTZ_
#資料來源命名
org.quartz.jobStore.dataSource=qzDS
#qzDS 資料來源，我們使用hikaricp，預設的是c3p0
org.quartz.dataSource.qzDS.provider=hikaricp
org.quartz.dataSource.qzDS.driver=com.mysql.cj.jdbc.Driver
org.quartz.dataSource.qzDS.URL=jdbc:mysql://localhost:3306/quartz?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
org.quartz.dataSource.qzDS.user=root
org.quartz.dataSource.qzDS.password=123456
org.quartz.dataSource.qzDS.maxConnections=10
既然我們沒有使用預設的連線池，那麼就探索一下，上原始碼！
在這個包下：org.quartz.utils，有一個PoolingConnectionProvider，顧名思義，連線池提供者
部分原始碼
public interface PoolingConnectionProvider extends ConnectionProvider {
/** The pooling provider. */
String POOLING_PROVIDER = "provider";
/** The c3p0 pooling provider. */
String POOLING_PROVIDER_C3P0 = "c3p0";
/** The Hikari pooling provider. */
String POOLING_PROVIDER_HIKARICP = "hikaricp";
}
然後HikariCpPoolingConnectionProvider這個類實現了PoolingConnectionProvider，自行檢視。
我們可以在org.quartz.impl下的StdSchedulerFactory中搜尋c3p0找到
if(poolingProvider != null && poolingProvider.equals(PoolingConnectionProvider.POOLING_PROVIDER_HIKARICP)) {
cpClass = "org.quartz.utils.HikariCpPoolingConnectionProvider";
}
else {
cpClass = "org.quartz.utils.C3p0PoolingConnectionProvider";
}
剩下的自己多看看吧，起始原始碼研究起來沒有想象中那麼難那麼乏味(我也不喜歡看原始碼)，但是這個原始碼看起來確實小有成就感。
回到正題頻道，配置application.yml
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
password: 123456
url: jdbc:mysql://localhost:3306/quartz?characterEncoding=UTF8&useSSL=false&serverTimezone=GMT%2B8
username: root
quartz:
jdbc:
initialize-schema: always
job-store-type: jdbc
initialize-schema: always每次啟動專案，總是初始化資料庫表自動建立表的關鍵地方，流程是先刪除資料庫表，再建立，如果表不存在，則拋異常，但是不會影響後面的生成表，下次再啟動專案的時候，由於表已經存在了，所以不會再拋異常了
job-store-type: jdbc就是任務持久化型別，我們用jdbc
我們可能要在job裡注入spring物件，不做配置，是無法注入的。
/**
* @author: taoym
* @date: 2020/6/4 11:32
* @desc: 一定要自定義JobFactory重寫SpringBeanJobFactory的createJobInstance方法，否則在job中是獲取不到spring容器中的bean的
*/
@Component
public class JobFactory extends SpringBeanJobFactory {
@Autowired
private AutowireCapableBeanFactory beanFactory;
/**
* 這裡覆蓋了super的createJobInstance方法，對其建立出來的類再進行autowire
*/
@Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
Object jobInstance = super.createJobInstance(bundle);
beanFactory.autowireBean(jobInstance);
return jobInstance;
}
}
建立quartz的配置檔案
@Configuration
public class QuartzConfig {
@Autowired
private JobFactory jobFactory;
/**
* 讀取quartz.properties 檔案
* 將值初始化
*
* @return
*/
@Bean
public Properties quartzProperties() throws IOException {
PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
propertiesFactoryBean.afterPropertiesSet();
return propertiesFactoryBean.getObject();
}
@Bean
public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
schedulerFactoryBean.setJobFactory(jobFactory);
schedulerFactoryBean.setQuartzProperties(quartzProperties());
return schedulerFactoryBean;
}
/**
* 初始化監聽器
*
* @return
*/
@Bean
public QuartzInitializerListener executorListener() {
return new QuartzInitializerListener();
}
@Bean(name = "scheduler")
public Scheduler scheduler() throws IOException {
return schedulerFactoryBean().getScheduler();
}
}
建立觸發器元件
public class TriggerComponent {
/**
* @author: taoym
* @date: 2020/6/1 10:35
* @desc: 構建cron觸發器
*/
public static Trigger cronTrigger(String cron) {
CronTrigger cronTrigger = TriggerBuilder.newTrigger()
.withSchedule(CronScheduleBuilder.cronSchedule(cron).withMisfireHandlingInstructionDoNothing())
.build();
return cronTrigger;
}
public static Trigger cronTrigger(String cron, JobDataMap jobDataMap) {
CronTrigger cronTrigger = TriggerBuilder.newTrigger()
.withSchedule(CronScheduleBuilder.cronSchedule(cron).withMisfireHandlingInstructionDoNothing())
.usingJobData(jobDataMap)
.build();
return cronTrigger;
}
}
觸發器就用這個元件來獲取就行了。
建立任務
@DisallowConcurrentExecution
public class TestJob extends QuartzJobBean {
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
}
}
jobExecutionContext這裡面可以獲取任務組、任務名、觸發器組、觸發器名、jobdetail等資訊。
那個註解是為了讓同一個例項(jobdetail)只能單執行緒執行。
可以這麼理解，job為介面，jobdetail為實現類，a是其中一個實現類，a需要花費100s執行一定的操作，而你給的定時器是沒50s就執行一次操作，a在執行到一半的時候又需要開啟一個執行緒來執行。使用了DisallowConcurrentExecution就相當於a沒有把操作執行完的時候，a不允許開啟執行緒再執行當前操作。
不知道我的描述是否易懂！
按需建立自己的任務表，我是用定時任務做爬蟲的(小爬蟲)
CREATE TABLE `quartz_job` (
`id` int(11) NOT NULL AUTO_INCREMENT COMMENT '編號',
`job_name` varchar(50) DEFAULT '' COMMENT '任務名',
`job_group` varchar(50) DEFAULT '' COMMENT '任務組名稱',
`job_desc` varchar(255) DEFAULT '' COMMENT 'job描述',
`cron` varchar(50) DEFAULT '' COMMENT 'cron表示式',
`status` tinyint(1) DEFAULT '0' COMMENT '狀態',
`url` varchar(255) DEFAULT '' COMMENT '請求地址',
`param` varchar(255) DEFAULT '' COMMENT '引數',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=31 DEFAULT CHARSET=utf8;
我們新增任務的時候不和quartz打交道，把任務放到資料庫即可。別慌，後面有用到他的地方。
這個表需要有增刪改查操作，我們會在系統中查詢任務列表選擇單個或者所有任務開始執行
執行任務
@Resource
private QuartzJobMapper quartzJobMapper;
@Autowired
private Scheduler scheduler;
@Override
public String start(Integer id) {
JobDataMap jobDataMap = new JobDataMap();
jobDataMap.put(k,v);
QuartzJob quartzJob = quartzJobMapper.selectByPrimaryKey(id);
JobKey jobKey = JobKey.jobKey(quartzJob.getJobName(), quartzJob.getJobGroup());
jobDetail = JobBuilder.newJob(TestJob.class).withIdentity(jobKey).storeDurably().build();
Trigger trigger = TriggerComponent.cronTrigger(quartzJob.getCron(), jobDataMap);
try {
scheduler.scheduleJob(jobDetail, trigger);
quartzJobMapper.updateStatus(true, id);
return "開始任務執行成功";
} catch (SchedulerException se) {
log.info("開始任務的時候發生了錯誤");
}
return "開始任務的時候發生了錯誤,請檢查日誌";
}
最後我又按照此教程上的內容貼上了一遍程式碼，可以正常執行。
轉載請說明來源，謝謝！