正文

springboot实现动态增删启停定时任务(代码片段)

xinyuan_java  xinyuan_java  2022-12-08  785

关键词：

在spring boot项目中，可以通过@EnableScheduling注解和@Scheduled注解实现定时任务，也可以通过SchedulingConfigurer接口来实现定时任务。但是这两种方式不能动态添加、删除、启动、停止任务。

要实现动态增删启停定时任务功能，比较广泛的做法是集成Quartz框架。但是本人的开发原则是：在满足项目需求的情况下，尽量少的依赖其它框架，避免项目过于臃肿和复杂。

查看spring-context这个jar包中org.springframework.scheduling.ScheduledTaskRegistrar这个类的源代码，发现可以通过改造这个类就能实现动态增删启停定时任务功能。

定时任务列表页

定时任务执行日志

添加执行定时任务的线程池配置类

@Configuration
public class SchedulingConfig 
    @Bean
    public TaskScheduler taskScheduler() 
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        // 定时任务执行线程池核心线程数
        taskScheduler.setPoolSize(4);
        taskScheduler.setRemoveOnCancelPolicy(true);
        taskScheduler.setThreadNamePrefix("TaskSchedulerThreadPool-");
        return taskScheduler;

添加ScheduledFuture的包装类。ScheduledFuture是ScheduledExecutorService定时任务线程池的执行结果。

public final class ScheduledTask 

    volatile ScheduledFuture<?> future;

    /**
     * 取消定时任务
     */
    public void cancel() 
        ScheduledFuture<?> future = this.future;
        if (future != null) 
            future.cancel(true);

添加Runnable接口实现类，被定时任务线程池调用，用来执行指定bean里面的方法。

public class SchedulingRunnable implements Runnable 

    private static final Logger logger = LoggerFactory.getLogger(SchedulingRunnable.class);

    private String beanName;

    private String methodName;

    private String params;

    public SchedulingRunnable(String beanName, String methodName) 
        this(beanName, methodName, null);
    

    public SchedulingRunnable(String beanName, String methodName, String params) 
        this.beanName = beanName;
        this.methodName = methodName;
        this.params = params;
    

    @Override
    public void run() 
        logger.info("定时任务开始执行 - bean：，方法：，参数：", beanName, methodName, params);
        long startTime = System.currentTimeMillis();

        try 
            Object target = SpringContextUtils.getBean(beanName);

            Method method = null;
            if (StringUtils.isNotEmpty(params)) 
                method = target.getClass().getDeclaredMethod(methodName, String.class);
             else 
                method = target.getClass().getDeclaredMethod(methodName);
            

            ReflectionUtils.makeAccessible(method);
            if (StringUtils.isNotEmpty(params)) 
                method.invoke(target, params);
             else 
                method.invoke(target);
            
         catch (Exception ex) 
            logger.error(String.format("定时任务执行异常 - bean：%s，方法：%s，参数：%s ", beanName, methodName, params), ex);
        

        long times = System.currentTimeMillis() - startTime;
        logger.info("定时任务执行结束 - bean：，方法：，参数：，耗时： 毫秒", beanName, methodName, params, times);
    

    @Override
    public boolean equals(Object o) 
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        SchedulingRunnable that = (SchedulingRunnable) o;
        if (params == null) 
            return beanName.equals(that.beanName) &&
                    methodName.equals(that.methodName) &&
                    that.params == null;
        

        return beanName.equals(that.beanName) &&
                methodName.equals(that.methodName) &&
                params.equals(that.params);
    

    @Override
    public int hashCode() 
        if (params == null) 
            return Objects.hash(beanName, methodName);
        

        return Objects.hash(beanName, methodName, params);

添加定时任务注册类，用来增加、删除定时任务。

@Component
public class CronTaskRegistrar implements DisposableBean 

    private final Map<Runnable, ScheduledTask> scheduledTasks = new ConcurrentHashMap<>(16);

    @Autowired
    private TaskScheduler taskScheduler;

    public TaskScheduler getScheduler() 
        return this.taskScheduler;
    

    public void addCronTask(Runnable task, String cronExpression) 
        addCronTask(new CronTask(task, cronExpression));
    

    public void addCronTask(CronTask cronTask) 
        if (cronTask != null) 
            Runnable task = cronTask.getRunnable();
            if (this.scheduledTasks.containsKey(task)) 
                removeCronTask(task);
            

            this.scheduledTasks.put(task, scheduleCronTask(cronTask));
        
    

    public void removeCronTask(Runnable task) 
        ScheduledTask scheduledTask = this.scheduledTasks.remove(task);
        if (scheduledTask != null)
            scheduledTask.cancel();
    

    public ScheduledTask scheduleCronTask(CronTask cronTask) 
        ScheduledTask scheduledTask = new ScheduledTask();
        scheduledTask.future = this.taskScheduler.schedule(cronTask.getRunnable(), cronTask.getTrigger());

        return scheduledTask;
    


    @Override
    public void destroy() 
        for (ScheduledTask task : this.scheduledTasks.values()) 
            task.cancel();
        

        this.scheduledTasks.clear();

添加定时任务示例类

@Component("demoTask")
public class DemoTask 
    public void taskWithParams(String params) 
        System.out.println("执行有参示例任务：" + params);
    

    public void taskNoParams() 
        System.out.println("执行无参示例任务");

定时任务数据库表设计

添加定时任务实体类

public class SysJobPO 
    /**
     * 任务ID
     */
    private Integer jobId;
    /**
     * bean名称
     */
    private String beanName;
    /**
     * 方法名称
     */
    private String methodName;
    /**
     * 方法参数
     */
    private String methodParams;
    /**
     * cron表达式
     */
    private String cronExpression;
    /**
     * 状态（1正常 0暂停）
     */
    private Integer jobStatus;
    /**
     * 备注
     */
    private String remark;
    /**
     * 创建时间
     */
    private Date createTime;
    /**
     * 更新时间
     */
    private Date updateTime;

    public Integer getJobId() 
        return jobId;
    

    public void setJobId(Integer jobId) 
        this.jobId = jobId;
    

    public String getBeanName() 
        return beanName;
    

    public void setBeanName(String beanName) 
        this.beanName = beanName;
    

    public String getMethodName() 
        return methodName;
    

    public void setMethodName(String methodName) 
        this.methodName = methodName;
    

    public String getMethodParams() 
        return methodParams;
    

    public void setMethodParams(String methodParams) 
        this.methodParams = methodParams;
    

    public String getCronExpression() 
        return cronExpression;
    

    public void setCronExpression(String cronExpression) 
        this.cronExpression = cronExpression;
    

    public Integer getJobStatus() 
        return jobStatus;
    

    public void setJobStatus(Integer jobStatus) 
        this.jobStatus = jobStatus;
    

    public String getRemark() 
        return remark;
    

    public void setRemark(String remark) 
        this.remark = remark;
    

    public Date getCreateTime() 
        return createTime;
    

    public void setCreateTime(Date createTime) 
        this.createTime = createTime;
    

    public Date getUpdateTime() 
        return updateTime;
    

    public void setUpdateTime(Date updateTime) 
        this.updateTime = updateTime;

新增定时任务

boolean success = sysJobRepository.addSysJob(sysJob);
if (!success)
    return OperationResUtils.fail("新增失败");
else 
    if (sysJob.getJobStatus().equals(SysJobStatus.NORMAL.ordinal())) 
        SchedulingRunnable task = new SchedulingRunnable(sysJob.getBeanName(), sysJob.getMethodName(), sysJob.getMethodParams());
        cronTaskRegistrar.addCronTask(task, sysJob.getCronExpression());
    


return OperationResUtils.success();

修改定时任务，先移除原来的任务，再启动新任务

boolean success = sysJobRepository.editSysJob(sysJob);
if (!success)
    return OperationResUtils.fail("编辑失败");
else 
    //先移除再添加
    if (existedSysJob.getJobStatus().equals(SysJobStatus.NORMAL.ordinal())) 
        SchedulingRunnable task = new SchedulingRunnable(existedSysJob.getBeanName(), existedSysJob.getMethodName(), existedSysJob.getMethodParams());
        cronTaskRegistrar.removeCronTask(task);
    

    if (sysJob.getJobStatus().equals(SysJobStatus.NORMAL.ordinal())) 
        SchedulingRunnable task = new SchedulingRunnable(sysJob.getBeanName(), sysJob.getMethodName(), sysJob.getMethodParams());
        cronTaskRegistrar.addCronTask(task, sysJob.getCronExpression());
    


return OperationResUtils.success();

删除定时任务

boolean success = sysJobRepository.deleteSysJobById(req.getJobId());
if (!success)
    return OperationResUtils.fail("删除失败");
else
    if (existedSysJob.getJobStatus().equals(SysJobStatus.NORMAL.ordinal())) 
        SchedulingRunnable task = new SchedulingRunnable(existedSysJob.getBeanName(), existedSysJob.getMethodName(), existedSysJob.getMethodParams());
        cronTaskRegistrar.removeCronTask(task);
    


return OperationResUtils.success();

定时任务启动/停止状态切换

if (existedSysJob.getJobStatus().equals(SysJobStatus.NORMAL.ordinal())) 
    SchedulingRunnable task = new SchedulingRunnable(existedSysJob.getBeanName(), existedSysJob.getMethodName(), existedSysJob.getMethodParams());
    cronTaskRegistrar.addCronTask(task, existedSysJob.getCronExpression());
 else 
    SchedulingRunnable task = new SchedulingRunnable(existedSysJob.getBeanName(), existedSysJob.getMethodName(), existedSysJob.getMethodParams());
    cronTaskRegistrar.removeCronTask(task);

添加实现了CommandLineRunner接口的SysJobRunner类，当spring boot项目启动完成后，加载数据库里状态为正常的定时任务。

@Service
public class SysJobRunner implements CommandLineRunner 

    private static final Logger logger = LoggerFactory.getLogger(SysJobRunner.class);

    @Autowired
    private ISysJobRepository sysJobRepository;

    @Autowired
    private CronTaskRegistrar cronTaskRegistrar;

    @Override
    public void run(String... args) 
        // 初始加载数据库里状态为正常的定时任务
        List<SysJobPO> jobList = sysJobRepository.getSysJobListByStatus(SysJobStatus.NORMAL.ordinal());
        if (CollectionUtils.isNotEmpty(jobList)) 
            for (SysJobPO job : jobList) 
                SchedulingRunnable task = new SchedulingRunnable(job.getBeanName(), job.getMethodName(), job.getMethodParams());
                cronTaskRegistrar.addCronTask(task, job.getCronExpression());
            

            logger.info("定时任务已加载完毕...");

工具类SpringContextUtils，用来从spring容器里获取bean

@Component
public class SpringContextUtils implements ApplicationContextAware 

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext)
            throws BeansException 
        SpringContextUtils.applicationContext = applicationContext;
    

    public static Object getBean(String name) 
        return applicationContext.getBean(name);
    

    public static <T> T getBean(Class<T> requiredType) 
        return applicationContext.getBean(requiredType);
    

    public static <T> T getBean(String name, Class<T> requiredType) 
        return applicationContext.getBean(name, requiredType);
    

    public static boolean containsBean(String name) 
        return applicationContext.containsBean(name);
    

    public static boolean isSingleton(String name) 
        return applicationContext.isSingleton(name);
    

    public static Class<? extends Object> getType(String name) 
        return applicationContext.getType(name);

springboot实现动态增删启停定时任务(代码片段)

在springboot项目中，可以通过@EnableScheduling注解和@Scheduled注解实现定时任务，也可以通过SchedulingConfigurer接口来实现定时任务。但是这两种方式不能动态添加、删除、启动、停止任务。要实现动态增删启停定时任务功... 查看详情

springboot实现动态增删启停定时任务(代码片段)

springboot定时任务，怎么实现任务动态增删启停？(代码片段)

...者：jessehua链接：https://www.jianshu.com/p/0f68936393fd在springboot项目中，可以通过@EnableScheduling注解和@Scheduled注解实现定时任务，也可以通过SchedulingConfigurer接口来实现定时任务。但是这两种方式不能动态添加、删... 查看详情

springboot实现动态增删启停定时任务(代码片段)

告别硬编码，springboot实现动态增删启停定时任务，非常实用，亲测有效！(代码片段)

来源：www.jianshu.com/p/0f68936393fd在springboot项目中，可以通过@EnableScheduling注解和@Scheduled注解实现定时任务，也可以通过SchedulingConfigurer接口来实现定时任务。但是这两种方式不能动态添加、删除、启动、停止任务... 查看详情

springboot定时任务，怎么实现任务动态增删启停？

点击关注公众号，Java干货及时送达作者：jessehua链接：https://www.jianshu.com/p/0f68936393fd在springboot项目中，可以通过@EnableScheduling注解和@Scheduled注解实现定时任务，也可以通过SchedulingConfigurer接口来实查看详情

基于springboot实现定时任务的增删改启停

该功能主要是基于 TaskScheduler 和 CronTask两个类来实现。直接干代码 1.创建一个springboot 工程，依赖如下<?xmlversion="1.0"encoding="UTF-8"?><projectxmlns="http://maven.apache.org/POM/4.0.0"xmlns 查看详情

springboot动态定时任务(代码片段)

SpringBoot动态定时任务前言配置文件定时任务核心类提供修改cron表达式的controller前言之前在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执... 查看详情

springboot整合quartz集群环境实现动态定时任务配置原

最近做了一个springboot 整合quartz 实现动态定时任务配置，在集群环境下运行的任务。能够对定时任务，动态的进行增删改查，界面效果图如下： 1.在项目中引入jar 2.将需要的表导入数据库官网上有不... 查看详情

springboot定时任务动态管理通用解决方案(代码片段)

一、功能说明SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改二、快速使用具体的功能已经封装成SpringBoot-starter即插即用<dependency&g... 查看详情

springboot定时任务动态管理通用解决方案(代码片段)

quartz+springboot实现动态管理定时任务

项目实践过程中碰到一个动态管理定时任务的需求：针对每个人员进行信息的定时更新，具体更新时间可随时调整、启动、暂定等。思路将每个人员信息的定时配置保存到数据库中，这样实现了任务的动态展示和管理。任务的每... 查看详情

springboot集成quartz动态定时任务

SpringBoot集成Quartz动态定时任务项目中需要用到定时任务，考虑了下java方面定时任务无非就三种：用Java自带的timer类。稍微看了一下，可以实现大部分的指定频率的任务的调度（timer.schedule（）），也可以实现关闭和开启（timer.ca... 查看详情

重学springboot系列之异步任务与定时任务(代码片段)

重学SpringBoot系列之异步任务与定时任务实现Async异步任务环境准备同步调用异步调用异步回调为异步任务规划线程池SpringBoot任务线程池自定义线程池优雅地关闭线程池通过@Scheduled实现定时任务开启定时任务方法不同定时方式... 查看详情

springboot中并发定时任务的实现动态定时任务的实现（看这一篇就够了）

#一、在JAVA开发领域，目前可以通过以下几种方式进行定时任务1、单机部署模式Timer：jdk中自带的一个定时调度类，可以简单的实现按某一频度进行任务执行。提供的功能比较单一，无法实现复杂的调度任务。ScheduledExecutorService... 查看详情

springboot自带定时任务实现动态配置cron参数

同学们，我今天分享一下SpringBoot动态配置Cron参数。场景是这样子的：后台管理界面对定时任务进行管理，可动态修改执行时间，然后保存入库，每次任务执行前从库里查询时间，以达到动态修改Cron参数的效果。好，咱们一起来... 查看详情