SpringAop + ThreadPoolTaskScheduler + 自定义注解实现动态定时任务

一、前述

在平时生活中，闲下来总会思考一些现实中已经拥有的东西，工具或者软件，假如自己是这些的开发者，我怎么去实现这个功能，于是乎，哼哧哼哧，实现一个最简单类似闹钟动态定时，开动

二、关于定时的那些过往

1、Timer 相信是许多程序员接触的第一个定时的类库，它属于 java.util 下，还记得当时，用 Timer 跑起来第一个定时任务的时候，这是多么神奇，Timer 内部定时调用的是 TimerTask ，TimerTask 是一个实现了 Runnable 接口的抽象类，所以使用多线程就比较方便
2、spring 的 @Scheduled 注解，该注解的 Target 是 ElementType.METHOD, ElementType.ANNOTATION_TYPE，通过编写 cron 表达式来指定定时任务的执行时间,也可以通过内部定义的方法来实现对应的一些场景，如下：

（1）fixedDelay： 间隔多久执行一次注解标注的方法，从上一次结束到下一次调用的开始时间，返回的是毫秒数，默认值为 -1
（2）fixedDelayString：同 fixedDelay，但是返回值是毫秒数的字符串形式，默认值为一个空串，“”
（3）fixedRate：间隔一定周期来调用两个方法，间隔时间指的是两次调用相隔时间，以毫秒为单位，执行带注解的方法
（4）fixedRateString：同 fixedRate ,但是返回为 String，默认为 “”
（5）initialDelay：在第一次执行之前，延迟多久启动
（6）initialDelayString：同 initialDelay ，返回值为 String

3、通过整合 Quartz 实现定时任务，这里不多做阐述

三、大概架构流程图

四、SpringAop + ThreadPoolTaskScheduler + 自定义注解实现

1、自定义一个注解 @FaithSchedule：

@Target(value = ElementType.METHOD)
@Retention(value = RetentionPolicy.RUNTIME)
public @interface FaithSchedule {
    /**
     * 定时任务方法
     * @return string
     */
    String scheduleMethod() default "";
    /**
     * 定时任务操作类型
     * @return DynamicOperationType
     */
    DynamicOperationType dynamicOperationType();
}

2、线程配置，FaithThreadPoolConfig：

@Configuration
public class FaithThreadPoolConfig {
    @Bean("faithThreadScheduler")
    public ThreadPoolTaskScheduler trPoolTaskScheduler(){
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        //核心线程数
        threadPoolTaskScheduler.setPoolSize(5);
        return threadPoolTaskScheduler;
    }
}

3、定时任务核心调度类，DynamicScheduledTask：

@Slf4j
@Component
@EnableScheduling
@Service
public class DynamicScheduledTask implements SchedulingConfigurer {

    @Autowired
    @Qualifier("faithThreadScheduler")
    private ThreadPoolTaskScheduler scheduler;
    private static Map<String, ScheduledFuture<?>> taskFutures = new ConcurrentHashMap<String, ScheduledFuture<?>>();

    @Override
    public void configureTasks(ScheduledTaskRegistrar scheduledTaskRegistrar) {}

    /**
     * 添加定时任务
     * @param runTime 运行时间
     * @param cron cron 表达式
     * @param taskId task 任务唯一标识
     */
    public void addTask(String runTime,String cron,String taskId) throws Exception{
        ScheduledFuture<?> scheduledFuture = scheduler.schedule(new Runnable() {
            @Override
            public void run() {
                System.out.println("running faith task");
            }
        }, new Trigger() {
            @Override
            public Date nextExecutionTime(TriggerContext triggerContext) {
                CronTrigger cronTrigger = new CronTrigger(cron);
                Date date = cronTrigger.nextExecutionTime(triggerContext);
                return date;
            }
        });
        taskFutures.put(runTime + "-" + (taskId.contains("-") ? taskId.substring(taskId.lastIndexOf("-") + 1):taskId),scheduledFuture);
    }

    /**
     * 获取正在执行的任务列表
     * @return List<String></>
     */
    public List<String> getTasks() throws Exception{
        List<String> tasks = new ArrayList<>();
        Set<Map.Entry<String, ScheduledFuture<?>>> entries = taskFutures.entrySet();
        Iterator<Map.Entry<String, ScheduledFuture<?>>> iterator = entries.iterator();
        while (iterator.hasNext()){
            Map.Entry<String, ScheduledFuture<?>> next = iterator.next();
            String key = next.getKey();
            tasks.add(key);
        }
        return tasks;
    }

    /**
     * 取消指定任务
     * @param taskId 任务唯一标识
     * @return boolean
     */
    public boolean cancelTask(String taskId) throws Exception{
        ScheduledFuture<?> offFuture = taskFutures.get(taskId);
        if(null != offFuture){
            boolean cancel = offFuture.cancel(true);
            boolean cancelled = offFuture.isCancelled();
            //将这个 taskId 的任务从 map 里面移除
            taskFutures.remove(taskId);
            log.info("cancel taskId ：{}, cancel result ：{}，is cancelled? :{}",taskId,cancel,cancelled);
            return cancel;
        }else{
            log.error("taskId: {} nonexistent",taskId);
            return false;
        }
    }

    /**
     * 重置指定任务
     * @param runTime 任务运行时间
     * @param taskId taskId 任务唯一标识
     * @param cron cron 表达式
     */
    public void resetTask(String runTime,String taskId,String cron) throws Exception{
        boolean cancel = cancelTask(taskId);
        if(cancel){
            addTask(runTime,cron,taskId);
        }
    }
}

4、定时任务操作类型接口，OperationType：

public interface OperationType {
    List<String> handle(JoinPoint joinPoint,FaithSchedule faithSchedule);
}

5、操作类型枚举类，DynamicOperationType：

@Slf4j
public enum DynamicOperationType implements OperationType {

    LIST() {
        @Override
        public List<String> handle(JoinPoint joinPoint,FaithSchedule faithSchedule) {
            try {
                List<String> tasks = dynamicScheduledTask.getTasks();
                return tasks;
            }catch (Exception e){
                FaithSysException.throwFaithSysException(FaithSysExceptionEnum.QUERY_TASK_LIST_ERROR,e.toString());
            }
            return new ArrayList<>();
        }
    },
    ADD(){
        @Override
        public List<String> handle(JoinPoint joinPoint, FaithSchedule faithSchedule){
            String name = faithSchedule.scheduleMethod();

            try {
                Object[] args = getArgs(joinPoint,name);
                AddForDynamicDto arg = (AddForDynamicDto)args[0];
                // invoke
                String runTime = arg.getRunTime();
                String cronTime = runTime.replaceAll(":", "-").replaceAll(" ", "-");
                String[] date = cronTime.split("-");
                String cron = FaithDateUtil.getCron(date);
                String taskid = UUID.randomUUID().toString().replaceAll("-", "");
                dynamicScheduledTask.addTask(cronTime,cron, taskid);
            } catch (Exception e) {
                FaithSysException.throwFaithSysException(FaithSysExceptionEnum.ADD_TASK_ERROR,e.toString());
                return null;
            }
            return new ArrayList<>();
        }
    },
    UPDATE() {
        @Override
        public List<String> handle(JoinPoint joinPoint,FaithSchedule faithSchedule){
            String name = faithSchedule.scheduleMethod();
            try {
                Object[] args = getArgs(joinPoint,name);
                UpdateForDynamicDto arg = (UpdateForDynamicDto)args[0];
                String cronTime = arg.getRunTime().replaceAll(":", "-").replaceAll(" ", "-");
                String cron = FaithDateUtil.getCron(cronTime.split("-"));
                dynamicScheduledTask.resetTask(cronTime, arg.getTaskId(), cron);
            }catch (Exception e){
                FaithSysException.throwFaithSysException(FaithSysExceptionEnum.ADD_TASK_ERROR,e.toString());
            }
            return new ArrayList<>();
        }
    },
    CANCEL() {
        @Override
        public List<String> handle(JoinPoint joinPoint,FaithSchedule faithSchedule){

            String name = faithSchedule.scheduleMethod();
            try {
                Object[] args = getArgs(joinPoint,name);

                CancelForDynamicDto arg = (CancelForDynamicDto)args[0];
                // invoke
                Object res = null;
                String taskId = arg.getTaskId();
                boolean resetTask = dynamicScheduledTask.cancelTask(taskId);
            }catch (Exception e){
                FaithSysException.throwFaithSysException(FaithSysExceptionEnum.CANCEL_TASK_ERROR,e.toString());
            }
            return new ArrayList<>();
        }
    };
    public DynamicScheduledTask dynamicScheduledTask;
    public DynamicScheduledTask getDynamicScheduledTask(){
        return dynamicScheduledTask;
    }
    public void setDynamicScheduledTask(DynamicScheduledTask dynamicScheduledTask){
        this.dynamicScheduledTask = dynamicScheduledTask;
    }
    @Component
    public static class DynamicScheduleServiceInjector{
        @Autowired
        private DynamicScheduledTask dynamicScheduledTask;
        @PostConstruct
        public void postConstruct(){
            for(DynamicOperationType type: EnumSet.allOf(DynamicOperationType.class)){
                type.setDynamicScheduledTask(dynamicScheduledTask);
            }
        }
    }
    private static Object[] getArgs(JoinPoint joinPoint,String name) throws Exception{
        Object res = null;
        Method currentMethod = ((MethodSignature)joinPoint.getSignature()).getMethod();
        Object target = joinPoint.getTarget();
        Method handleMethod = joinPoint.getTarget().getClass().getDeclaredMethod(name, currentMethod.getParameterTypes());
        handleMethod.setAccessible(true);
        Object[] args = joinPoint.getArgs();
        res = handleMethod.invoke(target, args);
        return args;
    }
}

五、简要说明

1、当 Http 请求进入到 Controller 层，Controller 调用 Service 的方法
2、将注解加在 Service 的方法上，调用时，通过 Aop 切入，拿到注解里的属性
3、根据注解的属性以及 Aop 获取的请求 Body ，在枚举类重写方法，实现任务调度

六、Gitee 地址

全部代码在 Gitee:faith-dynamic