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

@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());

   }

}

@springbootapplication

@importresource (value = { "classpath:applicationcontext*.xml" })

public class springboot2taskapplication {

   public static void main(string[] args) {

     springapplication.run(springboot2taskapplication. class , args);

   }

}

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

@service

public class task2 {

   private static log logger = logfactory.getlog(task2. class );

   public void method2() {

     logger.info( "task2----method2>>>>" + new date());

   }

}

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

@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;

   }

}

@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表达式错误" );

     }

   }

}

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));

     }

   }

}

/**

    * 初始化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" ;

   }