1.引入依赖包
<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>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
</dependency>
2.新建 quartz.properties 配置文件
org.quartz.scheduler.instanceName = MyScheduler
org.quartz.threadPool.threadCount = 3
org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
先写这三行,见效快
3.写几个配置类,必须有
import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
public final class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements
ApplicationContextAware {
private transient AutowireCapableBeanFactory autowireCapablebeanFactory;
@Override
public void setApplicationContext(final ApplicationContext context) {
autowireCapablebeanFactory= context.getAutowireCapableBeanFactory();
}
@Override
protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
final Object job = super.createJobInstance(bundle);
autowireCapablebeanFactory.autowireBean(job);
return job;
}
}
import org.quartz.spi.JobFactory;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import java.io.IOException;
import java.util.Properties;
@Configuration
public class SchedulerConfig {
@Bean
public JobFactory jobFactory(ApplicationContext applicationContext)
{
AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
jobFactory.setApplicationContext(applicationContext);
return jobFactory;
}
@Bean
public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory) throws Exception {
SchedulerFactoryBean factory = new SchedulerFactoryBean();
factory.setOverwriteExistingJobs(true);
factory.setJobFactory(jobFactory);
factory.setQuartzProperties(quartzProperties());
factory.afterPropertiesSet();
return factory;
}
@Bean
public Properties quartzProperties() throws IOException {
PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
propertiesFactoryBean.afterPropertiesSet();
return propertiesFactoryBean.getObject();
}
}
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;
@Override
protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
// 调用父类的方法
Object jobInstance = super.createJobInstance(bundle);
// 进行注入
capableBeanFactory.autowireBean(jobInstance);
return jobInstance;
}
}
4.写个控制类
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 定时任务控制器
*
* @author ZYD 2018-8-26
*/
@Controller
public class MyJobController {
@Autowired
private Scheduler scheduler;
/**
* 添加定时任务
*
* @throws Exception
*/
@RequestMapping(value = "/myJob/initJob")
@ResponseBody
public void addjob() throws Exception {
}
public void addJob(String jobClassName, String jobName,String jobGroupName) throws Exception {
// 启动调度器
scheduler.start();
// 构建job信息
JobDetail jobDetail = JobBuilder.newJob(getClass(jobClassName()).getClass())
.withIdentity(jobName, jobGroupName).build();
// 表达式调度构建器(即任务执行的时间),默认 10 秒运行一次
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule("0/10 * * * ?");
// 按新的cronExpression表达式构建一个新的trigger
CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobClassName, jobGroupName)
.withSchedule(scheduleBuilder).build();
try {
scheduler.scheduleJob(jobDetail, trigger);
} catch (SchedulerException e) {
System.out.println("创建定时任务失败" + e);
throw new Exception("创建定时任务失败");
}
}
/**
* 暂停任务
*
* @param jobName 定时任务名称
* @param jobGroupName 分组名称
* @throws Exception
*/
@RequestMapping(value = "/myJob/pausejob")
@ResponseBody
public void pausejob(String jobName, String jobGroupName) throws Exception {
jobPause(jobName, jobGroupName);
}
public void jobPause(String jobName, String jobGroupName) throws Exception {
scheduler.pauseJob(JobKey.jobKey(jobName, jobGroupName));
}
/**
* 恢复任务
*
* @param jobName
* @param jobGroupName
* @throws Exception
*/
@RequestMapping(value = "/myJob/resumejob")
@ResponseBody
public void resumejob(String jobName, String jobGroupName) throws Exception {
jobresume(jobName, jobGroupName);
}
public void jobresume(String jobName, String jobGroupName) throws Exception {
scheduler.resumeJob(JobKey.jobKey(jobName, jobGroupName));
}
/**
* 重新安排任务
*
* @param jobName 任务名称
* @param jobGroupName 分组名称
* @param cronExpression 定时规则
* @throws Exception
*/
@RequestMapping(value = "/myJob/reschedulejob")
@ResponseBody
public void rescheduleJob(String jobName, String jobGroupName, String cronExpression) throws Exception {
jobreschedule(jobName, jobGroupName, cronExpression);
}
public void jobreschedule(String jobName, String jobGroupName, String cronExpression) throws Exception {
try {
TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);
// 表达式调度构建器
CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);
CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
// 按新的cronExpression表达式重新构建trigger
trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
// 按新的trigger重新设置job执行
scheduler.rescheduleJob(triggerKey, trigger);
} catch (SchedulerException e) {
System.out.println("更新定时任务失败" + e);
throw new Exception("更新定时任务失败");
}
}
/**
* 删除任务
*
* @param ids 多个 id 的字符串,由逗号分隔
* @throws Exception
*/
@RequestMapping(value = "/myJob/deletejob")
@ResponseBody
public void deletejob(String ids) throws Exception {
jobdelete(myJob.getJobName(), myJob.getJobGroupName());
}
public void jobdelete(String jobName, String jobGroupName) throws Exception {
scheduler.pauseTrigger(TriggerKey.triggerKey(jobName, jobGroupName));
scheduler.unscheduleJob(TriggerKey.triggerKey(jobName, jobGroupName));
scheduler.deleteJob(JobKey.jobKey(jobName, jobGroupName));
}
private static BaseJob getClass(String classname) throws Exception {
Class<?> class1 = Class.forName("com.dinsmooth.cis.task." + classname);
return (BaseJob) class1.newInstance();
}
}
怎么使用自己脑补吧