schedule 通过数据库 动态新增任务

任务

@Component
public class DynamicPrintTask implements Runnable {
    public static Boolean isRun = false;
    @Autowired
    SpringScheduledCronRepository springScheduledCronRepository;

    @Override
    public void run() {
        if (isRun) return;
        isRun = true;
        System.out.println("-----=====定时任务"+ LocalDateTime.now().format(DateTimeFormatter.ISO_LOCAL_DATE_TIME));
        isRun = false;
    }
}

Utiles

public class BeanUtils {
    public static Field findField(Class<?> clazz, String name) {
        try {
            return clazz.getField(name);
        } catch (NoSuchFieldException ex) {
            return findDeclaredField(clazz, name);
        }
    }

    public static Field findDeclaredField(Class<?> clazz, String name) {
        try {
            return clazz.getDeclaredField(name);
        } catch (NoSuchFieldException ex) {
            if (clazz.getSuperclass() != null) {
                return findDeclaredField(clazz.getSuperclass(), name);
            }
            return null;
        }
    }

    public static Method findMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
        try {
            return clazz.getMethod(methodName, paramTypes);
        } catch (NoSuchMethodException ex) {
            return findDeclaredMethod(clazz, methodName, paramTypes);
        }
    }

    public static Method findDeclaredMethod(Class<?> clazz, String methodName, Class<?>... paramTypes) {
        try {
            return clazz.getDeclaredMethod(methodName, paramTypes);
        } catch (NoSuchMethodException ex) {
            if (clazz.getSuperclass() != null) {
                return findDeclaredMethod(clazz.getSuperclass(), methodName, paramTypes);
            }
            return null;
        }
    }

    public static Object getProperty(Object obj, String name) throws NoSuchFieldException {
        Object value = null;
        Field field = findField(obj.getClass(), name);
        if (field == null) {
            throw new NoSuchFieldException("no such field [" + name + "]");
        }
        boolean accessible = field.isAccessible();
        field.setAccessible(true);
        try {
            value = field.get(obj);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        field.setAccessible(accessible);
        return value;
    }

    public static void setProperty(Object obj, String name, Object value) throws NoSuchFieldException {
        Field field = findField(obj.getClass(), name);
        if (field == null) {
            throw new NoSuchFieldException("no such field [" + name + "]");
        }
        boolean accessible = field.isAccessible();
        field.setAccessible(true);
        try {
            field.set(obj, value);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        field.setAccessible(accessible);
    }

    public static Map<String, Object> obj2Map(Object obj, Map<String, Object> map) {
        if (map == null) {
            map = new HashMap<String, Object>();
        }
        if (obj != null) {
            try {
                Class<?> clazz = obj.getClass();
                do {
                    Field[] fields = clazz.getDeclaredFields();
                    for (Field field : fields) {
                        int mod = field.getModifiers();
                        if (Modifier.isStatic(mod)) {
                            continue;
                        }
                        boolean accessible = field.isAccessible();
                        field.setAccessible(true);
                        map.put(field.getName(), field.get(obj));
                        field.setAccessible(accessible);
                    }
                    clazz = clazz.getSuperclass();
                } while (clazz != null);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return map;
    }

    /**
     * 获得父类集合，包含当前class
     *
     * @param clazz
     * @return
     */
    public static List<Class<?>> getSuperclassList(Class<?> clazz) {
        List<Class<?>> clazzes = new ArrayList<Class<?>>(3);
        clazzes.add(clazz);
        clazz = clazz.getSuperclass();
        while (clazz != null) {
            clazzes.add(clazz);
            clazz = clazz.getSuperclass();
        }
        return Collections.unmodifiableList(clazzes);
    }

SchedulingConfigurer

@Component
public class MyScheduleConfigurer implements SchedulingConfigurer {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    @Autowired
    private SpringScheduledCronRepository repository;

    private ScheduledTaskRegistrar taskRegistrar;

    @Autowired
    MyScheduleConfigurer scheConfigurer;

    //注入我们的定时任务类
    @Autowired
    DynamicPrintTask task;

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

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

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {


        logger.info("configureTasks");

        List<SpringScheduledCron> springScheduledCrons = sortClearRules();

        this.taskRegistrar = taskRegistrar;
        this.taskRegistrar.setTaskScheduler(MyThreadPool.getScheduleTP(springScheduledCrons.size()+1));



        springScheduledCrons.forEach(springScheduledCron->{
            logger.info("springScheduledCrons = "+springScheduledCron.toString());
            scheConfigurer.addTriggerTask(springScheduledCron.getCron_id().toString(),new TriggerTask(task, triggerContext -> {
                //查询数据库  获得该类的cron表达式
                SpringScheduledCron springScheduledCronByCronKey = repository.findSpringScheduledCronById(springScheduledCron.getCron_id());
                String cronExpression = springScheduledCronByCronKey.getCron_expression();
                System.out.println(springScheduledCronByCronKey);
                // CronTrigger实现了Trigger
                return new CronTrigger(cronExpression).nextExecutionTime(triggerContext);
            }));
        });

    }

    /**
     * 添加任务
     *
     * @param taskId
     * @param triggerTask
     */
    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);
    }



    private Set<ScheduledFuture<?>> getScheduledFutures() {
        if (scheduledFutures == null) {
            try {
                scheduledFutures = (Set<ScheduledFuture<?>>) BeanUtils.getProperty(taskRegistrar,  "scheduledTasks");
            } catch (NoSuchFieldException e) {
                throw new SchedulingException("not found scheduledFutures field.");
            }
        }
        return scheduledFutures;
    }


    /**
     * 取消任务
     *
     * @param taskId
     */
    public void cancelTriggerTask(String taskId) {
        ScheduledFuture<?> future = taskFutures.get(taskId);
        if (future != null) {
            future.cancel(true);
        }
        taskFutures.remove(taskId);
        getScheduledFutures().remove(future);
    }

    /**
     * 重置任务
     *
     * @param taskId
     * @param triggerTask
     */
    public void resetTriggerTask(String taskId, TriggerTask triggerTask) {
        cancelTriggerTask(taskId);
        addTriggerTask(taskId, triggerTask);
    }

    /**
     * 任务编号
     *
     * @return
     */
    public Set<String> taskIds() {
        return taskFutures.keySet();
    }

    /**
     * 是否存在任务
     *
     * @param taskId
     * @return
     */
    public boolean hasTask(String taskId) {
        return this.taskFutures.containsKey(taskId);
    }

    /**
     * 任务调度是否已经初始化完成
     *
     * @return
     */
    public boolean inited() {
        return this.taskRegistrar != null && this.taskRegistrar.getScheduler() != null;
    }
    /**
     * 初始化数据库数据
     * @return
     */
    private List<SpringScheduledCron> sortClearRules() {
        List<SpringScheduledCron> springScheduledCrons = repository.selectAll();
        springScheduledCrons.forEach(rule -> {
            logger.info("springScheduledCrons = "+springScheduledCrons);
        });
        return springScheduledCrons;
    }


}

实体类

@Table(name = "spring_scheduled_cron")
public class SpringScheduledCron {
    @Id
    @GeneratedValue(generator = "JDBC",strategy= GenerationType.AUTO)
    private Integer cron_id;
    private String cron_key;
    private String cron_expression;
    private String task_explain;
    private Integer status;

    public Integer getCron_id() {
        return cron_id;
    }

    public void setCron_id(Integer cron_id) {
        this.cron_id = cron_id;
    }

    public String getCron_key() {
        return cron_key;
    }

    public void setCron_key(String cron_key) {
        this.cron_key = cron_key;
    }

    public String getCron_expression() {
        return cron_expression;
    }

    public void setCron_expression(String cron_expression) {
        this.cron_expression = cron_expression;
    }

    public String getTask_explain() {
        return task_explain;
    }

    public void setTask_explain(String task_explain) {
        this.task_explain = task_explain;
    }

    public Integer getStatus() {
        return status;
    }

    public void setStatus(Integer status) {
        this.status = status;
    }

    @Override
    public String toString() {
        return "SpringScheduledCron{" +
                "cron_id=" + cron_id +
                ", cron_key='" + cron_key + '\'' +
                ", cron_expression='" + cron_expression + '\'' +
                ", task_explain='" + task_explain + '\'' +
                ", status=" + status +
                '}';
    }
}

Dao

public interface SpringScheduledCronRepository extends BaseMapper<SpringScheduledCron> {

    //根据CronKey查找表达式
    @Select("select * from spring_scheduled_cron where cron_key = #{cronKey}")
    List<SpringScheduledCron> findSpringScheduledCronByCronKey(@Param("cronKey") String cronKey);

    //根据CronKey查找表达式
    @Select("select * from spring_scheduled_cron where cron_id = #{id}")
    SpringScheduledCron findSpringScheduledCronById(@Param("id") Integer id);
}

线程池

public class MyThreadPool {
    /**
     * 将queueSize=1，尽可能保持按任务提交顺序进行执行！
     *
     * @param maximumPoolSize
     *            线程池峰值线程个数
     * @return ThreadPoolExecutor
     */
    public static ThreadPoolExecutor getTP(int maximumPoolSize) {
        return (new ThreadPoolExecutor(maximumPoolSize / 10 + 1, maximumPoolSize, 2, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(1), new CallerRunsPolicy()));

        // return (new ThreadPoolExecutor(maxPoolSize , maxPoolSize, 0,
        // TimeUnit.SECONDS,
        // new ArrayBlockingQueue<Runnable>(maxPoolSize + 5), new
        // ThreadPoolExecutor.CallerRunsPolicy()));
    }

    /**
     *
     * @param maximumPoolSize
     *            线程池峰值线程个数
     * @return ThreadPoolExecutor
     */
    public static ThreadPoolTaskScheduler getScheduleTP(int maximumPoolSize) {
        ThreadPoolTaskScheduler taskScheduler = new ThreadPoolTaskScheduler();
        taskScheduler.setPoolSize(maximumPoolSize);
        taskScheduler.setThreadNamePrefix("TaskScheduler-ThreadPool-");
        // 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者
        taskScheduler.setRejectedExecutionHandler(new CallerRunsPolicy());
        // 调度器shutdown被调用时等待当前被调度的任务完成
        taskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        // 等待时长
        taskScheduler.setAwaitTerminationSeconds(60);
        taskScheduler.initialize();
        return taskScheduler;
    }

    /**
     *
     * @param maximumPoolSize
     *            线程池峰值线程个数
     * @return ThreadPoolExecutor
     */
    public static ThreadPoolTaskExecutor getExecutorTP(int maximumPoolSize) {
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(maximumPoolSize / 10 + 1);
        taskExecutor.setMaxPoolSize(maximumPoolSize);
        taskExecutor.setThreadNamePrefix("TaskExecutor-ThreadPool-");
        // 线程池对拒绝任务（无线程可用）的处理策略，目前只支持AbortPolicy、CallerRunsPolicy；默认为后者
        taskExecutor.setRejectedExecutionHandler(new CallerRunsPolicy());
        // 调度器shutdown被调用时等待当前被调度的任务完成
        taskExecutor.setWaitForTasksToCompleteOnShutdown(true);
        // 等待时长
        taskExecutor.setAwaitTerminationSeconds(60);
        taskExecutor.initialize();
        return taskExecutor;
    }


    /**
     * @param maximumPoolSize
     *            线程池峰值线程个数
     * @param queueSize
     *            线程池ArrayBlockingQueue大小
     * @return ThreadPoolExecutor
     */
    public static ThreadPoolExecutor getTP(int maximumPoolSize, int queueSize) {
        return (new ThreadPoolExecutor(maximumPoolSize / 10 + 1, maximumPoolSize, 2, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize), new CallerRunsPolicy()));
    }

    /**
     * @param corePoolSize
     *            线程池初始线程个数
     * @param maximumPoolSize
     *            线程池峰值线程个数
     * @param queueSize
     *            线程池ArrayBlockingQueue大小
     * @return ThreadPoolExecutor
     */
    public static ThreadPoolExecutor getTP(int corePoolSize, int maximumPoolSize, int queueSize) {
        return (new ThreadPoolExecutor(corePoolSize, maximumPoolSize, 2, TimeUnit.SECONDS,
                new ArrayBlockingQueue<Runnable>(queueSize), new CallerRunsPolicy()));
    }

    /**
     * A handler for rejected tasks that runs the rejected task directly in the
     * calling thread of the {@code execute} method, unless the executor has
     * been shut down, in which case the task is discarded.
     */
    public static class CallerRunsPolicy implements RejectedExecutionHandler {
        /**
         * Creates a {@code CallerRunsPolicy}.
         */
        public CallerRunsPolicy() {
        }

        /**
         * Executes task r in the caller's thread, unless the executor has been
         * shut down, in which case the task is discarded.
         *
         * @param r
         *            the runnable task requested to be executed
         * @param e
         *            the executor attempting to execute this task
         */
        public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
            try {
                e.getQueue().put(r);
            } catch (InterruptedException e1) {
                e1.printStackTrace();
            }
            // if (!e.isShutdown()) {
            // r.run();
            // }
        }
    }

}

controller

 @RestController
@RequestMapping("/test")
public class TestController {
@GetMapping("/test")
public Result test(){

    myScheConfigurer.addTriggerTask("19",new TriggerTask((Runnable)task,triggerContext -> {
        return new CronTrigger("30 * * * * ?").nextExecutionTime(triggerContext);
    }));
// return    templateReportService.getSgxBEventProcessByTypeSum("2021-02-10","2021-03-29",2);
    return  null;
}
}

补充

  /**
     * 添加任务
     *
     * @param taskId
     * @param triggerTask
     */
    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);
    }

这里添加任务是 不能直接使用 @Autowired 注入的 task 而必须使用 new 的形式

可以参考 https://blog.csdn.net/qq_38009686/article/details/121350600