浅谈在springboot中使用定时任务的方式

package com.fongtech.cli;

import org.mybatis.spring.annotation.MapperScan;

import org.springframework.boot.SpringApplication;

import org.springframework.boot.autoconfigure.SpringBootApplication;

import org.springframework.scheduling.annotation.EnableAsync;

import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication

@MapperScan ( "com.fongtech.cli.mbg.*.**" )

@EnableAsync

@EnableScheduling

public class SpringbootAdminApplication {

     public static void main(String[] args) {

         SpringApplication.run(SpringbootAdminApplication. class , args);

     }

}

@Slf4j

@Component

public class AsyncTaskConfiguration {

     /**

      * 每分钟检查任务列表，判断任务类型执行相应的任务

      * 根据实际任务执行情况，限定执行任务数量

      */

     @Scheduled (cron = "0 0/1 * * * ? " )

     @Async

     public void startCommonTask() throws Exception {

         log.info( "startCommonTask  start........." + Thread.currentThread().getName());

         commonTaskService.startCommonTask();

         log.info( "startCommonTask  end........." + Thread.currentThread().getName());

     }}

package com.fongtech.cli.admin.tasktime;

import com.fongtech.cli.common.util.BeanUtils;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.SchedulingException;

import org.springframework.scheduling.TaskScheduler;

import org.springframework.scheduling.annotation.EnableScheduling;

import org.springframework.scheduling.annotation.SchedulingConfigurer;

import org.springframework.scheduling.config.ScheduledTaskRegistrar;

import org.springframework.scheduling.config.TriggerTask;

import org.springframework.scheduling.support.CronTrigger;

import javax.annotation.PostConstruct;

import java.util.Map;

import java.util.Set;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ScheduledFuture;

/**

  * @author linb

  * @date 2020/6/15 11:16

  */

@Configuration

//@EnableScheduling

public class DefaultSchedulingConfigurer implements SchedulingConfigurer {

     private ScheduledTaskRegistrar taskRegistrar;

     private Set<ScheduledFuture<?>> scheduledFutures = null ;

     private Map<String, ScheduledFuture<?>> taskFutures = new ConcurrentHashMap<>();

     @Override

     public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

         this .taskRegistrar = taskRegistrar;

     }

     @SuppressWarnings ( "unchecked" )

     private Set<ScheduledFuture<?>> getScheduledFutures() {

         if (scheduledFutures == null ) {

             try {

                 // spring版本不同选用不同字段scheduledFutures

                 scheduledFutures = (Set<ScheduledFuture<?>>) BeanUtils.getProperty(taskRegistrar, "scheduledTasks" );

             } catch (NoSuchFieldException e) {

                 throw new SchedulingException( "not found scheduledFutures field." );

             }

         }

         return scheduledFutures;

     }

     /**

      * 添加任务

      */

     public void addTriggerTask(String taskId, TriggerTask triggerTask) {

         if (taskFutures.containsKey(taskId)) {

             throw new SchedulingException( "the taskId[" + taskId + "] was added." );

         }

         TaskScheduler scheduler = taskRegistrar.getScheduler();

         ScheduledFuture<?> future = scheduler.schedule(triggerTask.getRunnable(), triggerTask.getTrigger());

         getScheduledFutures().add(future);

         taskFutures.put(taskId, future);

     }

     /**

      * 取消任务

      */

     public void cancelTriggerTask(String taskId) {

         ScheduledFuture<?> future = taskFutures.get(taskId);

         if (future != null ) {

             future.cancel( true );

         }

         taskFutures.remove(taskId);

         getScheduledFutures().remove(future);

     }

     /**

      * 重置任务

      */

     public void resetTriggerTask(String taskId, TriggerTask triggerTask) {

         cancelTriggerTask(taskId);

         addTriggerTask(taskId, triggerTask);

     }

     /**

      * 任务编号

      */

     public Set<String> taskIds() {

         return taskFutures.keySet();

     }

     /**

      * 是否存在任务

      */

     public boolean hasTask(String taskId) {

         return this .taskFutures.containsKey(taskId);

     }

     /**

      * 任务调度是否已经初始化完成

      */

     public boolean inited() {

         return this .taskRegistrar != null && this .taskRegistrar.getScheduler() != null ;

     }

}

package com.fongtech.cli.admin.tasktime;

import com.fongtech.cli.admin.service.IAuthLoginService;

import com.fongtech.cli.admin.service.IBackupsService;

import com.fongtech.cli.admin.service.IDictionnaryEntryService;

import com.fongtech.cli.mbg.model.entity.AuthLogin;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.CommandLineRunner;

import org.springframework.core.annotation.Order;

import org.springframework.scheduling.config.TriggerTask;

import org.springframework.scheduling.support.CronTrigger;

import org.springframework.stereotype.Component;

/**

  * 项目启动后执行，

  */

@Slf4j

@Component

@Order (value = 1 )

public class CmdRunner implements CommandLineRunner {

     @Autowired

     private DefaultSchedulingConfigurer defaultSchedulingConfigurer;

     @Autowired

     private IDictionnaryEntryService dictionnaryEntryService;

     @Autowired

     private IBackupsService backupsService;

     @Autowired

     private IAuthLoginService authLoginService;

     @Override

     public void run(String... args) throws Exception {

         log.info( "------按照预设备份周期启动数据库备份定时任务" );

         while (!defaultSchedulingConfigurer.inited())

         {

             try {

                 Thread.sleep( 100 );

             } catch (InterruptedException e) {

                 e.printStackTrace();

             } finally {

             }

         }

         String cron = dictionnaryEntryService.getEntryValueByName( "CRON_VALUE" );

         //默认按照管理员用户权限执行备份任务

         AuthLogin authLogin = authLoginService.query().eq(AuthLogin::getLogin_user, "admin" ).getOne();

         //启动线程，按照原表内的时间执行备份任务

         defaultSchedulingConfigurer.addTriggerTask( "task" ,

                 new TriggerTask(

                         () -> System.out.println( "=====----------启动定时任务=-----------" );,

                         new CronTrigger(cron)));

     }

}

defaultSchedulingConfigurer.cancelTriggerTask( "task" );