索取营销诊断书
021-80394720QQ
您的位置：上海毫米网络优化公司 > 小程序 > 百度小程序 >
相关推荐recommended
Springboot开启定时任务Spring Schedule(含业务场景代码)
作者：mmseoamin日期：2023-12-21

Springboot开启定时任务Spring Schedule(内涵业务场景代码)

一、简介

Spring Schedule是Spring框架提供的一种轻量级的任务调度框架，可以用来执行定时任务和周期性任务。在很多应用场景中，我们需要定时执行某些任务，比如定时备份数据库、定时清理缓存、定时发送邮件等等。Spring Schedule提供了很方便的任务调度解决方案，可以很容易地实现这些定时任务。

Spring Boot是Spring框架的一个子项目，它提供了很多开箱即用的特性，可以帮助我们更快速、更便捷地开发Spring应用。在Spring Boot应用中整合Spring Schedule也非常简单，本文将介绍如何在Spring Boot中整合Spring Schedule。

二、添加依赖

引入springboot依赖

三、配置定时任务

在Spring Boot中配置定时任务有两种方式：基于注解和基于XML配置。我们这里选择基于注解的方式。

首先，在启动类上添加@EnableScheduling注解，启用Spring Schedule：

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

然后，在需要执行定时任务的方法上添加@Scheduled注解，指定定时任务的执行时间：

@Service
public class MyService {
    @Scheduled(cron = "0 0 0 * * ?")
    public void backupDatabase() {
        // 备份数据库的代码
    }
}

这个例子中，我们定义了一个名为backupDatabase的方法，并且使用@Scheduled注解指定了它每天0点执行一次。

其中，cron参数是一个Cron表达式，用来指定任务的执行时间。

四、任务并发执行问题

默认情况下，Spring Schedule是单线程执行任务的，也就是说，如果一个任务还没执行完，下一个任务就必须等待。如果任务的执行时间较长，那么会影响其他任务的执行，甚至会导致任务积压，最终导致整个应用崩溃。

为了避免这种情况的发生，我们需要在配置文件中添加以下配置：

spring.task.scheduling.pool.size=10

一个大小为10的线程池来执行任务，也就是说，最多可以并发执行10个任务。这样就能避免任务积压和应用崩溃的问题了。

五、动态调整定时任务

有时候，我们需要动态调整定时任务的执行时间，比如说，某个任务需要紧急执行，我们就需要把它的执行时间提前。在Spring Boot中，我们可以使用@Scheduled注解的fixedRate和fixedDelay属性来实现动态调整定时任务。

fixedRate属性指定任务执行的频率，单位是毫秒。如果任务的执行时间大于fixedRate，那么任务会在执行完后立即再次执行；如果任务的执行时间小于fixedRate，那么任务会在fixedRate时间间隔后再次执行。

fixedDelay属性指定任务执行的延迟时间，单位也是毫秒。如果任务的执行时间大于fixedDelay，那么任务会在执行完后延迟fixedDelay时间后再次执行；如果任务的执行时间小于fixedDelay，那么任务会在fixedDelay-executionTime时间间隔后再次执行。

下面是一个动态调整定时任务执行时间的例子

@Service
public class MyService {
    private long fixedRate = 60 * 1000; // 默认执行间隔为1分钟
    @Scheduled(fixedRate = "#{myService.fixedRate}")
    public void doTask() {
        // 执行任务的代码
    }
    public void updateFixedRate(long fixedRate) {
        this.fixedRate = fixedRate;
    }
}

这个例子中，我们定义了一个名为doTask的方法，并且使用@Scheduled注解指定了它的执行频率为fixedRate。同时，我们还定义了一个名为updateFixedRate的方法，用来动态调整定时任务的执行频率。

在updateFixedRate方法中，我们可以更新fixedRate属性的值，从而改变定时任务的执行频率。注意，我们在@Scheduled注解的fixedRate属性中使用了SpEL表达式来获取fixedRate属性的值，这样就能实现动态调整定时任务的执行频率了。

六、业务场景

6.1 从数据库中获取cron表达式，启动定时任务

可以通过在Spring Boot项目中定义一个 ScheduledTaskRegistrar bean，并在其中注册一个 Runnable 对象，以实现在项目启动后手动创建 Spring Schedule 定时任务。

同时，使用 JdbcTemplate 从 MySQL 数据库中获取 cron 表达式并将其传递给 CronTrigger 对象以定义定时任务的调度时间。

示例demo

@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addTriggerTask(
                new Runnable() {
                    @Override
                    public void run() {
                        // 这里是您的定时任务执行的逻辑
                    }
                },
                new Trigger() {
                    @Override
                    public Date nextExecutionTime(TriggerContext triggerContext) {
                        String cronExpression = getCronExpressionFromDatabase();
                        if (cronExpression == null || cronExpression.isEmpty()) {
                            return null; // 如果 cron 表达式为空，禁止执行定时任务
                        }
                        CronTrigger cronTrigger = new CronTrigger(cronExpression);
                        return cronTrigger.nextExecutionTime(triggerContext);
                    }
                }
        );
    }
    private String getCronExpressionFromDatabase() {
        // 从 MySQL 数据库中获取 cron 表达式
        // 使用 JdbcTemplate 执行 SQL 查询，返回 cron 表达式字符串
        // 示例代码：
        String sql = "SELECT cron_expression FROM my_table WHERE task_name = 'my_task'";
        String cronExpression = jdbcTemplate.queryForObject(sql, String.class);
        return cronExpression;
    }
}

在上面的代码中，ScheduledTaskRegistrar bean 会自动在项目启动后被创建，并通过 configureTasks 方法注册了一个定时任务。该任务使用 Runnable 对象定义了任务执行的逻辑，使用 Trigger 对象定义了任务的调度时间。

在 Trigger 对象中，我们通过调用 getCronExpressionFromDatabase 方法从 MySQL 数据库中获取 cron 表达式，并使用 CronTrigger 对象来定义该定时任务的调度时间。在 nextExecutionTime 方法中，TriggerContext 参数可以提供有关上一次执行时间和上下文信息的详细信息。

请注意，ScheduledTaskRegistrar bean 的 @EnableScheduling 注解用于启用 Spring Schedule 功能。

6.2 从数据库中获取cron表达式，启动定时任务，任务执行时间超过下次执行时间,继续执行

在6.1的基础上继续修改

@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        taskRegistrar.addFixedDelayTask(
                new Runnable() {
                    @Override
                    public void run() {
                        // 这里是您的定时任务执行的逻辑
                    }
                },
                new Trigger() {
                    @Override
                    public Date nextExecutionTime(TriggerContext triggerContext) {
                        String cronExpression = getCronExpressionFromDatabase();
                        CronTrigger cronTrigger = new CronTrigger(cronExpression);
                        Date nextExecutionTime = cronTrigger.nextExecutionTime(triggerContext);
                        if (nextExecutionTime != null) {
                            // 如果下一次执行时间不为空，计算执行时间与当前时间之间的差值
                            long delay = nextExecutionTime.getTime() - System.currentTimeMillis();
                            if (delay < 0) {
                                // 如果下一次执行时间已经过去，设置延迟时间为 0
                                delay = 0;
                            }
                            return new Date(System.currentTimeMillis() + delay);
                        } else {
                            // 如果下一次执行时间为空，返回 null
                            return null;
                        }
                    }
                }
        );
    }
    private String getCronExpressionFromDatabase() {
        // 从 MySQL 数据库中获取 cron 表达式
        // 使用 JdbcTemplate 执行 SQL 查询，返回 cron 表达式字符串
        // 示例代码：
        String sql = "SELECT cron_expression FROM my_table WHERE task_name = 'my_task'";
        String cronExpression = jdbcTemplate.queryForObject(sql, String.class);
        return cronExpression;
    }
}

6.3 从数据库中获取定时任务,按照任务配置cron表达式启动,并监听数据库是否有新的定时任务生成

在6.2的基础上修改,原有的定时任务肯定还是不能动,那么就增加一个默认的定时任务来帮忙

  • 获取定时任务

  • 增加默认轮训定时任务

    • 去重,追加新的定时任务

    • 增加定时任务

      @Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Autowired
    private JdbcTemplate jdbcTemplate;
	
	/**
     * 当前正在执行的定时任务(数据库可能突然插入)
     */
    private List registerTaskList;
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		// 待执行定时任务
		List tasks = findTasksToExecute();
		if (CollUtil.isEmpty(registerTaskList)) {
            registerTaskList = new ArrayList<>();
        }
        // 追加定时任务列表
        synchronized (registerTaskList) {
            registerTaskList.addAll(tasks);
        }
		// 轮询追加定时任务
		taskRegistrar.addFixedDelayTask(
                new Runnable() {
                    @Override
                    public void run() {
						// 追加新的定时任务(数据库插入新的定时任务,自动追加执行)
						addNewScheduleTask(taskRegistrar);
                    }
                },
                new Trigger() {
                    @Override
                    public Date nextExecutionTime(TriggerContext triggerContext) {
						// 设置当前时间和时区
						Calendar nextExecutionTime = Calendar.getInstance();
						TimeZone timeZone = TimeZone.getTimeZone("Asia/Shanghai"); // 设置为您所在的时区
						nextExecutionTime.setTimeZone(timeZone);
						Date lastCompletionTime = triggerContext.lastCompletionTime();
						if (lastCompletionTime != null) {
							nextExecutionTime.setTime(lastCompletionTime);
						}
						// 延迟1分钟启动
						nextExecutionTime.add(Calendar.MINUTE, 1);
						// 设置定时任务的触发规则(延迟1分钟启动,每5s执行一次)
						CronTrigger cronTrigger = new CronTrigger("5 * * * * ?", timeZone);
						return cronTrigger.nextExecutionTime(triggerContext);
                    }
                }
        );
        if (!CollectionUtil.isEmpty(tasks)) {
			for(Task task : tasks) {
				String cronExpression = task.getCronExpression();
				taskRegistrar.addFixedDelayTask(
						new Runnable() {
							@Override
							public void run() {
								// 业务执行逻辑
								// executeScheduleTask(task);
							}
						},
						new Trigger() {
							@Override
							public Date nextExecutionTime(TriggerContext triggerContext) {
								CronTrigger cronTrigger = new CronTrigger(cronExpression);
								Date nextExecutionTime = cronTrigger.nextExecutionTime(triggerContext);
								if (nextExecutionTime != null) {
									// 如果下一次执行时间不为空，计算执行时间与当前时间之间的差值
									long delay = nextExecutionTime.getTime() - System.currentTimeMillis();
									if (delay < 0) {
										// 如果下一次执行时间已经过去，设置延迟时间为 0
										delay = 0;
									}
									return new Date(System.currentTimeMillis() + delay);
								} else {
									// 如果下一次执行时间为空，返回 null
									return null;
								}
							}
						}
				);
			}
        }
    }
	/**
     * 追加新的定时任务.
     *
     * @param taskRegistrar 定时任务注册器
     */
    private void addNewScheduleTask(ScheduledTaskRegistrar taskRegistrar) {
        // 数据库中新的定时任务
        List newTaskList = findNewTasksToExecute();
        if (CollUtil.isNotEmpty(newTaskList)) {
            // 存在新的定时任务
            synchronized (registerTaskList) {
                registerTaskList.addAll(newTaskList);
            }
            for (Task newTask : newTaskList) {
                String newCronExpression = newTask.getCronExpression();
                taskRegistrar.addTriggerTask(
                        () -> {
                            // 定时任务的逻辑
                            executeScheduleTask(newTask);
                        },
                        triggerContext -> {
                            if (newCronExpression == null || newCronExpression.isEmpty()) {
                                // 如果 cron 表达式为空，禁止执行定时任务
                                return null;
                            }
                            CronTrigger cronTrigger = new CronTrigger(newCronExpression);
                            Date nextExecutionTime = cronTrigger.nextExecutionTime(triggerContext);
                            if (nextExecutionTime != null) {
                                // 如果下一次执行时间不为空，计算执行时间与当前时间之间的差值
                                long delay = nextExecutionTime.getTime() - System.currentTimeMillis();
                                if (delay < 0) {
                                    // 如果下一次执行时间已经过去，设置延迟时间为 0
                                    delay = 0;
                                }
                                return new Date(System.currentTimeMillis() + delay);
                            } else {
                                // 如果下一次执行时间为空，返回 null
                                return null;
                            }
                        });
                // 重新加载任务
                taskRegistrar.afterPropertiesSet();
            }
        }
    }
	
	/**
     * 执行定时任务.
	 *
     * @param task 定时任务
     */
	void executeScheduleTask(Task task) {
		// ....
	}
	
	/**
     * 获取定时任务.
     *
     * @return 定时任务
     */
    private List findTasksToExecute() {
		String sql = "select * from task";
		List queryForList = jdbcTemplate.query(sql, new TaskRowMapper());
		return queryForList;
    }
	
	/**
     * 获取数据库中新的定时任务.
     *
     * @return 定时任务集合
     */
    private List findNewTasksToExecute() {
        List tasks = findTasksToExecute();
        if (CollUtil.isEmpty(tasks)) {
            return new ArrayList<>();
        }
        // 通过主键进行区分
        Map registerTaskMap = registerTaskList.stream().collect(Collectors.toMap(Task::getId, Function.identity()));
        tasks = tasks.stream().filter(e -> !registerTaskMap.containsKey(e.getKeyId())).collect(Collectors.toList());
        return tasks;
    }
}

      6.4 启动定时任务,任务结束时,关闭定时任务

      关闭定时任务

      • 通过ScheduledTaskRegistrar.destroy()方法

        • 关闭ScheduledTaskRegistrar中注册的所有定时任务(一键关闭)

        • 通过ScheduledFuture.cancel(true)方法关闭当前定时任务

          • 关闭ScheduledFuture注册的定时任务(选择关闭)
            基于ScheduledTaskRegistrar.destroy()

            基于代码6.1进行改造

            @@Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		Task task = new Task();
        taskRegistrar.addTriggerTask(
                new Runnable() {
                    @Override
                    public void run() {
                        // 这里是您的定时任务执行的逻辑
						excute(task);
						if (isClose(task)) {
							// 符合关闭条件,关闭定时任务
							taskRegistrar.destroy();
						}
                    }
                },
                new Trigger() {
                    @Override
                    public Date nextExecutionTime(TriggerContext triggerContext) {
                        String cronExpression = getCronExpressionFromDatabase();
                        if (cronExpression == null || cronExpression.isEmpty()) {
                            return null; // 如果 cron 表达式为空，禁止执行定时任务
                        }
                        CronTrigger cronTrigger = new CronTrigger(cronExpression);
                        return cronTrigger.nextExecutionTime(triggerContext);
                    }
                }
        );
    }
    private String getCronExpressionFromDatabase() {
        // 从 MySQL 数据库中获取 cron 表达式
        // 使用 JdbcTemplate 执行 SQL 查询，返回 cron 表达式字符串
        // 示例代码：
        String sql = "SELECT cron_expression FROM my_table WHERE task_name = 'my_task'";
        String cronExpression = jdbcTemplate.queryForObject(sql, String.class);
        return cronExpression;
    }
}
            基于ScheduledFuture.cancel(true)

            基于代码6.1改造

            定义TaskScheduler

            @Configuration
@EnableScheduling
public class TaskSchedulerConfig {
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        // 设置线程池大小
        taskScheduler.setPoolSize(15);
        // 设置线程名前缀
        taskScheduler.setThreadNamePrefix("MyTaskScheduler-");
        // 设置等待线程池关闭的时间
        taskScheduler.setAwaitTerminationSeconds(3600);
        // 在关闭时等待所有任务完成
        taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        // 其他定制配置...
        return taskScheduler;
    }
}

            定义定时任务

            @Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Autowired
    private JdbcTemplate jdbcTemplate;
	
	/**
     * 定时任务(用于关闭某项定时任务)
     */
    @Autowired
    private TaskScheduler taskScheduler;
	/**
     * 定时任务(用于关闭某项定时任务)
     */
	private ScheduledFuture scheduledFuture;
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		taskRegistrar.setTaskScheduler(taskScheduler);
		Task task = new Task();
        scheduledFuture = taskScheduler.schedule(
                new Runnable() {
                    @Override
                    public void run() {
                        // 这里是您的定时任务执行的逻辑
						excute(task);
						if (isClose(task)) {
							// 符合关闭条件,关闭定时任务
							scheduledFuture.close(true);
						}
                    }
                },
                new Trigger() {
                    @Override
                    public Date nextExecutionTime(TriggerContext triggerContext) {
                        String cronExpression = getCronExpressionFromDatabase();
                        if (cronExpression == null || cronExpression.isEmpty()) {
                            return null; // 如果 cron 表达式为空，禁止执行定时任务
                        }
                        CronTrigger cronTrigger = new CronTrigger(cronExpression);
                        return cronTrigger.nextExecutionTime(triggerContext);
                    }
                }
        );
    }
    private String getCronExpressionFromDatabase() {
        // 从 MySQL 数据库中获取 cron 表达式
        // 使用 JdbcTemplate 执行 SQL 查询，返回 cron 表达式字符串
        // 示例代码：
        String sql = "SELECT cron_expression FROM my_table WHERE task_name = 'my_task'";
        String cronExpression = jdbcTemplate.queryForObject(sql, String.class);
        return cronExpression;
    }
}

            通过taskScheduler.schedule创建任务,依据判断条件isClose()关闭定时任务

            6.5 从数据库中获取定时任务,按照任务配置cron表达式启动,并监听数据库是否有新的定时任务生成,任务执行完毕后,关闭当前定时任务.

            基于6.3,6.4代码进行改造!!!

            由于我们采用的是一次定义多任务,但关闭时要求只关闭当前任务,所以不能采用

            ScheduledTaskRegistrar.destroy(),它会将所有任务一起关闭,源码如下:

            	@Override
	public void destroy() {
	    for (ScheduledTask task : this.scheduledTasks) {
			task.cancel();
		}
		if (this.localExecutor != null) {
			this.localExecutor.shutdownNow();
		}
	}

            ScheduledTask.cancel 源码如下:

            	public void cancel() {
		ScheduledFuture future = this.future;
		if (future != null) {
			future.cancel(true);
		}
	}

            与我们的ScheduledFutur.cancel一致,定点删除,因此我们开始正题

            定义TaskScheduler

            @Configuration
@EnableScheduling
public class TaskSchedulerConfig {
    @Bean
    public TaskScheduler taskScheduler() {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        // 设置线程池大小
        taskScheduler.setPoolSize(15);
        // 设置线程名前缀
        taskScheduler.setThreadNamePrefix("MyTaskScheduler-");
        // 设置等待线程池关闭的时间
        taskScheduler.setAwaitTerminationSeconds(3600);
        // 在关闭时等待所有任务完成
        taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        // 其他定制配置...
        return taskScheduler;
    }
}

            定义定时任务

            @Configuration
@EnableScheduling
public class ScheduleConfig implements SchedulingConfigurer {
    @Autowired
    private JdbcTemplate jdbcTemplate;
	
	/**
     * 当前正在执行的定时任务(数据库可能突然插入)
     */
    private List registerTaskList;
	
	/**
     * 定时任务(用于关闭某项定时任务)
     */
    @Autowired
    private TaskScheduler taskScheduler;
    /**
     * 存储所有的定时任务map<唯一标识,定时任务>
     */
    private Map scheduledFutureMap;
    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
		// 待执行定时任务
		List tasks = findTasksToExecute();
		if (CollUtil.isEmpty(registerTaskList)) {
            registerTaskList = new ArrayList<>();
        }
        // 追加定时任务列表
        synchronized (registerTaskList) {
            registerTaskList.addAll(tasks);
        }
		
		taskRegistrar.setTaskScheduler(taskScheduler);
		
		// 轮询追加定时任务
		ScheduledFuture defaultScheduledFuture = taskScheduler.schedule(
                new Runnable() {
                    @Override
                    public void run() {
						// 追加新的定时任务(数据库插入新的定时任务,自动追加执行)
						addNewScheduleTask(taskRegistrar);
                    }
                },
                new Trigger() {
                    @Override
                    public Date nextExecutionTime(TriggerContext triggerContext) {
						// 设置当前时间和时区
						Calendar nextExecutionTime = Calendar.getInstance();
						TimeZone timeZone = TimeZone.getTimeZone("Asia/Shanghai"); // 设置为您所在的时区
						nextExecutionTime.setTimeZone(timeZone);
						Date lastCompletionTime = triggerContext.lastCompletionTime();
						if (lastCompletionTime != null) {
							nextExecutionTime.setTime(lastCompletionTime);
						}
						// 延迟1分钟启动
						nextExecutionTime.add(Calendar.MINUTE, 1);
						// 设置定时任务的触发规则(延迟1分钟启动,每5s执行一次)
						CronTrigger cronTrigger = new CronTrigger("5 * * * * ?", timeZone);
						return cronTrigger.nextExecutionTime(triggerContext);
                    }
                }
        );
		// 管理默认任务
		scheduledFutureMap.put("default", defaultScheduledFuture);
        if (!CollectionUtil.isEmpty(tasks)) {
			for(Task task : tasks) {
				String cronExpression = task.getCronExpression();
				ScheduledFuture schedule = taskScheduler.schedule(
						new Runnable() {
							@Override
							public void run() {
								// 业务执行逻辑
								// executeScheduleTask(task);
							}
						},
						new Trigger() {
							@Override
							public Date nextExecutionTime(TriggerContext triggerContext) {
								CronTrigger cronTrigger = new CronTrigger(cronExpression);
								Date nextExecutionTime = cronTrigger.nextExecutionTime(triggerContext);
								if (nextExecutionTime != null) {
									// 如果下一次执行时间不为空，计算执行时间与当前时间之间的差值
									long delay = nextExecutionTime.getTime() - System.currentTimeMillis();
									if (delay < 0) {
										// 如果下一次执行时间已经过去，设置延迟时间为 0
										delay = 0;
									}
									return new Date(System.currentTimeMillis() + delay);
								} else {
									// 如果下一次执行时间为空，返回 null
									return null;
								}
							}
						}
				);
				// 通过主键作为唯一标识,退出时获取scheduledFuture退出
				String identity = String.valueOf(task.getId());
				scheduledFutureMap.put(identity, schedule);
			}
        }
    }
	/**
     * 追加新的定时任务.
     *
     * @param taskRegistrar 定时任务注册器
     */
    private void addNewScheduleTask(ScheduledTaskRegistrar taskRegistrar) {
        // 数据库中新的定时任务
        List newTaskList = findNewTasksToExecute();
        if (CollUtil.isNotEmpty(newTaskList)) {
            // 存在新的定时任务
            synchronized (registerTaskList) {
                registerTaskList.addAll(newTaskList);
            }
            for (Task newTask : newTaskList) {
                String newCronExpression = newTask.getCronExpression();
                ScheduledFuture schedule = taskScheduler.schedule(
                        () -> {
                            // 定时任务的逻辑
                            executeScheduleTask(newTask);
                        },
                        triggerContext -> {
                            if (newCronExpression == null || newCronExpression.isEmpty()) {
                                // 如果 cron 表达式为空，禁止执行定时任务
                                return null;
                            }
                            CronTrigger cronTrigger = new CronTrigger(newCronExpression);
                            Date nextExecutionTime = cronTrigger.nextExecutionTime(triggerContext);
                            if (nextExecutionTime != null) {
                                // 如果下一次执行时间不为空，计算执行时间与当前时间之间的差值
                                long delay = nextExecutionTime.getTime() - System.currentTimeMillis();
                                if (delay < 0) {
                                    // 如果下一次执行时间已经过去，设置延迟时间为 0
                                    delay = 0;
                                }
                                return new Date(System.currentTimeMillis() + delay);
                            } else {
                                // 如果下一次执行时间为空，返回 null
                                return null;
                            }
                        });
				// 通过主键作为唯一标识,退出时获取scheduledFuture退出
				String identity = String.valueOf(task.getId());
				scheduledFutureMap.put(identity, schedule);
                // 重新加载任务
                taskRegistrar.afterPropertiesSet();
            }
        }
    }
	
	/**
     * 执行定时任务.
	 *
     * @param task 定时任务
     */
	void executeScheduleTask(Task task) {
		// 定时任务
		
		// 判断是否关闭当前定时任务
		if (isClose(task)) {
			String identity = String.valueOf(task.getId());
			if (scheduledFutureMap.containsKey(identity)) {
				ScheduledFuture scheduledFuture = scheduledFutureMap.get(identity);
				// 取消当前任务
				scheduledFuture.cancel(true);
				scheduledFutureMap.remove(identity);
				return;
			}
		}
	}
	
	/**
     * 获取定时任务.
     *
     * @return 定时任务
     */
    private List findTasksToExecute() {
		String sql = "select * from task";
		List queryForList = jdbcTemplate.query(sql, new TaskRowMapper());
		return queryForList;
    }
	
	/**
     * 获取数据库中新的定时任务.
     *
     * @return 定时任务集合
     */
    private List findNewTasksToExecute() {
        List tasks = findTasksToExecute();
        if (CollUtil.isEmpty(tasks)) {
            return new ArrayList<>();
        }
        // 通过主键进行区分
        Map registerTaskMap = registerTaskList.stream().collect(Collectors.toMap(Task::getId, Function.identity()));
        tasks = tasks.stream().filter(e -> !registerTaskMap.containsKey(e.getKeyId())).collect(Collectors.toList());
        return tasks;
    }
}

            七、总结

            通过本文的介绍，我们可以看到，在Spring Boot应用中整合Spring Schedule非常简单，只

            需要添加依赖、配置定时任务，就能实现定时任务的执行。同时，我们还介绍了如何解决任

            务并发执行的问题，以及如何动态调整定时任务的执行时间,动态关闭定时任务。

            希望这篇文章对您有所帮助。

             

上一篇：云计算与海量数据管理实验

下一篇：ElasticSearch基础学习（SpringBoot集成ES）

网站优化运营
整站seo优化
网络营销运营
成功案例
品牌创意网站
营销型网站
小程序
微信小程序
微信公众号
百度熊掌号
网站优化分享
关于我们
公司概况
公司新闻
公司文化
结构体系
企业资质
加入我们
关注我们
扫描二维码
获取更多信息
精彩一手掌握
Copyright © 2014-2019 seo,上海网站优化_网络制作_网站seo排名_网站建设推广_上海网络公司 版权所有 沪ICP备19022315号