Spring Boot 定时任务与调度系统

应用启动类：

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

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

测试类：

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest
class ScheduledTaskApplicationTests {
    @Test
    void contextLoads() {
        assertThat(true).isTrue();
    }
}

结论：集成 Spring Task 的步骤包括创建 Spring Boot 项目、添加所需的依赖、配置定时任务、创建定时任务类、测试应用。

集成 Quartz 的步骤

步骤：

1. 创建 Spring Boot 项目。
2. 添加所需的依赖。
3. 配置 Quartz。
4. 创建定时任务类。
5. 测试应用。

示例： pom.xml 文件中的依赖：

<dependencies>
    <!-- Web 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <!-- Quartz 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-quartz</artifactId>
    </dependency>
    <!-- 测试依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
</dependencies>

application.properties 文件中的配置：

# 服务器端口
server.port=8080
# Quartz 配置
spring.quartz.job-store-type=jdbc
spring.quartz.jdbc.initialize-schema=always
spring.quartz.scheduler-name=MyScheduler
spring.quartz.properties.org.quartz.threadPool.threadCount=10

定时任务类：

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.springframework.stereotype.Component;
import java.text.SimpleDateFormat;
import java.util.Date;

@Component
public class ProductQuartzJob implements Job {
    private SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("Quartz 任务执行时间：" + dateFormat.format(new Date()));
        processQuartzTask();
    }

    private void processQuartzTask() {
        try {
            Thread.sleep(2000);
            System.out.println("Quartz 任务处理完成：" + dateFormat.format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Quartz 配置类：

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

@Configuration
public class QuartzConfig {
    @Bean
    public JobDetail productJobDetail() {
        return JobBuilder.newJob(ProductQuartzJob.class).withIdentity("productJob").storeDurably().build();
    }

    @Bean
    public Trigger productTrigger() {
        return TriggerBuilder.newTrigger()
                .forJob(productJobDetail())
                .withIdentity("productTrigger")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0/1 * * * ?"))
                .build();
    }
}

控制器类：

import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/quartz")
public class QuartzController {
    @Autowired
    private Scheduler scheduler;

    @PostMapping("/start")
    public String startJob() {
        try {
            JobDetail jobDetail = productJobDetail();
            Trigger trigger = productTrigger();
            scheduler.scheduleJob(jobDetail, trigger);
            return "任务已启动";
        } catch (SchedulerException e) {
            e.printStackTrace();
            return "任务启动失败";
        }
    }

    @PostMapping("/stop")
    public String stopJob() {
        try {
            TriggerKey triggerKey = new TriggerKey("productTrigger");
            scheduler.pauseTrigger(triggerKey);
            JobKey jobKey = new JobKey("productJob");
            scheduler.deleteJob(jobKey);
            return "任务已停止";
        } catch (SchedulerException e) {
            e.printStackTrace();
            return "任务停止失败";
        }
    }

    private JobDetail productJobDetail() {
        return JobBuilder.newJob(ProductQuartzJob.class).withIdentity("productJob").storeDurably().build();
    }

    private Trigger productTrigger() {
        return TriggerBuilder.newTrigger()
                .forJob(productJobDetail())
                .withIdentity("productTrigger")
                .withSchedule(CronScheduleBuilder.cronSchedule("0 0/1 * * * ?"))
                .build();
    }
}

应用启动类：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

测试类：

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import static org.assertj.core.api.Assertions.assertThat;

@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
class QuartzApplicationTests {
    @LocalServerPort
    private int port;

    @Autowired
    private TestRestTemplate restTemplate;

    @Test
    void contextLoads() {}

    @Test
    void testStartJob() {
        String response = restTemplate.postForObject("http://localhost:" + port + "/api/quartz/start", null, String.class);
        assertThat(response).contains("任务已启动");
    }

    @Test
    void testStopJob() {
        String response = restTemplate.postForObject("http://localhost:" + port + "/api/quartz/stop", null, String.class);
        assertThat(response).contains("任务已停止");
    }
}

结论：集成 Quartz 的步骤包括创建 Spring Boot 项目、添加所需的依赖、配置 Quartz、创建定时任务类、测试应用。

Spring Boot 的实际应用场景

在实际开发中，Spring Boot 定时任务与调度系统的应用场景非常广泛，如：

• 实现数据库备份的定时任务。
• 实现数据清洗的定时任务。
• 实现报表生成的定时任务。
• 实现邮件发送的定时任务。

示例：

import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import java.text.SimpleDateFormat;
import java.util.Date;

@Component
class ProductScheduledTask {
    private SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

    @Scheduled(fixedRate = 5000)
    public void fixedRateTask() {
        System.out.println("固定频率任务执行时间：" + dateFormat.format(new Date()));
        processFixedRateTask();
    }

    @Scheduled(fixedDelay = 5000)
    public void fixedDelayTask() {
        System.out.println("固定延迟任务执行时间：" + dateFormat.format(new Date()));
        processFixedDelayTask();
    }

    @Scheduled(cron = "0 0/1 * * * ?")
    public void cronTask() {
        System.out.println("Cron 任务执行时间：" + dateFormat.format(new Date()));
        processCronTask();
    }

    private void processFixedRateTask() {
        try {
            Thread.sleep(2000);
            System.out.println("固定频率任务处理完成：" + dateFormat.format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void processFixedDelayTask() {
        try {
            Thread.sleep(2000);
            System.out.println("固定延迟任务处理完成：" + dateFormat.format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void processCronTask() {
        try {
            Thread.sleep(2000);
            System.out.println("Cron 任务处理完成：" + dateFormat.format(new Date()));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

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

// 测试类
@SpringBootTest
class ScheduledTaskApplicationTests {
    @Test
    void contextLoads() {
        assertThat(true).isTrue();
    }
}

输出结果：

• 控制台输出：
  • 固定频率任务执行时间：2023-06-01 10:00:00
  • 固定频率任务处理完成：2023-06-01 10:00:02
  • 固定延迟任务执行时间：2023-06-01 10:00:02
  • 固定延迟任务处理完成：2023-06-01 10:00:04
  • Cron 任务执行时间：2023-06-01 10:01:00
  • Cron 任务处理完成：2023-06-01 10:01:02

结论：在实际开发中，Spring Boot 定时任务与调度系统的应用场景非常广泛，需要根据实际问题选择合适的定时任务和调度系统。

总结

本章我们学习了 Spring Boot 定时任务与调度系统，包括定时任务的定义与特点、调度系统的定义与特点、Spring Boot 与定时任务的集成、Spring Boot 的实际应用场景，学会了在实际开发中处理定时任务与调度系统问题。其中，定时任务的定义与特点、调度系统的定义与特点、Spring Boot 与定时任务的集成、Spring Boot 的实际应用场景是本章的重点内容。