专栏首页麦洛的历劫之路springboot动态定时任务小案例

springboot动态定时任务小案例

大家好,我是麦洛,大家想了解springboot动态定时任务的实现方法示例的相关内容吗?在本文为您仔细讲解springboot动态定时任务的相关知识和一些Code实例,欢迎阅读和指正,我们先划重点:

  • springboot动态定时任务配置
  • springboot定时任务配置
  • springboot动态任务调度

下面大家一起来学习吧。

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>
</dependency>

2、创建定时任务工厂类

/\*\*
 \* 定时任务工厂类
 \*/
@Component
public class JobFactory extends SpringBeanJobFactory implements ApplicationContextAware {

 private transient AutowireCapableBeanFactory beanFactory;

 @Override
 protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
 final Object jobInstance = super.createJobInstance(bundle);
 beanFactory.autowireBean(jobInstance);
 return jobInstance;
 }

 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 this.beanFactory = applicationContext.getAutowireCapableBeanFactory();
 }

}

3、创建定时任务抽象类

public abstract class AbstractTask implements Job {

 private Logger logger = LoggerFactory.getLogger(AbstractTask.class);

 protected abstract void executeInternal(JobExecutionContext context) throws Exception;

 /\*\*
 \* 定时任务标识
 \*/
 private String key;

 /\*\*
 \* 数据库里配置的主键id
 \*/
 private Long dataBaseId;

 @Override
 public void execute(JobExecutionContext context) {
 try {
  executeInternal(context);
 } catch (Exception e) {
  logger.error(e.getMessage(), e);
  logger.error("job execute failed!");
 }
 }

 public String getKey() {
 return key;
 }

 public void setKey(String key) {
 this.key = key;
 }

 public Long getDataBaseId() {
 return dataBaseId;
 }

 public void setDataBaseId(Long dataBaseId) {
 this.dataBaseId = dataBaseId;
 }
}

4、创建定时任务业务实现类

这里可以写你的业务代码,实现具体的业务逻辑。

@Component("JobTask")
public class JobTask extends AbstractTask {

 @Override
 protected void executeInternal(JobExecutionContext context) {
 System.out.println("key = " + this.getKey());
 System.out.println("dataBaseId = " + this.getDataBaseId());
 }

}

5、创建定时任务管理器

包括项目启动时添加定时任务,手动添加定时任务,更新定时任务,删除定时任务方法。

/\*\*
 \* 定时任务管理容器 component (单例模式)
 \*/
@Component
@Scope("singleton")
public class JobQuartzManager implements ApplicationContextAware {

 /\*\*
 \* 创建新的scheduler
 \*/
 private static SchedulerFactory schedulerFactory = new StdSchedulerFactory();

 private Scheduler scheduler;

 /\*\*
 \* 定义组名称,不同的组用于区分任务
 \*/
 private static final String JOB\_GROUP\_NAME = "JOB\_GROUP\_NAME";

 private static final String TRIGGER\_GROUP\_NAME = "TRIGGER\_GROUP\_NAME";

 /\*\*
 \* 日志
 \*/
 private Logger logger = LoggerFactory.getLogger(JobQuartzManager.class);

 private ApplicationContext applicationContext;

 @Autowired
 private JobFactory jobFactory;

 public void start() {
 //启动定时任务(初始化)
 try {
  this.scheduler = schedulerFactory.getScheduler();
  scheduler.setJobFactory(jobFactory); //设置定时任务工厂模式
  //项目启动时默认给spring容器添加动态的定时任务
  this.addJob("job" + 100L, 100L, JobTask.class, "0/2 \* \* \* \* ?");
 } catch (SchedulerException e) {
  logger.error(e.getMessage(), e);
  throw new RuntimeException("init Scheduler failed");
 }
 }

 public boolean addJob(String jobName, Long dataBaseId, Class jobClass, String cronExp) {
 boolean result = false;
 if (!CronExpression.isValidExpression(cronExp)) {
  logger.error("Illegal cron expression format({})", cronExp);
  return result;
 }
 try {
  JobDetail jobDetail = JobBuilder.newJob().withIdentity(new JobKey(jobName, JOB\_GROUP\_NAME))
   .ofType((Class<AbstractTask>) Class.forName(jobClass.getName()))
   .build();
  //创建完jobDetail之后,使用语句传参数值,方便定时任务内部识别它是什么标识
  JobDataMap jobDataMap = jobDetail.getJobDataMap();
  jobDataMap.put("key", jobName);
  jobDataMap.put("dataBaseId", dataBaseId);
  Trigger trigger = TriggerBuilder.newTrigger()
   .forJob(jobDetail)
   .withSchedule(CronScheduleBuilder.cronSchedule(cronExp))
   .withIdentity(new TriggerKey(jobName, TRIGGER\_GROUP\_NAME))
   .build();
  scheduler.scheduleJob(jobDetail, trigger);
  scheduler.start();
  result = true;
 } catch (Exception e) {
  logger.error(e.getMessage(), e);
  logger.error("QuartzManager add job failed");
 }
 return result;
 }

 public boolean updateJob(String jobName, String cronExp) {
 boolean result = false;
 if (!CronExpression.isValidExpression(cronExp)) {
  logger.error("Illegal cron expression format({})", cronExp);
  return result;
 }
 JobKey jobKey = new JobKey(jobName, JOB\_GROUP\_NAME);
 TriggerKey triggerKey = new TriggerKey(jobName, TRIGGER\_GROUP\_NAME);
 try {
  if (scheduler.checkExists(jobKey) && scheduler.checkExists(triggerKey)) {
  JobDetail jobDetail = scheduler.getJobDetail(jobKey);
  Trigger newTrigger = TriggerBuilder.newTrigger()
   .forJob(jobDetail)
   .withSchedule(CronScheduleBuilder.cronSchedule(cronExp))
   .withIdentity(new TriggerKey(jobName, TRIGGER\_GROUP\_NAME))
   .build();
  scheduler.rescheduleJob(triggerKey, newTrigger);
  result = true;
  } else {
  logger.error("update job name:{},group name:{} or trigger name:{},group name:{} not exists..",
   jobKey.getName(), jobKey.getGroup(), triggerKey.getName(), triggerKey.getGroup());
  }
 } catch (SchedulerException e) {
  logger.error(e.getMessage(), e);
  logger.error("update job name:{},group name:{} failed!", jobKey.getName(), jobKey.getGroup());
 }
 return result;
 }

 public boolean deleteJob(String jobName) {
 boolean result = false;
 JobKey jobKey = new JobKey(jobName, JOB\_GROUP\_NAME);
 try {
  if (scheduler.checkExists(jobKey)) {
  result = scheduler.deleteJob(jobKey);
  } else {
  logger.error("delete job name:{},group name:{} not exists.", jobKey.getName(), jobKey.getGroup());
  }
 } catch (SchedulerException e) {
  logger.error(e.getMessage(), e);
  logger.error("delete job name:{},group name:{} failed!", jobKey.getName(), jobKey.getGroup());
 }
 return result;
 }

 @Override
 public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
 this.applicationContext = applicationContext;
 }

}

6、创建定时任务启动类

项目运行时给spring注入定时任务

/\*\*
 \* 定时任务启动类
 \*/
@Component
public class JobRunner implements ApplicationRunner {

 //注入定时任务管理器
 @Autowired
 private JobQuartzManager quartzManager;

 /\*\*
 \* 项目启动时激活定时任务
 \*/
 @Override
 public void run(ApplicationArguments applicationArguments) {
 System.out.println("--------------------注入定时任务---------------------");
 quartzManager.start();
 System.out.println("--------------------定时任务注入完成---------------------");
 }

}

7、测试案例

@RestController
@RequestMapping("/job")
public class JobController {

 @Autowired
 JobQuartzManager quartzManager;

 @PostMapping("addJob")
 @ResponseBody
 public String addJob(@RequestParam("dataBaseId") Long dataBaseId, @RequestParam("cronExp") String cronExp){
 boolean success = quartzManager.addJob("job" + dataBaseId, dataBaseId, JobTask.class, cronExp);
 if(success){
  return "添加成功";
 }else{
  return "添加失败!";
 }
 }

 @PostMapping("deleteJob")
 @ResponseBody
 public String deleteJob(@RequestParam("jobName") String jobName){
 boolean success = quartzManager.deleteJob(jobName);
 if(success){
  return "删除成功";
 }else{
  return "删除失败!";
 }
 }

 @PostMapping("updateJob")
 @ResponseBody
 public String updateJob(@RequestParam("jobName") String jobName, @RequestParam("cronExp") String cronExp){
 boolean success = quartzManager.updateJob(jobName, cronExp);
 if(success){
  return "更新成功";
 }else{
  return "更新失败!";
 }
 }

}

本文分享自微信公众号 - 今日Java(JavaToday),作者:麦洛

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2021-02-07

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • springboot 动态定时任务

    最近在使用springboot的定时任务,一般都是基于注解的。 但是这种方式不够灵活, 不是动态的。 要是修改定时任务的话还要重启服务。很麻烦, 但是有没有一种...

    分享干货的你
  • SpringBoot动态定时任务

    每次新增编辑删除数据库中的任务时都需刷新下任务 以达到任务的动态变化 启动boot时也需执行refresh方法;

    一觉睡到小时候
  • SpringBoot 动态修改定时任务频率

    调试情况如下: 1.调用start 2.调用change,并传入0/3 * * * * * 3.调用stop

    软件测试君
  • 定时器篇:定时任务入门小案例

  • SpringBoot开发案例之整合定时任务(Scheduled)

    来来来小伙伴们,基于上篇的邮件服务,定时任务就不单独分项目了,天然整合进了邮件服务中。

    小柒2012
  • SpringBoot开发案例之整合定时任务(Scheduled)

    来来来小伙伴们,基于上篇的邮件服务,定时任务就不单独分项目了,天然整合进了邮件服务中。 不知道,大家在工作之中,经常会用到那些定时任务去执行特定的业务,这里列举...

    小柒2012
  • 手写动态定时任务

    在开发中我们一般使用quartz来做动态的定时任务,但是这是别人写好的开发框架,要是我们自己想手动实现一个呢。那应该怎么做呢。

    分享干货的你
  • SpringBoot启动时执行指定任务

    @EventListener({ApplicationReadyEvent.class})

    乐心湖
  • 【springboot】2.3.7集成定时任务SchedulingConfigurer实例

    项目需要启动一个定时执行的任务,该任务的执行可以随时停止执行,要求在数据库配置执行规律。

    用户5640963

扫码关注云+社区

领取腾讯云代金券