java cron表达式每一分钟执行一次

原创

mob64ca12f09e0c 2024-09-02 04:55:38 ©著作权

文章标签 spring 定时任务 Java 文章分类 Java 后端开发

©著作权归作者所有：来自51CTO博客作者mob64ca12f09e0c的原创作品，请联系作者获取转载授权，否则将追究法律责任

使用 Java 实现每分钟执行一次的 Cron 表达式

在现代的 Java 开发中，定时任务是非常常见的需求，比如定期执行清理工作、定时发送邮件等。Java 提供了多种方式来实现定时任务，而使用 Cron 表达式是其中一种灵活且强大的方式。本篇文章将教会你如何通过 Cron 表达式实现每分钟执行一次的定时任务，并详细解释每一步的实现方法。

整体流程

在实现的过程中，我们需要经历以下几个步骤：

步骤编号	步骤描述	代码示例
1	引入依赖	`pom.xml` 文件配置
2	创建定时任务类	定义包含 Cron 表达式的任务类
3	配置任务调度器及执行逻辑	配置 Scheduler
4	运行程序并测试	启动 Spring 应用程序

详细步骤

步骤 1: 引入依赖

在使用 Spring 框架时，我们需要在 pom.xml 文件中引入 spring-boot-starter 和 spring-boot-starter-quartz 依赖。下面是如何添加依赖的示例代码：

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

这里引入了两个依赖：

spring-boot-starter：基础的 Spring Boot 依赖。
spring-boot-starter-quartz：Quartz 定时调度框架的依赖。

步骤 2: 创建定时任务类

接下来，我们需要创建一个定时任务类，该类用于定义具体的执行逻辑。下面是一个示例：

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

public class MyCronJob implements Job {
    
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // 这里是任务执行的具体逻辑
        System.out.println("任务正在执行: " + System.currentTimeMillis());
    }
}

这段代码中，我们实现了 Job 接口，并重写了 execute 方法，这里可以编写我们需要每分钟执行的任务逻辑。

步骤 3: 配置任务调度器及执行逻辑

在这一步，我们需要配置 Quartz 调度器并指定 Cron 表达式。我们会在一个配置类中完成这一步：

import org.quartz.CronScheduleBuilder;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QuartzConfig {

    @Bean
    public JobDetail myJobDetail() {
        // 创建一个 JobDetail 实例并指定要执行的任务
        return JobBuilder.newJob(MyCronJob.class)
                .withIdentity("myJob")
                .storeDurably()
                .build();
    }

    @Bean
    public Trigger myTrigger() {
        // 每分钟触发一次的 Cron 表达式
        String cronExpression = "0 * * ? * *";
        
        return TriggerBuilder.newTrigger()
                .forJob(myJobDetail())
                .withIdentity("myTrigger")
                .withSchedule(CronScheduleBuilder.cronSchedule(cronExpression))
                .build();
    }
}

在这个配置类中：

使用 JobBuilder 创建一个 JobDetail 实例，指定要执行的任务类。
使用 TriggerBuilder 创建一个触发器，并指定 Cron 表达式。这里的 0 * * ? * * 表示每一分钟执行一次。

步骤 4: 运行程序并测试

最后，我们需要创建一个 Spring Boot 应用程序的主类，以运行整个项目：

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

@SpringBootApplication
public class QuartzSchedulerApplication {

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

当我们运行这个程序时，控制台会每分钟输出一次当前的时间戳，表示我们的任务执行成功。

序列图

为了清晰理解整个过程，下面是一个简单的序列图，描述了任务是如何被调度和执行的：

sequenceDiagram
    participant User
    participant Quartz
    participant MyCronJob

    User->>Quartz: 启动应用程序
    Quartz->>Quartz: 配置任务和触发器
    Quartz->>User: 任务调度启动
    Quartz->>MyCronJob: 每分钟执行一次任务
    MyCronJob-->>Quartz: 任务执行完成