超级简单！Spring中四种霸气定时任务实现方式

        当涉及到定时任务的实现，Spring框架提供了多种强大的选项，以适应各种需求。在这篇文章中，我们将介绍Spring中的几种不同方式来实现定时任务，包括使用@Scheduled注解、SchedulingConfigurer接口、TaskScheduler和集成Quartz框架。

一、使用@Scheduled注解

        1.创建一个Spring Boot应用。

        2.创建一个定时任务类，使用@Scheduled注解定义要执行的任务。在这个示例中，我们将每隔5秒打印一次当前时间。

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

@Component
public class ScheduledTask {

    @Scheduled(fixedRate = 5000) // 每隔5秒执行一次
    public void printCurrentTime() {
        System.out.println("Current time: " + System.currentTimeMillis());
    }
}

        3.在Spring Boot的入口类上添加@EnableScheduling注解以启用定时任务

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

        4.运行应用，你将看到定时任务每隔5秒打印当前时间到控制台。

二、使用SchedulingConfigurer接口

1. 创建一个Spring Boot应用。

2. 创建一个SchedulingConfigurer的实现类，自定义定时任务的配置。在这个示例中，我们配置一个每隔3秒执行一次的任务。

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;

@Configuration
public class CustomSchedulingConfigurer implements SchedulingConfigurer {
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addFixedRateTask(
            () -> System.out.println("Custom Task: " + System.currentTimeMillis()),
            3000
        );
    }
}

        3.在Spring Boot的入口类上添加@EnableScheduling注解以启用定时任务。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@EnableScheduling
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

        4.运行应用，你将看到定时任务每隔3秒执行一次，打印当前时间到控制台。

三、使用TaskScheduler

TaskScheduler是Spring提供的任务调度器接口，允许你以编程方式定义和管理定时任务。
示例代码：

1. 创建一个Spring Boot应用。

2. 配置TaskScheduler并创建定时任务。在这个示例中，我们将使用ThreadPoolTaskScheduler作为任务调度器，定时每隔2秒执行一个任务。

3. import org.springframework.context.annotation.Bean;
   import org.springframework.scheduling.annotation.EnableScheduling;
   import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
   import org.springframework.scheduling.support.CronTrigger;
   import org.springframework.stereotype.Component;
   import org.springframework.scheduling.TaskScheduler;
   
   @Component
   public class ScheduledTasks {
   
       @Bean
       public TaskScheduler taskScheduler() {
           ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
           taskScheduler.setPoolSize(5);
           return taskScheduler;
       }
   
       @Scheduled(fixedRate = 2000) // 每隔2秒执行一次
       public void scheduledTask() {
           System.out.println("Scheduled Task: " + System.currentTimeMillis());
       }
   }

        3.在Spring Boot的入口类上添加@EnableScheduling注解以启用定时任务。

        4.运行应用，你将看到定时任务每隔2秒执行一次，打印当前时间到控制台。

四、使用Quartz

Quartz是一个强大的任务调度框架，Spring支持将Quartz集成到应用中以实现更复杂的定时任务需求。
示例代码：

1. 创建一个Spring Boot应用。

2. 添加Quartz的依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

        3.创建一个Quartz的Job类，实现org.quartz.Job接口，并在execute方法中定义任务逻辑。

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

public class MyQuartzJob implements Job {
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("Quartz Job: " + System.currentTimeMillis());
    }
}

        4.创建一个配置类，配置Quartz的调度器和触发器，以及Job的细节。

import org.quartz.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzConfig {
    @Bean
    public JobDetail quartzJobDetail() {
        return JobBuilder.newJob(MyQuartzJob.class)
                .withIdentity("myQuartzJob")
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger jobTrigger() {
        SimpleScheduleBuilder scheduleBuilder = SimpleScheduleBuilder.simpleSchedule()
                .withIntervalInSeconds(5) // 每隔5秒执行一次
                .repeatForever();

        return TriggerBuilder.newTrigger()
                .forJob(quartzJobDetail())
                .withIdentity("myQuartzJobTrigger")
                .withSchedule(scheduleBuilder)
                .build();
    }
}

        5.运行应用，你将看到Quartz的定时任务每隔5秒执行一次，打印当前时间到控制台。

这些方式提供了多种选择，你可以根据项目的需求和复杂度来选择合适的方式来实现定时任务。使用@Scheduled注解更简单，而实现SchedulingConfigurer接口可以更灵活地自定义任务的配置。TaskScheduler适用于相对简单的任务调度需求，而Quartz适用于更复杂的任务调度需求，如支持Cron表达式、分布式任务等。

END