聚合应用(微服务)下动态创建定时任务ScheduleTask动态读取cron表达式

创建父级parent类

创建返回值统一类 ResultBody

package com.example.demo.schedule.parent.controller;

import com.alibaba.fastjson.JSON;
import java.io.Serializable;
import java.util.HashMap;
import java.util.Map;
 
@SuppressWarnings("all")
public class ResultBody<T> implements Serializable {
    private static final long serialVersionUID = -6190689122701100762L;

    /**
     * 响应编码
     */
    private int code = 0;
    /**
     * 提示消息
     */
    private String msg = "操作成功";

    /**
     * 请求路径
     */
    private String path;

    /**
     * 响应数据
     */
    private T data;

    /**
     * 附加数据
     */
    private Map<String, Object> extra;

    /**
     * 响应时间
     */
    private long timestamp = System.currentTimeMillis();

    public ResultBody() {
        super();
    }
    public static ResultBody ok() {
        return new ResultBody();
    }
    public static ResultBody fail() {
        ResultBody resultBody = new ResultBody();
        resultBody.code = -1;
        resultBody.msg = "操作失败";
        return resultBody;
    }
    public ResultBody put(String key, Object value) {
        if (this.extra == null) {
            this.extra = new HashMap<>();
        }
        this.extra.put(key, value);
        return this;
    }
    public ResultBody data(T data) {
        this.data = data;
        return this;
    }
    public ResultBody msg(String msg) {
        this.msg = msg;
        return this;
    }
    public ResultBody path(String path) {
        this.path = path;
        return this;
    }
    public ResultBody extra(Map<String, Object> extra) {
        this.extra = extra;
        return this;
    }
    public ResultBody code(int code) {
        this.code = code;
        return this;
    }
/*    public ResultBody getEncrypt(String salt) {
        try {
            this.data = (T) AESUtils.encrypt(salt,
                    DateUtils.formatDate(new Date(), "yyyyMMdd"),
                    JSON.toJSONString(this.data));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return this;
    }*/

    public String json() {
        return JSON.toJSONString(this);
    }


    public static long getSerialVersionUID() {
        return serialVersionUID;
    }

    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }

    public String getPath() {
        return path;
    }

    public void setPath(String path) {
        this.path = path;
    }

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    public Map<String, Object> getExtra() {
        return extra;
    }

    public void setExtra(Map<String, Object> extra) {
        this.extra = extra;
    }

    public long getTimestamp() {
        return timestamp;
    }

    public void setTimestamp(long timestamp) {
        this.timestamp = timestamp;
    }
}

创建 SmartTaskController 

package com.example.demo.schedule.parent.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.example.demo.schedule.parent.model.SmartTask;
import com.example.demo.schedule.parent.service.DynamicTaskService;
import com.example.demo.schedule.parent.service.SmartTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;

@RestController
@RequestMapping(value = "/smart/task")
public class SmartTaskController {

    @Autowired
    private SmartTaskService smartTaskService;
    @Autowired
    private DynamicTaskService dynamicTaskService;

    /**
     * 分页查看任务列表
     * @param paramMap
     * @return
     */
    @GetMapping(value = "/page")
    public ResultBody page(@RequestParam Map<String, Objects> paramMap) {
        return ResultBody.ok().data(smartTaskService.findTaskPageList( ));
    }

    /**
     * 查看task详情
     * @param taskId
     * @return
     */
    @GetMapping(value = "/getByTaskId/{taskId}")
    public ResultBody<SmartTask> getByTaskId(@PathVariable("taskId") String taskId) {
        return ResultBody.ok().data(smartTaskService.findTaskByTaskId(taskId));
    }

    /**
     * 创建定时任务
     * @param smartTask
     * @return
     */
    @PostMapping(value = "/addTask")
    public ResultBody addTask(SmartTask smartTask) {
        try {
            smartTaskService.addTask(smartTask);
            if (smartTask.getState()==1) {
                dynamicTaskService.addTask(smartTask);
            }
            return ResultBody.ok();
        } catch (Exception e) {
            return ResultBody.fail().msg(e.getMessage());
        }
    }

    /**
     * 更新定时任务
     * @param smartTask
     * @return
     */
    @PostMapping(value = "/updatByTaskId")
    public ResultBody updatByTaskId(@RequestBody SmartTask smartTask) {
        try {
            if ( null != smartTask.getExtra()) {
                smartTask.setCron(cron(smartTask.getCron(), smartTask.getExtra()));
            }
            smartTaskService.updateTaskByTaskId(smartTask);
            SmartTask task = smartTaskService.findTaskByTaskId(smartTask.getTaskId());
            if (task.getState()==1) {
                dynamicTaskService.resetTriggerTask(task);
            }
            return ResultBody.ok();
        } catch (Exception e) {
            e.printStackTrace();
            return ResultBody.fail().msg(e.getMessage());
        }
    }

    /**
     * 重启定时任务
     * @param taskId
     * @return
     */
    @GetMapping(value = "/cancelByTaskId/{taskId}")
    public ResultBody cancelByTaskId(@PathVariable("taskId") String taskId) {
        try {
            if (!dynamicTaskService.hasTask(taskId)) {
                throw new RuntimeException("任务尚未执行，不可取消！");
            }
            SmartTask smartTask = new SmartTask();
            smartTask.setTaskId(taskId);
            smartTask.setState(0);
            smartTaskService.updateTaskByTaskId(smartTask);
            dynamicTaskService.cancelTriggerTask(taskId);
            return ResultBody.ok();
        } catch (Exception e) {
            return ResultBody.fail().msg(e.getMessage());
        }
    }

    /**
     * 批量取消任务
     * @param taskIdList
     * @return
     */
    @PostMapping(value = "/cancel")
    public ResultBody cancel(@RequestBody List<String> taskIdList) {
        smartTaskService.updateStateBatch(0, taskIdList.stream().filter(x->!dynamicTaskService.hasTask(x)).collect(Collectors.toList()));
        return ResultBody.ok();
    }

    /**
     * 启动一个定时任务
     * @param taskId
     * @return
     */
    @GetMapping(value = "/start/{taskId}")
    public ResultBody start(@PathVariable("taskId") String taskId) {
        try {
            if (dynamicTaskService.hasTask(taskId)) {
                throw new RuntimeException("当前任务已执行，不可重复操作！");
            }
            SmartTask smartTask = new SmartTask();
            smartTask.setTaskId(taskId);
            smartTask.setState(1);
            smartTaskService.updateTaskByTaskId(smartTask);
            dynamicTaskService.addTask(smartTaskService.findTaskByTaskId(taskId));
            return ResultBody.ok();
        } catch (Exception e) {
            return ResultBody.fail().msg(e.getMessage());
        }
    }

    /**]
     * 重置任务
     * @param taskId
     * @return
     */
    @GetMapping(value = "/restart/{taskId}")
    public ResultBody restart(@PathVariable("taskId") String taskId) {
        try {
            SmartTask smartTask = new SmartTask();
            smartTask.setTaskId(taskId);
            smartTask.setState(1);
            smartTaskService.updateTaskByTaskId(smartTask);
            dynamicTaskService.resetTriggerTask(smartTask);
            return ResultBody.ok();
        } catch (Exception e) {
            return ResultBody.fail().msg(e.getMessage());
        }
    }

    /**
     * 获取所有运行中的任务
     * @return
     */
    @GetMapping(value = "/getRunTaskList")
    public ResultBody<List<SmartTask>> getRunTaskList() {
        return ResultBody.ok().data(smartTaskService.getRunTaskList(dynamicTaskService.getRunTaskIdList()));
    }

    /**
     * 创建每周任务
     * @param smartTask
     * @return
     */
    @PostMapping(value = "/addWeekTask")
    public ResultBody addWeekTask(@RequestBody SmartTask smartTask) {
        try {
            if (null != smartTask.getExtra()) {
                throw new RuntimeException("任务创建失败！，未指定公式！");
            }
            smartTask.setCron(cron(smartTask.getCron(), smartTask.getExtra()));
            smartTaskService.addTask(smartTask);
            return ResultBody.ok();
        } catch (Exception e) {
            return ResultBody.fail().msg(e.getMessage());
        }
    }

    private String cron(String cron, String extra) {
        if (null == extra) {
            return cron;
        }
        JSONObject jsonObject = JSON.parseObject(extra);
        String newCron = "";
        switch (jsonObject.getIntValue("type")) {
            case 1: {
                //每天
                //获取每周哪一天的几天执行
                int hour = jsonObject.getIntValue("hour");
                //分
                int minute = jsonObject.getIntValue("minute");
                //秒
                int second = jsonObject.getIntValue("second");
                newCron = String.format("%d %d %d ? * *", second, minute, hour);
            } break;
            case 2: {
                //每周的哪一天执行
                int day = jsonObject.getIntValue("day");
                //获取每周哪一天的几天执行
                int hour = jsonObject.getIntValue("hour");
                //分
                int minute = jsonObject.getIntValue("minute");
                //秒
                int second = jsonObject.getIntValue("second");
                newCron = String.format("%d %d %d ? * %d", second, minute, hour, day);
            } break;
        }
        System.err.println("生成表达式：" + newCron);
        return newCron;
    }

    /**
     * 创建每天任务
     * @return
     */
    @PostMapping(value = "/addEveryDay")
    public ResultBody addEveryDay(@RequestBody SmartTask smartTask) {
        try {
            if (null != smartTask.getExtra()) {
                throw new RuntimeException("任务创建失败！，未指定公式！");
            }
            smartTask.setCron(cron(smartTask.getCron(), smartTask.getExtra()));
            smartTaskService.addTask(smartTask);
            return ResultBody.ok();
        } catch (Exception e) {
            return ResultBody.fail().msg(e.getMessage());
        }
    }


}

创建 SmartTaskMapper   

package com.example.demo.schedule.parent.mapper;

import com.example.demo.schedule.parent.model.SmartTask;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface SmartTaskMapper   {
    /**
     * 批量执行状态更新
     * @param state
     * @param idList
     */
    void updateStateBatch(@Param("state") int state, @Param("idList") List<String> idList);



    @Select("select t.task_id as taskId, t.name as name, t.create_time as createTime, t.update_time as updateTime, t.cron as cron, t.state as state, t.brief as brief, t.clazz_name as clazzName, t.business_type as businessType, t.extra as extra from t_task t where t.state = 1 and t.business_type ='${businessType}' ")
    List<SmartTask>  getList(@Param("businessType")  Integer  businessType );





}

创建 实体类

package com.example.demo.schedule.parent.model;


import java.io.Serializable;

/**
 * 任务模型
 */

public class SmartTask  implements Serializable {
    /**
     * 对应任务ID
     */

    private String taskId;
    /**
     * 定时任务表达式
     */
    private String cron;
    /**
     * 具体执行的操作
     */
//    private Runnable runnable;
    /**
     * 任务名称
     */
    private String name;
    /**
     * 任务状态，1：开启，0：未开启
     */
    private Integer state;
    /**
     * 任务描述
     */
    private String brief;
    /**
     * 实现任务的类名 (路径 + 类名 例如：cn.xxx.TaskXXX)
     */
    private String clazzName;
    /**
     * 业务类型 1: 每周答题
     */
    private Integer businessType;
    /**
     * 附加数据
     */
    private String extra;


    public String createTime;
    /**
     * 修改时间
     */
    public String updateTime;

    public String getCreateTime() {
        return createTime;
    }

    public void setCreateTime(String createTime) {
        this.createTime = createTime;
    }

    public String getUpdateTime() {
        return updateTime;
    }

    public void setUpdateTime(String updateTime) {
        this.updateTime = updateTime;
    }

    public String getTaskId() {
        return taskId;
    }

    public void setTaskId(String taskId) {
        this.taskId = taskId;
    }

    public String getCron() {
        return cron;
    }

    public void setCron(String cron) {
        this.cron = cron;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getState() {
        return state;
    }

    public void setState(Integer state) {
        this.state = state;
    }

    public String getBrief() {
        return brief;
    }

    public void setBrief(String brief) {
        this.brief = brief;
    }

    public String getClazzName() {
        return clazzName;
    }

    public void setClazzName(String clazzName) {
        this.clazzName = clazzName;
    }

    public Integer getBusinessType() {
        return businessType;
    }

    public void setBusinessType(Integer businessType) {
        this.businessType = businessType;
    }

    public String getExtra() {
        return extra;
    }

    public void setExtra(String extra) {
        this.extra = extra;
    }
}

创建  SmartTaskService

package com.example.demo.schedule.parent.service;

import com.example.demo.schedule.parent.model.SmartTask;

import java.util.List;

/**
 * 动态定时任务相关信息
 */
public interface SmartTaskService   {
    /**
     * 创建定时任务
     * @param smartTask
     */
    void addTask(SmartTask smartTask);

    /**
     * 更新任务
     * @param smartTask
     */
    void updateTaskByTaskId(SmartTask smartTask);

    /**
     * 查询任务列表
     * @param
     * @return
     */
    List<SmartTask>  findTaskPageList( );

    /**
     * 查看任务详情
     * @param taskId
     * @return
     */
    SmartTask findTaskByTaskId(String taskId);

    /**
     * 删除任务
     * @param taskId
     */
    void deleteTaskByTaskId(String taskId);

    /**
     * 查询所有在执行的任务
     * @return
     */
    List<SmartTask> findAll(SmartTask smartTask);

    /**
     * 获取所有执行中的任务
     * @param idList
     * @return
     */
    List<SmartTask> getRunTaskList(List<String> idList);
    /**
     * 批量执行状态更新
     * @param state
     * @param idList
     */
    void updateStateBatch(int state, List<String> idList);

    /**
     * 启动指定类型的任务
     * @param businessType          任务类型
     */
    void runTask( Integer businessType );

}

创建 SmartTaskServiceImpl 实现类

package com.example.demo.schedule.parent.service.impl;

import com.example.demo.schedule.parent.mapper.SmartTaskMapper;
import com.example.demo.schedule.parent.model.SmartTask;
import com.example.demo.schedule.parent.service.DynamicTaskService;
import com.example.demo.schedule.parent.service.SmartTaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;

@Service("smartTaskService")
public class SmartTaskServiceImpl   implements SmartTaskService {

    @Autowired
    private SmartTaskMapper smartTaskMapper;
    @Autowired
    private DynamicTaskService dynamicTaskService;

    /**
     * 创建定时任务
     *
     * @param smartTask
     */
    @Override
    public void addTask(SmartTask smartTask) {
        // smartTaskMapper.insert(smartTask);
    }

    /**
     * 更新任务
     *
     * @param smartTask
     */
    @Override
    public void updateTaskByTaskId(SmartTask smartTask) {
      //   smartTaskMapper.updateById(smartTask);
    }

    /**
     * 查询任务列表
     *
     * @param
     * @return
     */
    @Override
    public List<SmartTask> findTaskPageList( ) {

         return null;
    }

    /**
     * 查看任务详情
     *
     * @param taskId
     * @return
     */
    @Override
    public SmartTask findTaskByTaskId(String taskId) {
         return null;
    }

    /**
     * 删除任务
     *
     * @param taskId
     */
    @Override
    public void deleteTaskByTaskId(String taskId) {

    }

    /**
     * 查询所有在执行的任务
     *
     * @return
     */
    @Override
    public List<SmartTask> findAll(SmartTask smartTask) {
        return  null;
    }

    /**
     * 获取所有执行中的任务
     *
     * @param idList
     * @return
     */
    @Override
    public List<SmartTask> getRunTaskList(List<String> idList) {
        return  null;
    }

    /**
     * 批量执行状态更新
     *
     * @param state
     * @param idList
     */
    @Override
    public void updateStateBatch(int state, List<String> idList) {
        smartTaskMapper.updateStateBatch(state, idList);
    }

    @Override
    public void runTask( Integer  businessType ) {
        List<SmartTask> smartTaskList =  smartTaskMapper.getList(businessType );
        if (smartTaskList!=null&&smartTaskList.size()>0) {
            for (SmartTask smartTask : smartTaskList) {
                dynamicTaskService.addTask(smartTask);
            }
        }
    }
}

创建  DynamicTaskService

package com.example.demo.schedule.parent.service;

import com.example.demo.schedule.parent.model.SmartTask;

import java.util.List;
import java.util.Set;

public abstract class DynamicTaskService {

    /**
     * 添加任务
     */
    public abstract void addTask(SmartTask smartTask);


    /**
     * 取消任务
     */
    public abstract void cancelTriggerTask(String taskId);

    /**
     * 重置任务
     */
    public abstract void resetTriggerTask(SmartTask smartTask);

    /**
     * 任务编号
     */
    public abstract Set<String> taskIds();

    /**
     * 是否存在任务
     */
    public abstract boolean hasTask(String taskId);

    /**
     * 是否初始化
     * @return
     */
    public abstract boolean inited();

    /**
     * 获取执行中的任务ID
     * @return
     */
    public abstract List<String> getRunTaskIdList();

}

创建  DynamicTaskService 实现类

package com.example.demo.schedule.parent.service.impl;

import com.example.demo.schedule.parent.SpringContextUtils;
import com.example.demo.schedule.parent.parentConfig.AbstractTaskQueue;
import com.example.demo.schedule.parent.model.SmartTask;
import com.example.demo.schedule.parent.service.DynamicTaskService;
import org.springframework.core.annotation.Order;
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.support.CronTrigger;
import org.springframework.stereotype.Service;
import java.util.*;
import java.util.concurrent.ScheduledFuture;
import java.util.stream.Collectors;

@EnableScheduling
@Service("dynamicTaskService")
@SuppressWarnings("all")
@Order(-5000)
public class DynamicTaskServiceImpl extends DynamicTaskService implements SchedulingConfigurer {

    private ScheduledTaskRegistrar taskRegistrar = null;
    private Map<String, ScheduledFuture<?>> taskFutures =new HashMap<>() ; // Maps.newHashMap();

    @Override
    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
        this.taskRegistrar = taskRegistrar;

    }

    /**
     * 添加任务
     * @param taskId        任务id
     * @param cron          表达式
     * @param runnable      代码块
     */
    @Override
    public void addTask(SmartTask smartTask) {
        synchronized (this) {
            if (taskFutures.containsKey(smartTask.getTaskId())) {
                throw new SchedulingException(" taskId[" + smartTask.getTaskId() + "] 已存在.");
            }
            try {
                TaskScheduler scheduler = taskRegistrar.getScheduler();
                System.out.println(smartTask.getClazzName());
                System.err.println("smartTask = " + smartTask);
                Class clazz = Class.forName(smartTask.getClazzName());
                AbstractTaskQueue runnable = (AbstractTaskQueue) SpringContextUtils.getBean(clazz);
                runnable.setSmartTask(smartTask);
                ScheduledFuture<?> future = scheduler.schedule(runnable, new CronTrigger(smartTask.getCron()));
                taskFutures.put(smartTask.getTaskId(), future);
            } catch (Exception e) {

                e.printStackTrace();
            }
        }
    }

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

    /**
     * 重置任务
     */
    @Override
    public void resetTriggerTask(SmartTask smartTask) {
        cancelTriggerTask(smartTask.getTaskId());
        addTask(smartTask);
    }

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

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

    /**
     * 任务调度是否已经初始化完成
     */
    @Override
    public boolean inited() {
        return this.taskRegistrar != null && this.taskRegistrar.getScheduler() != null;
    }

    /**
     * 获取执行中的任务ID
     *
     * @return
     */
    @Override
    public List<String> getRunTaskIdList() {
        return taskFutures.keySet().stream().collect(Collectors.toList());
    }

}

创建 配置文件 AbstractTaskQueue 

package com.example.demo.schedule.parent.parentConfig;

import com.example.demo.schedule.parent.model.SmartTask;



public abstract class AbstractTaskQueue implements Runnable {
    /**
     * 将任务本身当做参数传入
     */
    protected SmartTask smartTask;

    public SmartTask getSmartTask() {
        return smartTask;
    }

    public void setSmartTask(SmartTask smartTask) {
        this.smartTask = smartTask;
    }
}

创建 配置文件 ApplicationStartListener  

package com.example.demo.schedule.parent.parentConfig;


import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;

/**
 * 放入父模块
 * 监听程序启动
 */

@SuppressWarnings("all")
public class ApplicationStartListener implements ApplicationListener<ContextRefreshedEvent> {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        System.out.println("程序已加载");
    }
}

创建 配置文件  DynamicTaskConfiguration 

package com.example.demo.schedule.parent.parentConfig;

import com.example.demo.schedule.parent.service.DynamicTaskService;
import com.example.demo.schedule.parent.service.SmartTaskService;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.event.ContextRefreshedEvent;

//父类模块（多服务的时候，放入父模块）

public abstract class DynamicTaskConfiguration extends ApplicationStartListener implements ApplicationContextAware {

    protected ApplicationContext context;

    @Autowired
    protected SmartTaskService smartTaskService;
    @Autowired
    protected DynamicTaskService dynamicTaskService;

    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        super.onApplicationEvent(event);
        dynamicTaskService.inited();
    }

    @Override
    public void setApplicationContext(ApplicationContext context) throws BeansException {
        this.context = context;
    }
}

创建 配置文件  SpringContextUtils 

package com.example.demo.schedule.parent;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

@Component
public class SpringContextUtils implements ApplicationContextAware{

        private static ApplicationContext applicationContext;

        public SpringContextUtils() {
        }

        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            SpringContextUtils.applicationContext = applicationContext;
        }

        public static Object getBean(String beanName) {
            return applicationContext != null ? applicationContext.getBean(beanName) : null;
        }

        public static <T> T getBean(Class<T> clazz) {
            return applicationContext != null?applicationContext.getBean(clazz):null;
        }

}

创建 children 子项目文件

创建配置文件TaskConfiguration （项目启动加载子项目1）

package com.example.demo.schedule.children.config;

import com.example.demo.schedule.parent.parentConfig.DynamicTaskConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;

/**
 *   写到子模块里面（每个子服务的定时任务不同，所有需要区分下）
 *  服务器启动的时候加载对应的定时任务
 */

@Configuration
public class TaskConfiguration extends DynamicTaskConfiguration {

    //添加每天轮训资格证有效期（通过条件查询对应的定时任务）
    @Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        super.onApplicationEvent(event);
        smartTaskService.runTask(1);
    }

}

创建配置文件TaskConfigurationCount （项目启动加载子项目2）

package com.example.demo.schedule.children.config;

import com.example.demo.schedule.parent.parentConfig.DynamicTaskConfiguration;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;

/** 
 * @author: xlk 
 */

@Configuration
public class TaskConfigurationCount extends DynamicTaskConfiguration {


     //添加每天统计资格证的数量
     @Override
     public void onApplicationEvent(ContextRefreshedEvent event) {
         super.onApplicationEvent(event);
         smartTaskService.runTask( 2 );
     }

}

创建执行任务逻辑1

package com.example.demo.schedule.children.task;

import com.example.demo.schedule.parent.parentConfig.AbstractTaskQueue;
import org.springframework.stereotype.Component;

//定时任务执行逻辑

@Component
public class RotationQualificationCreator extends AbstractTaskQueue {

    @Override
    public void run() {
        System.out.println(" =====定时任务开始执行逻辑====== "  );
    }
}

创建执行任务逻辑2

package com.example.demo.schedule.children.task;

import com.example.demo.schedule.parent.parentConfig.AbstractTaskQueue;
import org.springframework.stereotype.Component;

@Component
public class RotationQualificationCreatorCount extends AbstractTaskQueue {

    @Override
    public void run() {
        System.out.println(" ============== 每天定时统计资格证数量 ========== "  );

    }
}

创建 启动类

package com.example.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.scheduling.annotation.EnableScheduling;

@EnableScheduling
@SpringBootApplication
public class DemoApplication {

	public static void main(String[] args) {
		SpringApplication.run(DemoApplication.class, args);
	}

}

创建 application.properties

server.port=8081
spring.datasource.url:jdbc:mysql://192.168.1.215:3306/task_demo?useSSL=false
spring.datasource.username:root
spring.datasource.password:root

创建数据库脚本

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for t_task
-- ----------------------------
DROP TABLE IF EXISTS `t_task`;
CREATE TABLE `t_task`  (
  `task_id` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '任务编号',
  `name` varchar(64) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '任务名称',
  `create_time` varchar(19) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '创建时间',
  `update_time` varchar(19) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '更新时间',
  `cron` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NOT NULL COMMENT '表达式',
  `state` tinyint(1) NOT NULL COMMENT '任务状态，1：开启，0：未开启',
  `brief` text CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL COMMENT '任务描述',
  `clazz_name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL DEFAULT NULL COMMENT '文件名',
  `business_type` int(4) NULL DEFAULT NULL COMMENT '业务类型 1: 每周答题',
  `extra` text CHARACTER SET utf8mb4 COLLATE utf8mb4_bin NULL COMMENT '附加数据',
  PRIMARY KEY (`task_id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8mb4 COLLATE = utf8mb4_bin COMMENT = '任务表' ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of t_task
-- ----------------------------
INSERT INTO `t_task` VALUES ('2021061214255624300000010', '任务 -- 1', '2021-11-26 18:10:00', '2021-11-29 15:46:04', '0/2 * * * * ?', 1, '每天轮训资格证有效期1', 'com.example.demo.schedule.children.task.RotationQualificationCreator', 1, '');
INSERT INTO `t_task` VALUES ('2021061214255624300000020', '任务 -- 2', '2021-11-26 18:10:00', '2021-11-29 15:46:04', '0/2 * * * * ?', 1, '每天轮训资格证有效期2', 'com.example.demo.schedule.children.task.RotationQualificationCreatorCount', 2, '');

SET FOREIGN_KEY_CHECKS = 1;

执行打印日志

demo地址：

链接：https://pan.baidu.com/s/1W6tYi5uzz35dX9iWLR9n7Q 
提取码：1234