### Spring Boot 动态
Cron 表达式实现定时任务
在 Spring Boot 中，动态更新
Cron 表达式的功能可以通过多种方法实现。以下是基于 Quartz 和 `@Scheduled` 注解两种常见的方式。
#### 方法一：使用 Quartz 实现动态
Cron 定时任务
Quartz 提供了一个强大的任务调度机制，支持运行时修改
Cron 表达式。要实现这一目标，需完成以下操作：
1. **引入 Quartz 依赖**
在项目的 `pom.xml` 文件中添加 Quartz 的 Maven 依赖[^1]。
```xml
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-quartz</artifactId>
</dependency>
```
2. **创建 Job 类**
创建一个继承自 `Job` 接口的类，并重写其 `execute` 方法定义具体逻辑。
```java
import org.quartz.Job;
import org.quartz.JobExecutionContext;
public class MyDynamicJob implements Job {
@Override
public void execute(JobExecutionContext context) {
System.out.println("动态定时任务正在执行...");
}
}
```
3. **配置 Scheduler 工厂并动态设置
Cron 表达式**
使用 `Scheduler` 对象手动触发任务调度，并允许通过 API 修改
Cron 表达式。
```java
import org.quartz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;
@Component
public class Dynamic
CronConfigurer implements ApplicationListener<ContextRefreshedEvent> {
@Autowired
private Scheduler scheduler;
@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
try {
updateJobWithNew
CronExpression("0/5 * * * * ?");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public void updateJobWithNew
CronExpression(String
cronExpression) throws Exception {
TriggerKey triggerKey = TriggerKey.triggerKey("myTrigger", "group1");
// 获取现有的触发器
CronTrigger trigger = (
CronTrigger) scheduler.getTrigger(triggerKey);
if (trigger == null) {
createInitialJob(
cronExpression);
return;
}
String oldTime = trigger.get
CronExpression();
if (!oldTime.equalsIgnoreCase(
cronExpression)) {
TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger()
.withIdentity(triggerKey)
.withSchedule(
CronScheduleBuilder.
cronSchedule(
cronExpression));
scheduler.rescheduleJob(triggerKey, triggerBuilder.build());
System.out.println("已成功更新
Cron 表达式：" +
cronExpression);
}
}
private void createInitialJob(String
cronExpression) throws Exception {
JobDetail jobDetail = JobBuilder.newJob(MyDynamicJob.class).withIdentity("job1", "group1").build();
Trigger trigger = TriggerBuilder.newTrigger().withIdentity("myTrigger", "group1")
.startNow()
.withSchedule(
CronScheduleBuilder.
cronSchedule(
cronExpression))
.build();
scheduler.scheduleJob(jobDetail, trigger);
System.out.println("初始任务已创建，
Cron 表达式：" +
cronExpression);
}
}
```
---
#### 方法二：使用 `@Scheduled` 注解配合动态刷新策略
如果不想引入额外的库，可以利用 Spring 自带的 `@Scheduled` 注解结合动态刷新机制来实现类似的动态
Cron 调度效果[^3]。
1. **启用定时任务**
在主程序入口处添加 `@EnableScheduling` 注解以开启定时任务支持[^2]。
```java
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;
@SpringBootApplication
@EnableScheduling
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
```
2. **编写可动态调整的定时任务**
利用外部化配置文件（如 application.properties 或数据库表），存储当前生效的
Cron 表达式，并周期性读取该值进行校验和更新。
```java
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
@Component
public class Dynamic
CronTask {
private final Logger logger = LoggerFactory.getLogger(Dynamic
CronTask.class);
@Value("${dynamic.
cron.expression}")
private String dynamic
CronExpression;
/**
* 周期性检测
Cron 表达式变化
*/
@Scheduled(fixedRate = 5000L)
public void refresh
Cron() {
logger.info("当前
Cron 表达式为 {}", dynamic
CronExpression);
}
/**
* 执行实际业务逻辑的任务
*/
@Scheduled(
cron = "${dynamic.
cron.expression}") // 绑定到属性中的
Cron 表达式
public void performTask() {
logger.info("动态定时任务被触发！");
}
}
```
3. **动态更改
Cron 表达式**
可以通过 RESTful API 更新应用上下文中对应的属性值，或者重启服务加载最新的配置项。
---
### 总结
上述两种方式分别适用于不同场景需求：
- 如果需要更复杂的功能扩展以及更高的灵活性，则推荐采用 Quartz 方案；
- 若仅满足简单的动态
Cron 更改诉求，内置的 `@Scheduled` 即足以胜任。
问题
扫一扫
3123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
