@Component
public class ScheduledTasks {
    
    @Scheduled(cron = "0 0/5 * * * ?")  // 每5分鐘執(zhí)行一次
    public void executeTask() {
        System.out.println("定時(shí)任務(wù)執(zhí)行，時(shí)間：" + new Date());
    }
}

package com.example.scheduler;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.EnableScheduling;
import org.springframework.scheduling.annotation.SchedulingConfigurer;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.config.ScheduledTaskRegistrar;
import org.springframework.scheduling.support.CronTrigger;

import java.util.Date;

@Configuration
@EnableScheduling
public class DynamicScheduleConfig implements SchedulingConfigurer {
    
    @Autowired
    private CronRepository cronRepository;  // 用于存儲(chǔ)和獲取Cron表達(dá)式
    
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.setScheduler(taskScheduler());
        
        // 從數(shù)據(jù)庫(kù)或配置中心獲取初始Cron表達(dá)式
        String initialCron = cronRepository.getCronByTaskName("sampleTask");
        
        // 添加可動(dòng)態(tài)修改的定時(shí)任務(wù)
        taskRegistrar.addTriggerTask(
            // 定時(shí)任務(wù)的執(zhí)行邏輯
            () -> {
                System.out.println("動(dòng)態(tài)定時(shí)任務(wù)執(zhí)行，時(shí)間：" + new Date());
            },
            // 定時(shí)任務(wù)觸發(fā)器，可根據(jù)需要返回下次執(zhí)行時(shí)間
            triggerContext -> {
                // 每次任務(wù)觸發(fā)時(shí)，重新獲取Cron表達(dá)式
                String cron = cronRepository.getCronByTaskName("sampleTask");
                CronTrigger trigger = new CronTrigger(cron);
                return trigger.nextExecution(triggerContext);
            }
        );
    }
    
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler scheduler = new ThreadPoolTaskScheduler();
        scheduler.setPoolSize(10);  // 設(shè)置線程池大小
        scheduler.setThreadNamePrefix("task-");
        scheduler.initialize();
        return scheduler;
    }
}

@Repository
public class CronRepository {
    
    // 這里可以連接數(shù)據(jù)庫(kù)或配置中心，本例使用內(nèi)存存儲(chǔ)簡(jiǎn)化演示
    private final Map<String, String> cronMap = new ConcurrentHashMap<>();
    
    public CronRepository() {
        // 設(shè)置初始值
        cronMap.put("sampleTask", "0 0/1 * * * ?");  // 默認(rèn)每分鐘執(zhí)行一次
    }
    
    public String getCronByTaskName(String taskName) {
        return cronMap.getOrDefault(taskName, "0 0/1 * * * ?");
    }
    
    public void updateCron(String taskName, String cron) {
        // 驗(yàn)證cron表達(dá)式的有效性
        try {
            new CronTrigger(cron);
            cronMap.put(taskName, cron);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid cron expression: " + cron, e);
        }
    }
}

@RestController
@RequestMapping("/scheduler")
public class SchedulerController {
    
    @Autowired
    private CronRepository cronRepository;
    
    @GetMapping("/cron/{taskName}")
    public Map<String, String> getCron(@PathVariable String taskName) {
        Map<String, String> result = new HashMap<>();
        result.put("taskName", taskName);
        result.put("cron", cronRepository.getCronByTaskName(taskName));
        return result;
    }
    
    @PutMapping("/cron/{taskName}")
    public Map<String, String> updateCron(
            @PathVariable String taskName, 
            @RequestParam String cron) {
        cronRepository.updateCron(taskName, cron);
        
        Map<String, String> result = new HashMap<>();
        result.put("taskName", taskName);
        result.put("cron", cron);
        result.put("message", "Cron expression updated successfully");
        return result;
    }
}

package com.example.scheduler;

import lombok.AllArgsConstructor;
import lombok.Data;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Service;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.stream.Collectors;

@Service
public class AdvancedTaskScheduler {
    
    @Autowired
    private TaskScheduler taskScheduler;
    
    @Autowired
    private CronRepository cronRepository;
    
    // 維護(hù)所有調(diào)度任務(wù)
    private final Map<String, ScheduledTask> scheduledTasks = new ConcurrentHashMap<>();
    
    @Data
    @AllArgsConstructor
    private static class ScheduledTask {
        private String taskName;
        private String cron;
        private Runnable runnable;
        private ScheduledFuture<?> future;
        private boolean running;
    }
    
    /**
     * 注冊(cè)一個(gè)新的定時(shí)任務(wù)
     */
    public void registerTask(String taskName, Runnable runnable) {
        // 判斷任務(wù)是否已存在
        if (scheduledTasks.containsKey(taskName)) {
            throw new IllegalArgumentException("Task with name " + taskName + " already exists");
        }
        String cron = cronRepository.getCronByTaskName(taskName);
        ScheduledFuture<?> future = taskScheduler.schedule(
            runnable,
            triggerContext -> {
                // 動(dòng)態(tài)獲取最新的cron表達(dá)式
                String currentCron = cronRepository.getCronByTaskName(taskName);
                return new CronTrigger(currentCron).nextExecution(triggerContext);
            }
        );
        
        scheduledTasks.put(taskName, new ScheduledTask(taskName, cron, runnable, future, true));
    }
    
    /**
     * 更新任務(wù)的Cron表達(dá)式
     */
    public void updateTaskCron(String taskName, String cron) {
        // 更新數(shù)據(jù)庫(kù)/配置中心中的cron表達(dá)式
        cronRepository.updateCron(taskName, cron);
        
        // 重新調(diào)度任務(wù)
        ScheduledTask task = scheduledTasks.get(taskName);
        if (task != null) {
            // 取消現(xiàn)有任務(wù)
            task.getFuture().cancel(false);
            
            // 創(chuàng)建新任務(wù)
            ScheduledFuture<?> future = taskScheduler.schedule(
                task.getRunnable(),
                triggerContext -> {
                    return new CronTrigger(cron).nextExecution(triggerContext);
                }
            );
            
            // 更新任務(wù)信息
            task.setCron(cron);
            task.setFuture(future);
        }
    }
    
    /**
     * 暫停任務(wù)
     */
    public void pauseTask(String taskName) {
        ScheduledTask task = scheduledTasks.get(taskName);
        if (task != null && task.isRunning()) {
            task.getFuture().cancel(false);
            task.setRunning(false);
        }
    }
    
    /**
     * 恢復(fù)任務(wù)
     */
    public void resumeTask(String taskName) {
        ScheduledTask task = scheduledTasks.get(taskName);
        if (task != null && !task.isRunning()) {
            ScheduledFuture<?> future = taskScheduler.schedule(
                task.getRunnable(),
                triggerContext -> {
                    String currentCron = cronRepository.getCronByTaskName(taskName);
                    return new CronTrigger(currentCron).nextExecution(triggerContext);
                }
            );
            
            task.setFuture(future);
            task.setRunning(true);
        }
    }
    
    /**
     * 刪除任務(wù)
     */
    public void removeTask(String taskName) {
        ScheduledTask task = scheduledTasks.get(taskName);
        if (task != null) {
            task.getFuture().cancel(false);
            scheduledTasks.remove(taskName);
        }
    }
    
    /**
     * 獲取所有任務(wù)信息
     */
    public List<Map<String, Object>> getAllTasks() {
        return scheduledTasks.values().stream()
            .map(task -> {
                Map<String, Object> map = new HashMap<>();
                map.put("taskName", task.getTaskName());
                map.put("cron", task.getCron());
                map.put("running", task.isRunning());
                return map;
            })
            .collect(Collectors.toList());
    }
}

@Repository
public class DatabaseCronRepository implements CronRepository {
    
    @Autowired
    private JdbcTemplate jdbcTemplate;
    
    @Override
    public String getCronByTaskName(String taskName) {
        try {
            return jdbcTemplate.queryForObject(
                "SELECT cron FROM scheduled_tasks WHERE task_name = ?",
                String.class,
                taskName
            );
        } catch (EmptyResultDataAccessException e) {
            return "0 0/1 * * * ?";  // 默認(rèn)值
        }
    }
    
    @Override
    public void updateCron(String taskName, String cron) {
        // 驗(yàn)證cron表達(dá)式
        try {
            new CronTrigger(cron);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid cron expression: " + cron, e);
        }
        
        // 更新數(shù)據(jù)庫(kù)
        int updated = jdbcTemplate.update(
            "UPDATE scheduled_tasks SET cron = ? WHERE task_name = ?",
            cron, taskName
        );
        
        if (updated == 0) {
            // 如果記錄不存在，則插入
            jdbcTemplate.update(
                "INSERT INTO scheduled_tasks (task_name, cron) VALUES (?, ?)",
                taskName, cron
            );
        }
    }
}

CREATE TABLE scheduled_tasks (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    task_name VARCHAR(100) NOT NULL UNIQUE,
    cron VARCHAR(100) NOT NULL,
    description VARCHAR(255),
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
);