SpringBoot定时任务详解(3种常见定时任务)

SpringBoot定时任务是Java开发经常使用的功能，下面我就来详解3种常见的SpringBoot定时任务@mikechen

SpringBoot 注解实现定时任务

使用 @Scheduled 注解可以在方法上标注定时任务的执行逻辑，这种方式比较简单，适合执行简单的定时任务。

如下所示：

@Scheduled 注解支持多种定时方式，如 fixedRate、cron、fixedDelay 等方式。

1.fixedRate方式

fixedRate表示：控制方法执行的间隔时间，比如间隔1秒执行一次。

如下所示：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class MyScheduledTask {

    @Scheduled(fixedRate = 1000)
    public void myTask() {
        System.out.println("定时任务执行");
    }
}

上述代码使用 @Scheduled 注解标注了一个名为 myTask 的定时任务，该定时任务每隔 1 秒钟执行一次，打印一条消息。

2.cron表达式方式

Cron表达式是一个字符串，包含六个或七个由空格分隔的时间字段，分别表示：秒、分、小时、日、月、周、年（可选）。

Cron表达式可以用于定制化实现定时任务，比如：

// 每天凌晨1点执行一次
    @Scheduled(cron = "0 0 1 * * ?")
    public void myTask2() {
        System.out.println("定时任务执行");
    }

该cron表达式表示：每天凌晨1点执行一次。

以下是常用的Cron表达式参数：

• 秒（0-59）
• 分钟（0-59）
• 小时（0-23）
• 日（1-31）
• 月（1-12 或 JAN-DEC）
• 周几（1-7 或 SUN-SAT）
• 年（可选，1970-2099）

3.initialDelay方式

initialDelay 表示在容器启动后，延迟再执行一次定时器。

如下所示：

@Component
@EnableScheduling    //开启定时任务
public class ScheduleTask {
    //容器启动后,延迟10秒后再执行一次定时器
    @Scheduled(initialDelay = 10000)
    private void myTasks3() {
        System.out.println("我是一个定时任务3");
    }
}

容器启动后,延迟10秒后再执行一次定时器。

SpringBoot接口实现定时任务

实现 ScheduledConfigurer 接口可以更灵活地配置定时任务，该接口只有一个方法 configureTasks，它可以通过 TaskRegistrar 参数来添加定时任务。

具体用法如下：

@Configuration
@EnableScheduling
public class MyScheduledTasks implements ScheduledConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(
            () -> {
                // 定时任务逻辑
            },
            triggerContext -> {
                CronTrigger cronTrigger = new CronTrigger("0 0 0 * * ?");
                return cronTrigger.nextExecutionTime(triggerContext);
            }
        );
    }
}

SpringBoot Quartz实现定时任务

Quartz 是一个功能强大的调度框架，Spring Boot 集成了 Quartz，可以使用 Quartz 来实现定时任务。

这种方式比较灵活，但需要学习 Quartz 的相关知识，使用稍微复杂一些。

如下所示：

import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;

public class MyScheduledTask {

    public void start() throws SchedulerException {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();

        JobDetail job = JobBuilder.newJob(MyJob.class)
                .withIdentity("myJob", "group1")
                .build();

        Trigger trigger = TriggerBuilder.newTrigger()
                .withIdentity("myTrigger", "group1")
                .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1))
                .startNow()
                .build();

        scheduler.scheduleJob(job, trigger);

        scheduler.start();
    }

    public void stop() throws SchedulerException {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        Scheduler scheduler = schedulerFactory.getScheduler();

        scheduler.shutdown();
    }

    public static class MyJob implements Job {
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            System.out.println("定时任务执行");
        }
    }
}

上述代码定义了一个名为 MyScheduledTask 的类，并使用 Quartz 框架来实现定时任务。

该定时任务每隔 1 秒钟执行一次，打印一条消息。

其中，定时任务的具体逻辑由 MyJob 类中的 execute 方法实现。

以上就是SpringBoot定时任务详解，更多内容请查看：SpringBoot框架(万字图文全面详解)