1. 使用 @Scheduled 注解
这是 Spring 提供的简单方式，基于注解实现定时任务。
步骤：
- 添加依赖
确保项目中引入了 Spring Boot Starter 依赖（如spring-boot-starter）。 - 开启定时任务支持
在主启动类上添加@EnableScheduling：
@SpringBootApplication
@EnableScheduling
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
3. 创建任务类
使用 @Scheduled 注解定义定时任务：
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class TaskScheduler {
@Scheduled(fixedRate = 5000) // 每5秒执行一次
public void fixedRateTask() {
System.out.println("任务按照固定频率执行：" + System.currentTimeMillis());
}
@Scheduled(cron = "0 0 12 * * ?") // 每天中午12点执行
public void cronTask() {
System.out.println("任务按照CRON表达式执行：" + System.currentTimeMillis());
}
}
4. @Scheduled 参数详解
fixedRate: 上次任务开始后间隔多久执行（以毫秒为单位）。fixedDelay: 上次任务结束后间隔多久执行。cron: 使用 CRON 表达式定义复杂的调度规则。
2. 使用 ScheduledExecutorService
如果任务管理需要更灵活，可以使用 Java 自带的线程池。
示例：
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
@Component
public class ExecutorTask implements CommandLineRunner {
@Override
public void run(String... args) throws Exception {
ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(2);
// 固定频率执行
scheduler.scheduleAtFixedRate(() -> {
System.out.println("FixedRate任务：" + System.currentTimeMillis());
}, 0, 5, TimeUnit.SECONDS);
// 延迟执行
scheduler.scheduleWithFixedDelay(() -> {
System.out.println("FixedDelay任务：" + System.currentTimeMillis());
}, 0, 5, TimeUnit.SECONDS);
}
}
3. 使用 Quartz 框架
Quartz 是一个功能更丰富的任务调度框架，适合复杂需求。
步骤：
- 添加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
2. 配置 Quartz 在 application.properties 或 application.yml 中配置 Quartz 属性，例如：
spring.quartz.job-store-type=memory
spring.quartz.thread-pool.thread-count=5
3. 定义 Job 创建一个 Quartz 任务类，继承 Job 接口：
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
public class QuartzJob implements Job {
@Override
public void execute(JobExecutionContext context) throws JobExecutionException {
System.out.println("Quartz任务执行：" + System.currentTimeMillis());
}
}
4. 创建任务调度器 使用 JobDetail 和 Trigger 定义任务和触发条件：
import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class QuartzConfig {
@Bean
public JobDetail jobDetail() {
return JobBuilder.newJob(QuartzJob.class)
.withIdentity("QuartzJob")
.storeDurably()
.build();
}
@Bean
public Trigger trigger() {
return TriggerBuilder.newTrigger()
.forJob(jobDetail())
.withIdentity("QuartzTrigger")
.withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ?")) // 每5秒触发
.build();
}
}
选择适合的方式
- 简单任务： 使用
@Scheduled，易于实现。 - 需要线程池支持： 使用
ScheduledExecutorService。 - 复杂任务调度： 使用 Quartz 框架。
如果您对某种方式需要更详细的解释或具体问题，请随时提出！
发布者：myrgd，转载请注明出处：https://www.object-c.cn/4583
