1. scheduled 方案

  1. 创建 spring boot 工程
  2. 在需要定时执行的类上添加注解 @Component
  3. 在类中定义方法, 编写定时业务逻辑, 并在方法上定义注解 @Scheduled , 并配置定时执行的周期

  4. 在 spring boot 引导类添加注解 @EnableScheduling

    1. @Component
    2. public class SchedulerTest{
    4.  @Scheduled(fixedRate=1000)
    5.  public void showTime(){
    6.      System.out.println(new Date().toLocaleString());   
    7.  }    
    8. }

    @Scheduled 介绍

  5. fixedRate 按照指定周期执行, 单位毫秒

    1. @Scheduled(fixedRate=1000)
  6. fixedRateString 和 fixedRate 类似, 只是是一个字符串, 时间也是毫秒值
  7. fixedDelay 固定延迟执行. 方法执行结束之后, 在固定延迟执行.
  8. fiexdDelayString 和 fixedDelay 类似
  9. Cron 表达式

    Cron 表达式是字符串, 实际是有七段值分别去描述时间,这些值是通过空白 区分

    1. Seconds 秒
    2. Minutes 分
    3. Hours 小时
    4. Day-of-Month 每月的第几天
    5. Month 第几月
    6. Day-of-Week 一周第几天
    7. Year (可选字段) 年

2. SchedulingConfigurer

业务场景描述：定时任务的任务名称，cron（定时任务表达式），定时任务开关，存储在数据库表中。在不重启项目的情况下，修改定时任务表达式，可以实时获取新的定时任务执行时间规则；修改定时任务执行状态，可以随时开关定时任务。
使用技术：基于接口 SchedulingConfigurer

  1. DROP TABLE IF EXISTS `scheduled`;
  2. CREATE TABLE `scheduled` (
  3.   `name` varchar(20) DEFAULT NULL,
  4.   `cron` varchar(30) DEFAULT NULL,
  5.   `open` tinyint(1) DEFAULT NULL COMMENT '1开启， 其他为关闭'
  6. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
  8. -- ----------------------------
  9. -- Records of scheduled
  10. -- ----------------------------
  11. INSERT INTO `scheduled` VALUES ('demo1', '0/5 * * * * ?', '1');
  12. INSERT INTO `scheduled` VALUES ('demo2', '0/6 * * * * ?', '1');

代码实现

定时任务配置类

  1. package com.example.demo.scheduled;
  3. import com.google.common.util.concurrent.ThreadFactoryBuilder;
  4. import org.springframework.context.annotation.Bean;
  5. import org.springframework.context.annotation.Configuration;
  6. import org.springframework.scheduling.annotation.EnableScheduling;
  7. import org.springframework.scheduling.annotation.SchedulingConfigurer;
  8. import org.springframework.scheduling.config.ScheduledTaskRegistrar;
  9. import org.springframework.scheduling.support.CronTrigger;
  10. import java.util.concurrent.Executor;
  11. import java.util.concurrent.Executors;
  12. import java.util.concurrent.ThreadFactory;
  14. /**
  15.  * @Description: 基于接口SchedulingConfigurer的动态定时任务
  16.  * @Author: 
  17.  */
  18. @Configuration
  19. @EnableScheduling
  20. public abstract class ConfigurerSchedulingDemo implements SchedulingConfigurer {
  22.     //定时任务周期表达式
  23.     private String cron;
  24.     /** 
  25.      * @Description:  重写配置定时任务的方法
  26.      * @param: scheduledTaskRegistrar 
  27.      * @return: void 
  28.      * @Author: 
  29.      */
  30.     @Override
  31.     public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {
  32.         scheduledTaskRegistrar.setScheduler(taskScheduler());
  33.         scheduledTaskRegistrar.addTriggerTask(
  34.                 //执行定时任务
  35.                 () ->
  36.                 {
  37.                     taskService();
  38.                 },
  39.                 //设置触发器
  40.                 triggerContext -> {
  42.                    cron = getCron();//获取定时任务周期表达式
  44.                     CronTrigger trigger = new CronTrigger(cron);
  46.                     return trigger.nextExecutionTime(triggerContext);
  47.                 }
  48.         );
  50.     }
  52.     @Bean
  53.     public Executor taskScheduler() {
  54.         //设置线程名称
  55.         ThreadFactory namedThreadFactory = new ThreadFactoryBuilder().setNameFormat("demo-pool-%d").build();
  56.         //创建线程池
  57.         return Executors.newScheduledThreadPool(5, namedThreadFactory);
  58.     }
  60.     /**
  61.      * @Description: 执行定时任务
  62.      * @param:
  63.      * @return: void
  64.      * @Author: 
  65.      */
  66.     public abstract void taskService();
  68.     /**
  69.      * @Description: 获取定时任务周期表达式
  70.      * @param:
  71.      * @return: java.lang.String
  72.      * @Author: 
  73.      * @Date: 2020/8/28
  74.      */
  75.     public abstract String getCron();
  77. }

定时任务1

  1. package com.example.demo.scheduled;
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.example.demo.dao.CronMapper;
  5. import com.example.demo.entity.Scheduled;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.context.annotation.Configuration;
  9. import java.time.LocalDateTime;
  11. /**
  12.  * @Description:
  13.  * @Author: 
  14.  */
  15. @Configuration
  16. public class TaskDemo extends ConfigurerSchedulingDemo {
  18.     @Autowired      //注入mapper
  19.     @SuppressWarnings("all")
  20.     CronMapper cronMapper;
  22.     @Override
  23.     public void taskService() {
  24.         Integer open = getOpen();
  25.         if (1== open){
  26.             System.out.println("定时任务demo1:"
  27.                     + LocalDateTime.now()+"，线程名称："+Thread.currentThread().getName()
  28.                     + " 线程id："+Thread.currentThread().getId());
  29.         }
  30.     }
  32.     @Override
  33.     public String getCron() {
  34.         QueryWrapper<Scheduled> queryWrapper = new QueryWrapper<>();
  35.         queryWrapper.eq("name","demo1");
  36.         String cron = cronMapper.selectOne(queryWrapper).getCron();
  37.         return cron;
  38.     }
  40.     public Integer getOpen() {
  41.         QueryWrapper<Scheduled> queryWrapper = new QueryWrapper<>();
  42.         queryWrapper.eq("name", "demo1");
  43.         Integer open = cronMapper.selectOne(queryWrapper).getOpen();
  44.         return open;
  45.     }
  47. }

定时任务2

  1. package com.example.demo.scheduled;
  3. import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
  4. import com.example.demo.dao.CronMapper;
  5. import com.example.demo.entity.Scheduled;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.context.annotation.Configuration;
  9. import java.time.LocalDateTime;
  11. /**
  12.  * @Description:
  13.  * @Author: 
  14.  */
  15. @Configuration
  16. public class TaskDemo1 extends ConfigurerSchedulingDemo {
  18.     @Autowired      //注入mapper
  19.     @SuppressWarnings("all")
  20.     CronMapper cronMapper;
  22.     @Override
  23.     public void taskService() {
  24.         Integer open = getOpen();
  25.         if (1== open){
  26.             System.out.println("定时任务demo2:"
  27.                     + LocalDateTime.now()+"，线程名称："+Thread.currentThread().getName()
  28.                     + " 线程id："+Thread.currentThread().getId());
  29.         }
  30.     }
  32.     @Override
  33.     public String getCron() {
  34.         QueryWrapper<Scheduled> queryWrapper = new QueryWrapper<>();
  35.         queryWrapper.eq("name","demo2");
  36.         String cron = cronMapper.selectOne(queryWrapper).getCron();
  37.         return cron;
  38.     }
  40.     public Integer getOpen() {
  41.         QueryWrapper<Scheduled> queryWrapper = new QueryWrapper<>();
  42.         queryWrapper.eq("name", "demo2");
  43.         Integer open = cronMapper.selectOne(queryWrapper).getOpen();
  44.         return open;
  45.     }
  46. }

2. Hutool 定时器实现

1. 定义接口

  1. public interface TimerTaskRunner {
  2.     /**
  3.     * 所有定时器业务类必须实现此接口
  4.     */
  5.     public void action();
  6. }

所有定时器类必须实现此接口

2. 定义定时器实现类

  2. /**
  3.  * 本接口用来，屏蔽定时任务的多样性
  4.  * <p>
  5.  * 目前用hutool，不排除以后用别的
  6.  */
  7. public interface TimerExeService {
  9.     /**
  10.      * 启动一个定时器
  11.      * <p>
  12.      * 定时任务表达式书写规范：0/2 * * * * *
  13.      * <p>
  14.      * 六位数，分别是：秒 分 小时 日 月 年
  15.      *
  16.      * @param taskId    任务id
  17.      * @param cron      cron表达式
  18.      * @param className 类的全名，必须是TimerTaskRunner的子类
  19.      */
  20.     void startTimer(String taskId, String cron, String className);
  22.     /**
  23.      * 停止一个定时器
  24.      *
  25.      * @param taskId 定时任务Id
  26.      */
  27.     void stopTimer(String taskId);
  29. }

3. 定义监听器

  1. /**
  2.  * 定时任务启动的 listener
  3.  */
  4. @Component
  5. public class TimerTaskRunListener implements ApplicationListener<ApplicationStartedEvent>, Ordered {
  7.     @Override
  8.     public void onApplicationEvent(ApplicationStartedEvent event) {
  10.         TimersService timersService = SpringUtil.getBean(TimersService.class);
  11.         TimerExeService timerExeService = SpringUtil.getBean(TimerExeService.class);
  13.         // 获取所有开启状态的任务
  14.         List<Timers> list = timersService.list(new LambdaQueryWrapper<Timers>().eq(Timers::getStatus, 1));
  16.         // 添加定时任务到调度器
  17.         for (Timers timer : list) {
  18.             timerExeService.startTimer(String.valueOf(timer.getId()), timer.getCron(), timer.getActionClass());
  19.         }
  21.         // 设置秒级别的启用
  22.         CronUtil.setMatchSecond(true);
  24.         try {
  25.             // TODO: 热启动的时候定时器不会重新启动,需要手动关闭,在启动一次, 生成环境可以将 try cathc 去掉就不会有此bug
  26.             // 启动定时器执行器
  27.             CronUtil.start();
  28.         } catch (UtilException e) {
  29.             CronUtil.restart();
  30.         }
  32.     }
  34.     @Override
  35.     public int getOrder() {
  36.         return LOWEST_PRECEDENCE;
  37.     }
  38. }

4. Hutool 定时器实现类

  1. @Slf4j
  2. @Service
  3. public class HutoolTimerExeServiceImpl implements TimerExeService {
  5.     @Override
  6.     public void startTimer(String taskId, String cron, String className) {
  8.         log.error("定时任务开始执行...{}", className);
  10.         if (ObjectUtil.hasEmpty(taskId, cron, className)) {
  11.             log.error("定时任务ID，cron，className为空 ");
  12.             throw new BusinessException(3, "请检查定时器的id，定时器cron表达式，定时任务是否为空！");
  13.         }
  15.         // 预加载类看是否存在此定时任务类
  16.         try {
  18.             Class.forName(className);
  19.         } catch (ClassNotFoundException e) {
  20.             log.error("定时任务指定类不存在。");
  21.             throw new BusinessException(2, "定时任务执行类不存在");
  22.         }
  24.         // 定义hutool的任务
  25.         Task task = () -> {
  26.             try {
  27.                 TimerTaskRunner timerTaskRunner = (TimerTaskRunner) SpringUtil.getBean(Class.forName(className));
  28.                 timerTaskRunner.action();
  29.             } catch (ClassNotFoundException e) {
  30.                 log.error(">>> 任务执行异常：{}", e.getMessage());
  31.             }
  32.         };
  34.         // 移除定时任务
  35.         CronUtil.remove(taskId);
  37.         // 开始执行任务
  38.         CronUtil.schedule(taskId, cron, task);
  39.     }
  41.     @Override
  42.     public void stopTimer(String taskId) {
  43.         CronUtil.remove(taskId);
  44.     }
  45. }

5. 定义测试类

  1. /**
  2.  * 这是一个定时任务的示例程序
  3.  *
  4.  */
  5. @Component
  6. public class SystemOutTaskRunner implements TimerTaskRunner {
  8.     @Override
  9.     public void action() {
  10.         System.out.println("改革吹风吹....." + DateUtil.date());
  11.     }
  12. }

6. spring boot启动类添加注解

  1. @EnableScheduling