SpringBoot 的几种定时任务
- Timer：这是java自带的java.util.Timer类，这个类允许你调度一个java.util.TimerTask任务。使用这种方式可以让你的程序按照某一个频度执行，但不能在指定时间运行。一般用的较少。
- ScheduledExecutorService：也jdk自带的一个类；是基于线程池设计的定时任务类,每个调度任务都会分配到线程池中的一个线程去执行,也就是说,任务是并发执行,互不影响。
- Spring Task：Spring3.0以后自带的task，可以将它看成一个轻量级的Quartz，而且使用起来比Quartz简单许多。
- Quartz：这是一个功能比较强大的的调度器，可以让你的程序在指定时间执行，也可以按照某一个频度执行，配置起来稍显复杂。
SpringBoot 快速实现定时任务
为什么说快速实现定时任务，Spring 3.0 以后自带定时任务task，相当于轻量级的Quartz，省去了Quartz复杂的配置步骤，上手简单，提高我们的开发速度
第一步：创建项目，在启动类中加入注解：@EnableScheduling 表示开启定时任务
第二步：创建定时任务类和方法，在需要执行定时任务的方法上使用注解：@Scheduled，在给Scheduled配置一些属性，一个简单的定时任务就实现了
1、Scheduled 注解常用属性
- cron ：支持cron表达式启动定时任务 - fixedDelay：上一次任务执行结束后等待多少毫秒后，开始下一个任务 - fixedRate：上一个任务开始执行等待多少毫秒后执行下一个任务，如果上一个任务执行的时间大于等待时间，那么上一个任务执行完成后立即执行下一个任务
注意：fixedRate 的任务某次执行时间再长也不会造成两次任务实例同时执行，除非用了 @Async 注解。 fixedDelay 总是前一次任务完成后，延时固定长度然后执行一次任务
下面我们来看一段代码帮助大家使用：
@Component
@Slf4j
public class MyShedule {
/**
* cron表达式触发定时任务
*/
@Async
@Scheduled(cron = "0/5 * * * * *")
public void test1(){
log.info("===========> cron方式执行定时任务 {}",new Date());
}
/**
* 上次任务执行结束后间隔时间执行，单位毫秒
*/
@Async
@Scheduled(fixedDelay = 2000)
public void test2() throws InterruptedException {
TimeUnit.SECONDS.sleep(5);
log.info("===========> fixedDelay方式执行定时任务 {}",new Date());
}
/**
* 上次任务开始执行后间隔时间执行，单位毫秒
*/
@Async
@Scheduled(fixedRate = 200)
public void test3() throws InterruptedException {
TimeUnit.SECONDS.sleep(2);
log.info("===========> fixedRate方式执行定时任务 {}",new Date());
}
}
2、多线程执行
官网学习地址：https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-task-execution-scheduling
在传统的Spring项目中，我们可以在xml配置文件添加task的配置，而在SpringBoot项目中一般使用config配置类的方式添加配置，所以新建一个AsyncConfig类
@Configuration
@EnableAsync
public class AsyncConfig {
/*
此处成员变量应该使用@Value从配置中读取
*/
private int corePoolSize = 10;
private int maxPoolSize = 200;
private int queueCapacity = 10;
@Bean
public Executor taskExecutor() {
ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
executor.setCorePoolSize(corePoolSize);
executor.setMaxPoolSize(maxPoolSize);
executor.setQueueCapacity(queueCapacity);
executor.initialize();
return executor;
}
}
@Configuration：表明该类是一个配置类
@EnableAsync：开启异步事件的支持
然后在定时任务的类或者方法上添加@Async 。最后重启项目，每一个任务都是在不同的线程中
SpringBoot 整合 Quartz
官网学习地址：https://docs.spring.io/spring-boot/docs/current/reference/htmlsingle/#boot-features-quartz
Quartz是现在比较流行的定时任务了，配置比较复杂上手有一定难度。但是再难也得上是不是，下面就开始在SpringBoot中使用Quartz做定时任务
第一步：引入jar包（简单）
如果SpringBoot版本是2.0.0以后的，则在spring-boot-starter中已经包含了quart的依赖，则可以直接使用spring-boot-starter-quartz依赖
<!--QuartZ-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
第二步：创建定时任务类（简单）
@Slf4j
public class QuartzJob1 implements Job {
@Override
public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
log.info("=====job1===开始执行 {}",System.currentTimeMillis());
//======================业务逻辑==========================
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
//=======================================================
log.info("=====job1===结束执行 {}",System.currentTimeMillis());
}
}
上面两步都比较简单，无法就是引入jar包，创建类实现Quartz中的Job接口，重写execute方法，execute方法里面就是我们的业务逻辑，这里我用一个sleep延时来代替
第三步：创建job和Trigger
@Configuration
public class MyQuartzScheduler {
// 任务调度
@Autowired
private Scheduler scheduler;
/**
* 开始执行所有任务
*
* @throws SchedulerException
*/
public void startJob() throws SchedulerException {
startJob1(scheduler);
startJob2(scheduler);
scheduler.start();
}
/**
* 注入Job1任务
* @param scheduler
* @throws SchedulerException
*/
private void startJob1(Scheduler scheduler) throws SchedulerException {
// 通过JobBuilder构建JobDetail实例，JobDetail规定只能是实现Job接口的实例
// JobDetail 是具体Job实例
JobDetail jobDetail = JobBuilder.newJob(QuartzJob1.class).withIdentity("job1", "group1").build();
// 基于表达式构建触发器
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0/5 * * * * ?");
// CronTrigger表达式触发器 继承于Trigger
// TriggerBuilder 用于构建触发器实例
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job1", "group1")
.withSchedule(cronScheduleBuilder).build();
scheduler.scheduleJob(jobDetail, cronTrigger);
}
/**
* 注入Job2任务
* @param scheduler
* @throws SchedulerException
*/
private void startJob2(Scheduler scheduler) throws SchedulerException {
JobDetail jobDetail = JobBuilder.newJob(QuartzJob2.class).withIdentity("job2", "group2").build();
CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0 0/5 * * * ?");
CronTrigger cronTrigger = TriggerBuilder.newTrigger().withIdentity("job2", "group2")
.withSchedule(cronScheduleBuilder).build();
scheduler.scheduleJob(jobDetail, cronTrigger);
}
}
在Quartz中有两个重要的概念必须掌握：job 和 trigger
job：使用 JobBuilder 创建
trigger：使用 TriggerBuilder创建
第四部：配置监听器
@Configuration
public class ApplicationStartQuartzJobListener implements ApplicationListener<ContextRefreshedEvent> {
@Autowired
private MyQuartzScheduler myQuartzScheduler;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
try {
//启动定时任务
myQuartzScheduler.startJob();
} catch (SchedulerException e) {
e.printStackTrace();
}
}
@Bean
public Scheduler scheduler() throws SchedulerException {
SchedulerFactory schedulerFactory = new StdSchedulerFactory();
return schedulerFactory.getScheduler();
}
}
网友评论