springboot动态配置定时任务

最新推荐文章于 2023-11-04 10:59:34 发布
最新推荐文章于 2023-11-04 10:59:34 发布
阅读量706 收藏 5
点赞数 1
文章标签： spring boot java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46759297/article/details/129535991
版权

前提条件：建表
建表sql语句

DROP TABLE IF EXISTS `scheduled_job`;

CREATE TABLE `scheduled_job` (
  `job_id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键id',
  `job_key` varchar(128) COLLATE utf8_bin NOT NULL COMMENT '定时任务完整类名',
  `cron_expression` varchar(20) COLLATE utf8_bin NOT NULL COMMENT 'cron表达式',
  `job_name` varchar(20) COLLATE utf8_bin NOT NULL COMMENT '任务名称',
  `task_explain` varchar(50) COLLATE utf8_bin NOT NULL DEFAULT '' COMMENT '执行周期',
  `job_desc` varchar(500) COLLATE utf8_bin DEFAULT NULL COMMENT '任务描述',
  `status` tinyint(4) NOT NULL DEFAULT '1' COMMENT '状态,1:正常;-1:停用',
  PRIMARY KEY (`job_id`),
  UNIQUE KEY `job_key` (`job_key`),
  UNIQUE KEY `cron_key_unique_idx` (`job_key`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8 COLLATE=utf8_bin COMMENT='定时任务表';

创建定时任务调度线程池

/**
 * @author ljm
 */
@Configuration
@Slf4j
public class ScheduledConfig {

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        log.info("创建定时任务调度线程池 start");
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(60);
        threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
        log.info("创建定时任务调度线程池 end");
        return threadPoolTaskScheduler;
    }

}

定时任务业务类

public interface ScheduledTaskService{

    /**
     * @Author ljm
     * @Description 启动任务
     * @Date  2023/1/9
     * @return
     */
    Boolean start(ScheduledJob scheduledJob);

    /**
     * @Author ljm
     * @Description 停止任务
     * @Date  2023/1/9
     * @return
     */
    Boolean stop(String jobKey);

    /**
     * @Author ljm
     * @Description 重新启动任务
     * @Date  2023/1/9
     * @return
     */
    Boolean restart(ScheduledJob scheduledJob);

     /**
      * @Author ljm
      * @Description 初始化任务
      * @Date  2023/1/9
      * @return
      */
    void initTask();
}

定时任务业务实现类

@Slf4j
@Service
public class ScheduledTaskServiceImpl implements ScheduledTaskService {

    /**
     * 可重入锁
     */
    private ReentrantLock lock = new ReentrantLock();

    /**
     * 定时任务线程池
     */
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;

    /**
     * 启动状态的定时任务集合
     */
    public Map<String, ScheduledFuture> scheduledFutureMap = new ConcurrentHashMap<>();

    @Autowired
    private ScheduledJobService scheduledJobService;


    /**
     * @Author ljm
     * @Description 启动任务
     * @Date  2023/1/9
     * @return
     */
    @Override
    public Boolean start(ScheduledJob scheduledJob) {
        String jobKey = scheduledJob.getJobKey();
        log.info("启动定时任务"+jobKey);
        //添加锁放一个线程启动，防止多人启动多次

        log.info("开始加锁");
        lock.lock();
        try {
            if(this.isStart(jobKey)){
                log.info("当前任务在启动状态中");
                return false;
            }
            //任务启动
            this.doStartTask(scheduledJob);
        } finally {
            lock.unlock();
            log.info("解锁完毕");
        }

        return true;
    }

    /**
     * 任务是否已经启动
     */
    private Boolean isStart(String taskKey) {
        //校验是否已经启动
        if (scheduledFutureMap.containsKey(taskKey)) {
            if (!scheduledFutureMap.get(taskKey).isCancelled()) {
                return true;
            }
        }
        return false;
    }


    /**
     * @Author ljm
     * @Description 停止任务
     * @Date  2023/1/9
     * @return
     */
    @Override
    public Boolean stop(String jobKey) {
        log.info("停止任务 "+jobKey);
        boolean flag = scheduledFutureMap.containsKey(jobKey);
        log.info("当前实例是否存在 "+flag);
        if(flag){
            ScheduledFuture scheduledFuture = scheduledFutureMap.get(jobKey);

            scheduledFuture.cancel(true);

            scheduledFutureMap.remove(jobKey);
        }
        return flag;
    }

    /**
     * @Author ljm
     * @Description 重新启动任务
     * @Date  2023/1/9
     * @return
     */
    @Override
    public Boolean restart(ScheduledJob scheduledJob) {
        log.info("重启定时任务"+scheduledJob.getJobKey());
        //停止
        this.stop(scheduledJob.getJobKey());

        return this.start(scheduledJob);
    }

    /**
     * @Author ljm
     * @Description 启动任务
     * @Date  2023/1/9
     * @return
     */
    public void doStartTask(ScheduledJob sj){
        log.info(sj.getJobKey());
        if(sj.getStatus().intValue() != 1) {
            return;
        }
        Class<?> clazz;
        ScheduledOfTask task;
        try {
            clazz = Class.forName(sj.getJobKey());
            task = (ScheduledOfTask) SpringContextUtil.getBean(clazz);
        } catch (ClassNotFoundException e) {
            throw new IllegalArgumentException("spring_scheduled_cron表数据" + sj.getJobKey() + "有误", e);
        }
        Assert.isAssignable(ScheduledOfTask.class, task.getClass(), "定时任务类必须实现ScheduledOfTask接口");
        ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(task,(triggerContext ->
                new CronTrigger(sj.getCronExpression()).nextExecutionTime(triggerContext)));
        scheduledFutureMap.put(sj.getJobKey(),scheduledFuture);
    }

    /**
     * @Author ljm
     * @Description 初始化任务
     * @Date  2023/1/9
     * @return
     */
    @Override
    public void initTask() {
        List<ScheduledJob> list = scheduledJobService.list();
        for (ScheduledJob scheduledJob : list) {
            //未启用
            if(scheduledJob.getStatus().intValue() == -1){
                continue;
            }
            doStartTask(scheduledJob);
        }
    }


}

初始化定时任务

@Slf4j
@Component
public class ScheduledTaskRunner implements ApplicationRunner {

    @Autowired
    private ScheduledTaskService scheduledTaskService;

     /**
      * @Author ljm
      * @Description 启动项目初始化任务
      * @Date  2023/1/9
      * @return
      */
    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("----初始化定时任务开始----");
        scheduledTaskService.initTask();
        log.info("----初始化定时任务完成----");
    }
}

执行调度任务接口

public interface ScheduledOfTask extends Runnable{

    <T> void execute() throws Exception;

    @SneakyThrows
    @Override
    default void run() {
        execute();
    }
}

@Component
 /**
  * @Author ljm
  * @Description 当一个类实现了这个接口之后，这个类就可以方便的获得ApplicationContext对象（spring上下文），
  * Spring发现某个Bean实现了ApplicationContextAware接口，Spring容器会在创建该Bean之后，自动调用该Bean的
  * setApplicationContext（参数）方法，调用该方法时，会将容器本身ApplicationContext对象作为参数传递给该方法。
  * @Date  2023/1/11 9:43
  * @return
  */
public class SpringContextUtil implements ApplicationContextAware {


    private static ApplicationContext applicationContext = null;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        if(SpringContextUtil.applicationContext == null){
            SpringContextUtil.applicationContext  = applicationContext;
        }
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    public static Object getBean(String name){
        return getApplicationContext().getBean(name);
    }

    public static <T> T getBean(Class<T> clazz){
        return getApplicationContext().getBean(clazz);
    }

    public static <T> T getBean(String name,Class<T> clazz){
        return getApplicationContext().getBean(name, clazz);
    }
}

定义类实现任务接口创建调度任务

@Component
@Slf4j
public class TaskJob1 implements ScheduledOfTask {

    @Autowired
    private RedisUtil redisUtil;

    @Autowired
    private MockRules mockRules;

    @Autowired
    private TableNameService tableNameService;


    /**
     * @Author ljm
     * @Description 启动任务
     * @Date  2023/2/13 15:20
     * @return
     */
    @Override
    public <T> void execute() throws Exception {

        log.info("执行任务 1 "+ LocalDateTime.now());

        log.info("执行任务 1 完成 "+ LocalDateTime.now());

    }
}

动态修改任务

@Data
@TableName("scheduled_job")
public class ScheduledJob {

    @TableId(value = "job_id",type = IdType.AUTO)
    private Integer jobId;

    @NotBlank(message = "类名不能为空")
    private String jobKey;

    private String cronExpression;

    private String jobName;

    private String taskExplain;

    private String jobDesc;

    private Integer status;

}

@RestController
@CrossOrigin
@RequestMapping("/job")
public class ScheduledJobController {

    @Autowired
    private ScheduledJobService scheduledJobService;

    @ApiOperation("修改并重启定时任务")
    @PostMapping(value = "/update")
    public Result update(@RequestBody ScheduledJob scheduledJob){
        if(scheduledJobService.updateOne(scheduledJob)){
            return Result.ok();
        }
        return Result.fail();
    }


    @ApiOperation("停止定时任务")
    @PostMapping(value = "/stop")
    public Result stop(@RequestParam Integer jobId){
        boolean stop = scheduledJobService.stop(jobId);
        if(stop){
            return Result.ok();
        }
        return Result.fail();
    }


    public static void main(String[] args) {
        System.out.println("=======================================");
    }

    @ApiOperation("定时任务启用或停用")
    @PostMapping(value = "/jobEnable/{jobId}/{status}")
    public Result stop(@PathVariable Integer jobId,@PathVariable Integer status) throws Exception {
        boolean stop = scheduledJobService.jobEnable(jobId,status);
        if(stop){
            return Result.ok();
        }
        return Result.fail();
    }

    @ApiOperation("修改定时任务")
    @PostMapping(value = "/updateJob")
    public Result updateJob(@RequestBody ScheduledJob scheduledJob) throws Exception {
        Result result = scheduledJobService.updateJob(scheduledJob);
        return result;
    }

    @ApiOperation("定时任务查询")
    @PostMapping("/list/{pageNo}/{pageSize}")
    public Result JobList(@PathVariable("pageNo") Integer pageNo,
                          @PathVariable("pageSize") Integer pageSize,
                          @RequestBody SearchObj searchObj){
        Page<ScheduledJob> page = new Page<>(pageNo,pageSize);
        Page<ScheduledJob> list = null;
        try {
            QueryWrapper<ScheduledJob> wrapper = new QueryWrapper<>();
            wrapper.like(StringUtils.isNotBlank(searchObj.getJobKey()),"job_key",searchObj.getJobKey());
            wrapper.like(StringUtils.isNotBlank(searchObj.getJobName()),"job_name",searchObj.getJobName());
            list = scheduledJobService.page(page,wrapper);
            return Result.ok(list);
        } catch (Exception e) {
            return Result.fail();
        }
    }

    @ApiOperation("创建定时任务")
    @PostMapping("createJob")
    public Result createJob(@Valid @RequestBody ScheduledJob scheduledJob){
        Boolean scheduledJobs = scheduledJobService.createJob(scheduledJob);
        if(scheduledJobs){
            return Result.ok();
        }
        return Result.fail();
    }

}



public interface ScheduledJobService extends IService<ScheduledJob> {

    /**
     * 修改定时任务，并重新启动
     * @param scheduledJob
     * @return
     */
    boolean updateOne(ScheduledJob scheduledJob);

     /**
      * @Author ljm
      * @Description 停止定时任务
      */
    boolean stop(Integer jobId);

     /**
      * @Author ljm
      * @Description 定时任务启用或停用
      * @Date  2023/1/9
      * @return
      */
    boolean jobEnable(Integer jobId, Integer status) throws Exception;

     /**
      * @Author ljm
      * @Description 修改定时任务
      * @Date  2023/1/9
      * @return
      */
     Result updateJob(ScheduledJob scheduledJob) throws Exception;

      /**
       * @Author ljm
       * @Description 创建定时任务
       * @Date  2023/1/11
       * @return
       */
    Boolean createJob(ScheduledJob scheduledJob);

}


@Service
@Slf4j
public class ScheduledJobServiceImpl extends ServiceImpl<ScheduledJobMapper, ScheduledJob> implements ScheduledJobService {

    @Autowired
    private ScheduledTaskService scheduledTaskService;


    /**
     * 修改定时任务，并重新启动
     * @param scheduledJob
     * @return
     */
    @Override
    public boolean updateOne(ScheduledJob scheduledJob) {
        boolean update = updateById(scheduledJob);
        if(update){
            scheduledTaskService.restart(getById(scheduledJob.getJobId()));
        }
        return true;
    }


    /**
     * @Author ljm
     * @Description 停止定时任务
     */
    @Override
    public boolean stop(Integer jobId) {
        ScheduledJob scheduledJob = baseMapper.selectById(jobId);
        Boolean stop = scheduledTaskService.stop(scheduledJob.getJobKey());
        return stop;
    }


    /**
     * @Author ljm
     * @Description 定时任务启用或停用
     * @Date  2023/1/9
     * @return
     */
    @Override
    public boolean jobEnable(Integer jobId, Integer status) throws Exception {
        Boolean start = true;
        Boolean stop = true;
        ScheduledJob scheduledJob = baseMapper.selectById(jobId);
        scheduledJob.setStatus(status);
        baseMapper.updateById(scheduledJob);
        if (status == 1){
            start = scheduledTaskService.start(scheduledJob);
        }
        if (status == 0){
            stop = scheduledTaskService.stop(scheduledJob.getJobKey());
        }
        return start && stop;
    }


    /**
     * @Author ljm
     * @Description 修改定时任务
     * @Date  2023/1/9
     * @return
     */
    @Override
    public Result updateJob(ScheduledJob scheduledJob) throws Exception {
        Integer jobId = scheduledJob.getJobId();
        ScheduledJob selectById = baseMapper.selectById(jobId);
        Integer status = selectById.getStatus();
        if (status == 1){
            return Result.ok("任务启动中,不能修改");
        }
        int update = baseMapper.updateById(scheduledJob);
        return Result.ok(update>0);
    }


    /**
     * @Author ljm
     * @Description 创建定时任务
     * @Date  2023/1/11
     * @return
     */
    @Override
    public Boolean createJob(ScheduledJob scheduledJob) {
        scheduledJob.setStatus(0);
        boolean save = save(scheduledJob);
        return save;
    }
}
weixin_46759297
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Springboot Quartz定时任务的动态调度使用，实战详解
2401_84009549的博客
04-18 930
创建JobFactory.java （job实例工厂）：/**@Description : 创建job实例工厂,使用默认的也许会出现spring的@Autowired 无法注入问题**/@Component@Autowired@Override//Job实例注入到Job工厂创建QuartzConfig.java （一些属性配置项）：/**@Description : 调度工厂,线程池属性等等配置**/
springboot建立动态定时任务
xiegongmiao的博客
08-18 637
建立定时任务 1.创建定时器抽象类 /** * 定时器抽象类 * * @author * */ public abstract class ScheduleTask implements Runnable { private String id; public void setId(String id) { this.id = id; } public Strin...
Spring Boot 设置动态定时任务，千万别再写死了~
芋艿V
11-04 1655
???? 这是一个或许对你有用的社群???? 一对一交流/面试小册/简历优化/求职解惑，欢迎加入「芋道快速开发平台」知识星球。下面是星球提供的部分资料：《项目实战（视频）》：从书中学，往事上“练”《互联网高频面试题》：面朝简历学习，春暖花开《架构 x 系统设计》：摧枯拉朽，掌控面试高频场景题《精进 Java 学习指南》：系统学习，互联网主流技术栈《必读 Java 源码专栏》：知其然，知其所以然????这是一个或许...
springboot定时任务的动态开启关闭
03-07
SpringBoot实现定时任务的动态开启关闭，如有疑问联系wx: hsj179540
SpringBoot2集成Quartz+Vue动态定时任务(前后分离)
03-05
【课程导图】    【教学设计】      课程采用番茄教学法，安装人脑记忆力和思维导图的方式+实战例子=完成课程授课，每一个课时可以独立观看，且可以利用碎片化学习，让你悄悄强大，弯道超车。【内容特色】      课程所采用的的案例，均是企业真实案例的脱敏后的教学案例，符合互联网的生产场景和技术要求【讲解方式】       番茄教学法+实操方式讲解【与其他课程差异化】      企业真是案例脱敏操作 
SpringBoot动态定时任务(完整版)
热门推荐
学习学习学习
10-14 2万+
完整版动态定时任务增删改启动暂停功能样样俱全，话不多说，直接看代码，你们直接CV就可以用！！！
SPRING BOOT 动态定时任务
hudeyong926的专栏
06-14 1万+
动态定时任务
SpringBoot实现动态定时任务
站在墙头上的博客
06-30 3962
springboot实现动态定时任务
springboot实现动态定时任务
SSM1234的博客
02-03 1318
1、maven引入quartz包 <!-- https://mvnrepository.com/artifact/org.quartz-scheduler/quartz --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.3.2</version&g
springboot动态配置定时任务(schedule)
06-13
springboot动态配置定时任务(schedule),可不重启项目实现开关重启任务,改变任务定时规则
Springboot2-Quartz 后台可动态配置的定时任务
02-28
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
[] - 2022-09-25 SpringBoot 设置动态定时任务，千万别再写死了~.pdf
最新发布
12-11
互联网资讯，技术简介，IT、AI技术，人工智能
SpringBoot中并发定时任务的实现、动态定时任务的实现（看这一篇就够了）推荐
08-26
主要介绍了SpringBoot并发定时任务动态定时任务实现，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
Springboot中使用数据库配置定时任务
01-03
Springboot中使用数据库配置定时任务，并在Job中自动装配Spring容器Bean。
Spring Boot动态设置定时任务
cn_220107的博客
04-04 4726
Spring Boot动态设置定时任务
spring boot动态设置定时任务
六六的小帅的博客
04-28 532
spring boot定时任务进阶
SpringBoot 设置动态定时任务，千万别再写死了~
09-27 726
点击关注公众号，实用技术文章及时了解之前写过文章记录怎么在SpringBoot项目中简单使用定时任务，不过由于要借助cron表达式且都提前定义好放在配置文件里，不能在项目运行中动态修改任务执行时间，实在不太灵活。经过网上搜索学习后，特此记录如何在SpringBoot项目中实现动态定时任务。因为只是一个demo，所以只引入了需要的依赖：<dependencies> <dep...
Spring boot 动态创建定时任务
L19910311的博客
08-18 3079
springboot创建动态定时任务，支持添加，修改，删除，立即执行等操作
Spring Boot 实现定时任务动态管理，太爽了！
Java技术栈，分享最主流的Java技术
06-16 1378
SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改。版权声明：本文为CSDN博主「敲代码的旺财」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。增强器实现的整体思路与SpringAop的思路一致，实现没有Aop复杂。(2) 使用后处理器拦截SpringBoot原本的定时任务。(4) cglib动态代理实现。(5) 定时任务执行器实现。(6) 增强器代理逻辑。
springboot 动态配置定时任务
09-23
总结起来，使用Spring Boot实现动态配置定时任务的步骤包括：启用定时任务和异步执行的功能、创建实现`Runnable`接口的定时任务类、注入`TaskScheduler`接口并调用`schedule()`方法、实例化`CronTrigger`并传入时间...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值