SpringBoot2 task scheduler 定时任务调度器四种方式

时间:2022-03-14 17:10:17

使用@enablescheduling方式

?
1
2
3
4
5
6
7
8
9
10
@component
@configurable
@enablescheduling
public class task1 {
  private static log logger = logfactory.getlog(task1.class);
  @scheduled(cron = "0/2 * * * * * ")
  public void execute() {
    logger.info("task1>>" + new date());
  }
}

xml配置方式

application 启动加入读取 xml 文件

?
1
2
3
4
5
6
7
8
@springbootapplication
@importresource(value = { "classpath:applicationcontext*.xml" })
public class springboot2taskapplication {
 
  public static void main(string[] args) {
    springapplication.run(springboot2taskapplication.class, args);
  }
}
?
1
2
3
4
5
6
<context:component-scan base-package="com.chenyingjun.task.schedual"></context:component-scan>
<task:scheduler id="appscheduler" pool-size="2" />
<!-- 调整定时任务 -->
<task:scheduled-tasks> 
  <task:scheduled ref="task2" method="method2" cron="0/10 * * * * ?"/>
</task:scheduled-tasks>
?
1
2
3
4
5
6
7
@service
public class task2 {
  private static log logger = logfactory.getlog(task2.class);
  public void method2() {
    logger.info("task2----method2>>>>" + new date());
  }
}

bean创建工厂方式

使用到的 jar 包

?
1
2
3
4
5
6
7
8
9
10
11
12
13
<dependency>
  <groupid>org.springframework</groupid>
  <artifactid>spring-context-support</artifactid>
</dependency>
<dependency>
  <groupid>org.springframework</groupid>
  <artifactid>spring-tx</artifactid>
</dependency>
<dependency>
  <groupid>org.quartz-scheduler</groupid>
  <artifactid>quartz</artifactid>
  <version>2.3.0</version>
</dependency>

新建 schedledconfiguration.java 文件

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
@configuration
public class schedledconfiguration {
 
  /**
   * attention:
   * details:配置定时任务
   */
  @bean(name = "jobdetail")
  public methodinvokingjobdetailfactorybean detailfactorybean(task3 task) {// testtask为需要执行的任务
    methodinvokingjobdetailfactorybean jobdetail = new methodinvokingjobdetailfactorybean();
    /*
     * 是否并发执行
     * 例如每5s执行一次任务,但是当前任务还没有执行完,就已经过了5s了,
     * 如果此处为true,则下一个任务会执行,如果此处为false,则下一个任务会等待上一个任务执行完后,再开始执行
     */
    jobdetail.setconcurrent(false);
 
    // 设置任务的名字
    jobdetail.setname("jobdetailname");
 
    // 设置任务的分组,这些属性都可以存储在数据库中,在多任务的时候使用
    jobdetail.setgroup("jobdetailgroup");
 
    /*
     * 为需要执行的实体类对应的对象
     */
    jobdetail.settargetobject(task);
 
    /*
     * 通过这几个配置,告诉jobdetailfactorybean我们需要执行定时执行scheduletask类中的task方法
     */
    jobdetail.settargetmethod("task");
    return jobdetail;
  }
 
  /**
   * details:配置定时任务的触发器,也就是什么时候触发执行定时任务
   */
  @bean(name = "jobtrigger")
  public crontriggerfactorybean cronjobtrigger(jobdetail jobdetail) {
    crontriggerfactorybean tigger = new crontriggerfactorybean();
    tigger.setjobdetail(jobdetail);
    // 初始时的cron表达式,可以改成从数据库中获取
    tigger.setcronexpression("0/2 * * * * ?");
    // trigger的name
    tigger.setname("tiggername");
    return tigger;
 
  }
 
  /**
   * details:定义quartz调度工厂
   */
  @bean(name = "scheduler")
  public schedulerfactorybean schedulerfactory(trigger trigger) {
    schedulerfactorybean bean = new schedulerfactorybean();
    // 用于quartz集群,quartzscheduler 启动时更新己存在的job
    bean.setoverwriteexistingjobs(true);
    // 延时启动,应用启动1秒后
    bean.setstartupdelay(1);
    // 注册触发器
    bean.settriggers(trigger);
    return bean;
  }
}

新建task任务

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
@service
public class task3 {
 
  @resource(name = "jobtrigger")
  private crontrigger crontrigger;
 
  @resource(name = "scheduler")
  private scheduler scheduler;
 
  private static log logger = logfactory.getlog(task3.class);
 
  public void task() {
    logger.info("task3---------" + new date());
  }
 
  /**
   * 设置cron并重启定时器
   * @param cron cron值
   */
  public void setcron(string cron) {
    try {
      // 表达式调度构建器
      cronschedulebuilder schedulebuilder = cronschedulebuilder.cronschedule(cron);
      // 按新的cronexpression表达式重新构建trigger
      crontrigger trigger = (crontrigger) scheduler.gettrigger(crontrigger.getkey());
      trigger = trigger.gettriggerbuilder().withidentity(crontrigger.getkey())
          .withschedule(schedulebuilder).build();
      // 按新的trigger重新设置job执行
      scheduler.reschedulejob(crontrigger.getkey(), trigger);
    } catch (schedulerexception e) {
      logger.info("cron表达式错误");
    }
  }
}

其中 setcron 方法可以进行重新设定任务调度时间

threadpooltaskscheduler runnable方式

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public class task4 implements runnable {
 
  private threadpooltaskscheduler threadpooltaskscheduler;
 
  private static log logger = logfactory.getlog(task4.class);
 
  @override
  public void run() {
    logger.info("task4================" + new date());
  }
 
  /**
   * 设置cron并启动
   * @param cronexp cron值
   */
  public void restart(string cronexp) {
    if (null != this.threadpooltaskscheduler) {
      scheduledexecutorservice scheduledexecutorservice = this.threadpooltaskscheduler.getscheduledexecutor();
      if (!scheduledexecutorservice.isshutdown()) {
        scheduledexecutorservice.shutdownnow();
      }
 
      this.threadpooltaskscheduler.destroy();
    }
 
    if (null != cronexp && cronexp.trim().length() > 0) {
      this.threadpooltaskscheduler = new threadpooltaskscheduler();
      this.threadpooltaskscheduler.setthreadnameprefix("task4");
      this.threadpooltaskscheduler.initialize();
      this.threadpooltaskscheduler.schedule(this, new crontrigger(cronexp));
    }
  }
}

其中restart可以进行任务启动和重新设置任务调度时间,调用方式如下所示

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
   * 初始化task4
   * 这里的代码不应该写在rest层上, 应该写在service层上
   */
  @postconstruct
  private void inittask4() {
    //初始化task4任务调度器cron,可以从数据库中查询到cron值
    settask4cron("0/3 * * * * ?");
  }
 
  /**
   * 改变task4的cron
   * @param cron cron值
   * @return 成功标志
   */
  @requestmapping(value = { "/settask4cron" }, method = requestmethod.get)
  @responsebody
  public string settask4cron(string cron) {
    if (null == task4) {
      task4 = new task4();
    }
 
    task4.restart(cron);
    return "success";
  }

inittask4 方法加了 @postconstruct '注解,可以在项目启动时自动根据cron来启动任务, settask4cron 方法可以重新调置任务时间

四个任务的效果如下:

SpringBoot2 task scheduler 定时任务调度器四种方式

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持服务器之家。

原文链接:http://www.cnblogs.com/cnJun/p/10546745.html