springboot 继承quartz（这里使用内存存储任务，如果想使用数据库存储需要额外配置DataSource这里暂不赘述）
- 引入依赖pom
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
- 配置quartz 和spring依赖依赖注入等
SpringJobFactory 是为了在job中能依赖注入spring 的bean
@Component
public class SpringJobFactory extends AdaptableJobFactory {
@Autowired
private AutowireCapableBeanFactory capableBeanFactory;
@Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
// 调用父类的方法
Object jobInstance = super.createJobInstance(bundle);
// 进行注入
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}
@Configuration
public class QuartzConfig {
//注入JobFactory
@Autowired
SpringJobFactory springJobFactory;
/**
* SchedulerFactoryBean这个类的真正作用提供了对org.quartz.Scheduler的创建与配置，并且会管理它的生命周期与Spring同步。
* org.quartz.Scheduler: 调度器。所有的调度都是由它控制。
* 数据源默认内存，且为非集群模式
*/
@Bean
public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
SchedulerFactoryBean factory = new SchedulerFactoryBean();
//设置自行启动
factory.setAutoStartup(true);
factory.setJobFactory(springJobFactory);
factory.setQuartzProperties(quartzProperties());
return factory;
}
//注入scheduler到spring
@Bean(name = "scheduler")
public Scheduler scheduler() throws IOException {
return schedulerFactoryBean().getScheduler();
}
@Bean
public Properties quartzProperties() throws IOException {
Properties properties = new Properties();
// ID设置为自动获取 每一个必须不同 （所有调度器实例中是唯一的）
properties.setProperty("org.quartz.scheduler.instanceId","AUTO");
// ThreadPool实现的类名
properties.setProperty("org.quartz.threadPool.class","org.quartz.simpl.SimpleThreadPool");
return properties;
}
- 完成配置后，就可以使用了
例如：先创建一个spring service
@Service
public class SrpingService {
public void test(){
System.out.println("spring service");
}
}
创建job 并注入该service
public class MyJob extends QuartzJobBean {
@Autowired
private SrpingService service;
@Override
protected void executeInternal(JobExecutionContext jobExecutionContext) throws JobExecutionException {
//如果超时下发超时提醒，并取消招车单，招车单编号
service.test();
}
}
创建一个job监听器,可以处理一些任务前后
@Component
public class JobListener implements JobListener {
@Autowired
JobScheduler scheduler;
//获取该JobListener的名称
@Override
public String getName() {
// TODO Auto-generated method stub
String name = getClass().getSimpleName();
log.info(name);
return name;
}
//：Scheduler在JobDetail即将被执行，但又被TriggerListerner否决时会调用该方法
@Override
public void jobExecutionVetoed(JobExecutionContext arg0) {
// TODO Auto-generated method stub
log.info("Scheduler在JobDetail即将被执行，但又被TriggerListerner否决");
}
//Scheduler在JobDetail将要被执行时调用这个方法。
@Override
public void jobToBeExecuted(JobExecutionContext arg0) {
// TODO Auto-generated method stub
log.info("Scheduler在JobDetail将要被执行");
}
//Scheduler在JobDetail被执行之后调用这个方法
@Override
public void jobWasExecuted(JobExecutionContext arg0, JobExecutionException arg1) {
// TODO Auto-generated method stub
log.info("Scheduler在JobDetail被执行之后,删除该job");
JobKey jobKey = arg0.getJobDetail().getKey();
//移除该job
scheduler.deleteJob(jobKey);
}
}
写一个JobScheduler封装Scheduler为方便使用(并且初始化启动)
@Service
public class JobScheduler {
@Autowired
private Scheduler scheduler;
//初始化启动
@PostConstruct
public void initialize() {
try {
scheduler.start();
} catch (SchedulerException e) {
}
}
public void addJob(JobDetail jobDetail, Trigger trigger){
//加入这个调度
try {
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
public void runSchedule(){
try {
scheduler.start();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
public void deleteJob(JobKey jobKey){
try {
scheduler.deleteJob(jobKey);
} catch (SchedulerException e) {
e.printStackTrace();
}
}
/**
* 添加指定的job监听器
* @param jobListener
*/
public void addJobListiner(JobListener jobListener,String jobName,String jobGroupName){
try {
scheduler.getListenerManager().addJobListener(jobListener, KeyMatcher.keyEquals(JobKey.jobKey(jobName,jobGroupName)));
} catch (SchedulerException e) {
e.printStackTrace();
}
}
}
处理完，就可以使用了
@Service
public class MyUserQuartzService {
@Autowired
private JobScheduler jobScheduler;
@Autowired
private JobListener jobListener;
public void testQuartz(){
jobScheduler.addJobListiner(jobListener,"jobName","groupName");
JobDetail jobDetail= JobBuilder.newJob(MyJob.class).withIdentity("jobName","groupName").storeDurably().build();
Trigger trigger = TriggerBuilder.newTrigger()
//一分钟后执行
.startAt(DateBuilder.futureDate(1, DateBuilder.IntervalUnit.MINUTE))
.withIdentity("triggerName","groupName")
// .withSchedule(simpleScheduleBuilder) 可以写自己的cron方式
.build();
//因为前面已经启动scheduler，所以这里直接放入即可
jobScheduler.addJob(jobDetail, trigger);
}
