quartz简介
Quartz是一个完全由java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能, 但还是相对而言比较简单的。简创建一个实现org.quartz.Job接口的java类。Job接口包含唯一的方法:
public void execute(JobExecutionContext context)
throws JobExecutionException;
在你的Job接口实现类里面,添加一些逻辑到execute()方法。一旦你配置好Job实现类并设定好调度时间表,Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候,Quartz框架将调用你Job实现类(作业类)上的execute()方法并允许做它该做的事情。无需报告任何东西给调度器或调用任何特定的东西。仅仅执行任务和结束任务即可。如果配置你的作业在随后再次被调用,Quartz框架将在恰当的时间再次调用它(简介来源)。
quartz管理类
定时任务的启动主要包含以下五步:
- 创建一个JobDetail实例
- 定义一个Trigger(触发器)
- 创建scheduler
- 将trigger和jobdetail加入scheduler中
- 启动scheduler
在quartz使用之前,需要在pom.xml里面添加如下dependency:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
以下是quartz定时任务的工具类代码:
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
public class QuartzManageKit {
public void startJob(Class<TestJob> clazz,String groupName,String planName,String cron) {
try {
// 1. 创建一个JobDetail实例
JobDetail jobDetail = JobBuilder.newJob(clazz) // 定义Job类为传递过来实现了job的类,这是真正的执行逻辑所在
.withIdentity(groupName) // 定义name/group
.build();
// 2. 定义一个Trigger,执行的时间间隔由参数决定
CronTrigger trigger = (CronTrigger) TriggerBuilder.newTrigger()
.withIdentity(planName, groupName)// 定义名字和组
.withSchedule( //定义任务调度的时间间隔和次数
CronScheduleBuilder
.cronSchedule(cron)
)
.build();
// 3. 创建scheduler
SchedulerFactory sfact = new StdSchedulerFactory();
Scheduler scheduler = sfact.getScheduler();
// 4. 将trigger和jobdetail加入这个调度
scheduler.scheduleJob(jobDetail, trigger);
// 5. 启动scheduler
scheduler.start();
} catch (Exception e) {
e.printStackTrace();
}
}
}
除了工具类,quartz还需要一个AdaptableJobFactory的继承类,否则Job的作业类中无法注入由Spring容器所管理的Bean。具体的AdaptableJobFactory继承类代码如下:
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;
@Component
public class MyJobFactory extends AdaptableJobFactory {
@Autowired
private AutowireCapableBeanFactory capableBeanFactory;
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
Object jobInstance = super.createJobInstance(bundle);
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}
监听器的选择与说明
本次示例使用的监听器是实现ApplicationListener的方式。
ApplicationListener是通过指定泛型,确定其监听器执行的方式和时机,在相应的调用时机回调实现该接口的类。
本次示例选用ContextRefreshedEvent事件泛型,即在context初始化或者改变的时候调用当前实现ApplicationListener监听器中的onApplicationEvent方法。以下是监听器的具体实现代码:
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;
import com.es.quartz.MyJobFactory;
import com.es.quartz.QuartzManageKit;
import com.es.quartz.TestJob;
@Configuration
@Component
@Transactional
public class StartQuartzJobListener implements ApplicationListener<ContextRefreshedEvent> {
private static final Logger logger = LoggerFactory.getLogger(StartQuartzJobListener.class);
/* quartz */
@Autowired
private MyJobFactory myJobFactory;
/**
* 初始启动quartz
*/
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
logger.debug("定时任务监听器启动");
try {
QuartzManageKit quartz = new QuartzManageKit();
quartz.startJob(TestJob.class, "TestJob ", "TestJob ", "0/10 * * * * ? ");
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* @title:修改默认的jobFactory 支持Job中注入
*/
@Bean
public SchedulerFactoryBean schedulerFactoryBean () throws Exception {
SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
factoryBean.setOverwriteExistingJobs(true);
//延时启动20秒
factoryBean.setStartupDelay(20);
factoryBean.setJobFactory(myJobFactory);
return factoryBean;
}
}
其中startJob类中的参数传递给工具类需要执行的任务类、任务组名称、任务名称和定时任务的执行时间。
当前的定时任务触发器我选择的CronTrigger ,即需要执行的时间需要用crontab表达式控制。
crontab表达式从左到右依次表示:秒 分 时 日 月 周
示例:
crontab表达式 | 描述 |
---|---|
0 0 10 * * ? | 每天早上10点执行任务 |
0 30 10 1 * ? | 每月1号早上10:30执行任务 |
所以 0/10 * * * * ? 表示的是每10秒执行一次定时任务,即在每十秒,quartz就会调用一次实现了Job类的TestJob中的execute()方法。
Job的实现
Quartz框架在需要执行定时任务的时候,会调用你Job实现类(作业类)上的execute()方法实现方法中的业务逻辑。
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class TestJob implements Job{
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println("TestJob.execute("+ new Date().toLocaleString() +")");
}
}
项目启动
这时,所有的准备工作都已做好,只需要启动当前的项目即可触发监听器的监听规则,启动定时任务开始执行job实现类的业务。
本次示例使用springboot启动,具体实现如下:
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
当然,以上方法使用主方法启动也可以,具体实现方式如下:
public class JobMain {
public static void main(String[] args) {
QuartzManageKit quartz = new QuartzManageKit();
quartz.startJob(TestJob.class, "testJob", "testJob", "0/10 * * * * ?");
}
}
执行结果展示
启动项目或主方法之后,即可在控制台看到如下打印。如此,定时任务已经实现。