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

@Component
public class SimpleTask {

    @Scheduled(fixedRate = 5000)
    public void executeTask() {
        System.out.println("Task executed at: " + System.currentTimeMillis());
    }
}

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

public class DynamicTaskScheduler {

    private ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);

    public void scheduleTask(Runnable task, long initialDelay, long period) {
        scheduler.scheduleAtFixedRate(task, initialDelay, period, TimeUnit.MILLISECONDS);
    }

    public void stopScheduler() {
        scheduler.shutdown();
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.TaskScheduler;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.stereotype.Component;

import java.util.Date;

@Component
public class DynamicTaskScheduler {

    private TaskScheduler taskScheduler;

    @Autowired
    public DynamicTaskScheduler(TaskScheduler taskScheduler) {
        this.taskScheduler = taskScheduler;
    }

    public void scheduleTask(Runnable task, Date startTime) {
        taskScheduler.schedule(task, startTime);
    }

    public void scheduleTaskWithFixedRate(Runnable task, Date startTime, long period) {
        taskScheduler.scheduleAtFixedRate(task, startTime, period);
    }
}

CREATE TABLE scheduled_tasks (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    task_name VARCHAR(100),
    cron_expression VARCHAR(100),
    status VARCHAR(10)
);

@Autowired
private JdbcTemplate jdbcTemplate;

public List<ScheduledTaskConfig> loadTasksFromDB() {
    String sql = "SELECT * FROM scheduled_tasks WHERE status = 'ACTIVE'";
    return jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(ScheduledTaskConfig.class));
}

public void scheduleTasks() {
    List<ScheduledTaskConfig> tasks = loadTasksFromDB();
    for (ScheduledTaskConfig task : tasks) {
        CronTrigger trigger = new CronTrigger(task.getCronExpression());
        taskScheduler.schedule(new RunnableTask(task.getTaskName()), trigger);
    }
}

public class DynamicTaskManager {

    private Map<String, ScheduledFuture<?>> scheduledTasks = new ConcurrentHashMap<>();

    public void startTask(String taskId, Runnable task, String cronExpression) {
        CronTrigger trigger = new CronTrigger(cronExpression);
        ScheduledFuture<?> future = taskScheduler.schedule(task, trigger);
        scheduledTasks.put(taskId, future);
    }

    public void stopTask(String taskId) {
        ScheduledFuture<?> future = scheduledTasks.get(taskId);
        if (future != null) {
            future.cancel(true);
            scheduledTasks.remove(taskId);
        }
    }
}

public void scheduleTaskWithCronExpression(String cronExpression, Runnable task) {
    CronTrigger trigger = new CronTrigger(cronExpression);
    taskScheduler.schedule(task, trigger);
}

public class MultiTaskManager {

    private Map<String, ScheduledFuture<?>> taskMap = new ConcurrentHashMap<>();

    public void addTask(String taskId, Runnable task, String cronExpression) {
        CronTrigger trigger = new CronTrigger(cronExpression);
        ScheduledFuture<?> future = taskScheduler.schedule(task, trigger);
        taskMap.put(taskId, future);
    }

    public void removeTask(String taskId) {
        ScheduledFuture<?> future = taskMap.get(taskId);
        if (future != null) {
            future.cancel(true);
            taskMap.remove(taskId);
        }
    }
}

@RestController
@RequestMapping("/api/tasks")
public class TaskConfigController {

    @Autowired
    private TaskConfigService taskConfigService;

    @PostMapping
    public ResponseEntity<String> createTask(@RequestBody TaskConfig taskConfig) {
        taskConfigService.saveTaskConfig(taskConfig);
        return ResponseEntity.ok("Task created successfully");
    }

    @PutMapping("/{id}")
    public ResponseEntity<String> updateTask(@PathVariable Long id, @RequestBody TaskConfig taskConfig) {
        taskConfigService.updateTaskConfig(id, taskConfig);
        return ResponseEntity.ok("Task updated successfully");
    }

    @DeleteMapping("/{id}")
    public ResponseEntity<String> deleteTask(@PathVariable Long id) {
        taskConfigService.deleteTaskConfig(id);
        return ResponseEntity.ok("Task deleted successfully");
    }
}

@Component
public class DynamicTaskScheduler {

    @Autowired
    private TaskScheduler taskScheduler;

    @Autowired
    private TaskConfigRepository taskConfigRepository;

    @PostConstruct
    public void init() {
        List<TaskConfig> tasks = taskConfigRepository.findAll();
        for (TaskConfig task : tasks) {
            if ("ACTIVE".equals(task.getStatus())) {
                scheduleTask(task);
            }
        }
    }

    public void scheduleTask(TaskConfig taskConfig) {
        CronTrigger trigger = new CronTrigger(taskConfig.getCronExpression());
        taskScheduler.schedule(new RunnableTask(taskConfig.getTaskName()), trigger);
    }
}

@Component
public class RunnableTask implements Runnable {

    private String taskName;

    public RunnableTask(String taskName) {
        this.taskName = taskName;
    }

    @Override
    public void run() {
        System.out.println("Executing task: " + taskName);
        // 執(zhí)行具體的任務(wù)邏輯
    }
}

@Aspect
@Component
public class TaskExecutionLogger {

    @Around("execution(* com.example.tasks.RunnableTask.run(..))")
    public Object logTaskExecution(ProceedingJoinPoint joinPoint) throws Throwable {
        String taskName = (String) joinPoint.getArgs()[0];
        System.out.println("Task " + taskName + " started at " + new Date());
        Object result = joinPoint.proceed();
        System.out.println("Task " + taskName + " completed at " + new Date());
        return result;
    }
}