• jwbasta-Springboot集成Quartz

    功能点

    1. 添加CRON、固定间隔定时
    2. 修改定时的触发器
    3. 修改定时参数
    4. 暂停定时
    5. 启动暂停的定时
    6. 获取所有定时
    7. 启动所有定时
    8. 停止定时

    0.通过maven引入jar包

    1. <dependency>
    2.  
    3. <groupId>org.springframework.bootgroupId>
    4.  
    5. <artifactId>spring-boot-starter-quartzartifactId>
    6.  
    7. dependency>

    1. 定时类型

    Quartz可以通过org.quartz.Trigger.class去拓展定时类型的，目前需求需要支持CRON和固定间隔两种定时类型，后期需要支持跳过节假日、周一～周五、周末等需求，所以需要让定时类型支持拓展。

    1. 1.1定时类型
    2. /**
    4. *
    6. * 定时类型触发器类型
    8. * @author jiangwei
    10. *
    12. */
    13.  
    14. public enum TriggerType {
    15.  
    16.  
    17.  
    18. /**
    20. * 标准CRON支持
    22. */
    23.  
    24. CRON("标准CRON支持"),
    25.  
    26. /**
    28. * 固定间隔毫秒
    30. */
    31.  
    32. INTERVAL_MILLISECOND("固定间隔毫秒"),
    33.  
    34. /**
    36. * 固定间隔秒
    38. */
    39.  
    40. INTERVAL_SECOND("固定间隔秒"),
    41.  
    42. /**
    44. * 固定间隔分钟
    46. */
    47.  
    48. INTERVAL_MINUTE("固定间隔分钟"),
    49.  
    50. /**
    52. * 固定间隔小时
    54. */
    55.  
    56. INTERVAL_HOUR("固定间隔小时"),
    57.  
    58. /**
    60. * 工作日，跳过节假日
    62. */
    63.  
    64. WEEKDAYS("工作日，跳过节假日"),
    65.  
    66. /**
    68. * 节假日
    70. */
    71.  
    72. HOLIDAY("节假日")
    73.  
    74. ;
    75.  
    76.  
    77.  
    78.  
    79.  
    80. private String describe;
    81.  
    82.  
    83.  
    84. TriggerType(String describe) {
    85.  
    86. this.describe = describe;
    87.  
    88. }
    89.  
    90.  
    91.  
    92. public String getDescribe() {
    93.  
    94. return describe;
    95.  
    96. }
    97.  
    98.  
    99.  
    100. public void setDescribe(String describe) {
    101.  
    102. this.describe = describe;
    103.  
    104. }
    105.  
    106.  
    107.  
    108. }

    1.2 构建定时任务的抽象类

    我们需要构建不同的定时类型，不同的定时类型需要的参数也是不同的，因此我们需要抽象出定时的公用参数，将不同的参数多态实现

    1. /**
    3. * 构建定时任务基础对象
    5. * @author jiangwei
    7. *
    9. */
    10.  
    11. public class TaskInfo {
    12.  
    13.  
    14.  
    15. /**
    17. * 该定时的任务处理器
    19. */
    20.  
    21. private Classextends QuartzTaskJob> taskClass;
    22.  
    23.  
    24.  
    25. /**
    27. * 任务名
    29. */
    30.  
    31. private String taskName;
    32.  
    33. /**
    35. * 任务组名
    37. * */
    38.  
    39. private String groupName;
    40.  
    41.  
    42.  
    43. /**
    45. * 任务描述
    47. * */
    48.  
    49. private String description;
    50.  
    51.  
    52.  
    53.  
    54.  
    55. /**
    57. * 任务类型
    59. */
    60.  
    61. private TriggerType type;
    62.  
    63.  
    64.  
    65.  
    66.  
    67. /**
    69. * 任务参数,可在具体的QuartzTaskJob实现中获取这些参数
    71. * */
    72.  
    73. private Map param;
    74.  
    75.  
    76.  
    77. /**
    79. * 任务状态
    81. * */
    82.  
    83. private String taskStatus;
    84.  
    85.  
    86.  
    87. public TaskInfo(Class taskClass, String taskName, String groupName, String description, TriggerType type, Map param) {
    88.  
    89. this.taskClass = taskClass;
    90.  
    91. this.taskName = taskName;
    92.  
    93. this.groupName = groupName;
    94.  
    95. this.description = description;
    96.  
    97. this.type = type;
    98.  
    99. this.param = param;
    100.  
    101. }
    102.  
    103.  
    104.  
    105. public TaskInfo(Class taskClass, String taskName, String groupName, String description, TriggerType type) {
    106.  
    107. this.taskClass = taskClass;
    108.  
    109. this.taskName = taskName;
    110.  
    111. this.groupName = groupName;
    112.  
    113. this.description = description;
    114.  
    115. this.type = type;
    116.  
    117. }
    118.  
    119.  
    120.  
    121. public Classextends QuartzTaskJob> getTaskClass() {
    122.  
    123. return taskClass;
    124.  
    125. }
    126.  
    127.  
    128.  
    129. public void setTaskClass(Class taskClass) {
    130.  
    131. this.taskClass = taskClass;
    132.  
    133. }
    134.  
    135.  
    136.  
    137. public String getTaskName() {
    138.  
    139. return taskName;
    140.  
    141. }
    142.  
    143.  
    144.  
    145. public void setTaskName(String taskName) {
    146.  
    147. this.taskName = taskName;
    148.  
    149. }
    150.  
    151.  
    152.  
    153. public String getGroupName() {
    154.  
    155. return groupName;
    156.  
    157. }
    158.  
    159.  
    160.  
    161. public void setGroupName(String groupName) {
    162.  
    163. this.groupName = groupName;
    164.  
    165. }
    166.  
    167.  
    168.  
    169. public String getDescription() {
    170.  
    171. return description;
    172.  
    173. }
    174.  
    175.  
    176.  
    177. public void setDescription(String description) {
    178.  
    179. this.description = description;
    180.  
    181. }
    182.  
    183.  
    184.  
    185. public TriggerType getType() {
    186.  
    187. return type;
    188.  
    189. }
    190.  
    191.  
    192.  
    193. public void setType(TriggerType type) {
    194.  
    195. this.type = type;
    196.  
    197. }
    198.  
    199.  
    200.  
    201. public Map getParam() {
    202.  
    203. return param;
    204.  
    205. }
    206.  
    207.  
    208.  
    209. public void setParam(Map param) {
    210.  
    211. this.param = param;
    212.  
    213. }
    214.  
    215.  
    216.  
    217. public String getTaskStatus() {
    218.  
    219. return taskStatus;
    220.  
    221. }
    222.  
    223.  
    224.  
    225. public void setTaskStatus(String taskStatus) {
    226.  
    227. this.taskStatus = taskStatus;
    228.  
    229. }
    230.  
    231. }

    1.3 用以构建CRON定时任务

    1. /**
    3. * 用以构建CRON定时任务
    5. * cron触发器
    7. * @author jiangwei
    9. *
    11. */
    12.  
    13. public class CronInfo extends TaskInfo{
    14.  
    15. /**
    17. * cron表达式
    19. * */
    20.  
    21. private String cronExpression;
    22.  
    23.  
    24.  
    25. public CronInfo(Class taskClass, String taskName, String groupName, String description,
    27. Map param,String cronExpression) {
    28.  
    29. super(taskClass, taskName, groupName, description, TriggerType.CRON, param);
    30.  
    31. this.cronExpression = cronExpression;
    32.  
    33. }
    34.  
    35.  
    36.  
    37. public CronInfo(Class taskClass, String taskName, String groupName,
    39. String description,String cronExpression) {
    40.  
    41. super(taskClass, taskName, groupName, description, TriggerType.CRON);
    42.  
    43. this.cronExpression = cronExpression;
    44.  
    45. }
    46.  
    47.  
    48.  
    49. public String getCronExpression() {
    50.  
    51. return cronExpression;
    52.  
    53. }
    54.  
    55.  
    56.  
    57. public void setCronExpression(String cronExpression) {
    58.  
    59. this.cronExpression = cronExpression;
    60.  
    61. }
    62.  
    63.  
    64.  
    65.  
    66.  
    67. }

    1.4 用以构建固定间隔定时任务

    1. /**
    3. * 用以构建固定间隔定时任务
    5. * @author jiangwei
    7. *
    9. */
    10.  
    11. public class IntervalInfo extends TaskInfo{
    12.  
    13. /**
    15. * 事件间隔，根据TriggerType确定单位，除了数值为毫秒，该数值必须在-2^32~2^31 (-2147483648 ~ 2147483647)
    17. * */
    18.  
    19. private Long interval;
    20.  
    21.  
    22.  
    23. /**
    25. * 重复次数，会执行该数值+1次,为空无限重复
    27. * */
    28.  
    29. private Integer repeatCount;
    30.  
    31.  
    32.  
    33. public IntervalInfo(Class taskClass, String taskName, String groupName, String description,
    35. TriggerType type, Map param, Long interval,Integer repeatCount) {
    36.  
    37. super(taskClass, taskName, groupName, description, type, param);
    38.  
    39. if (type != TriggerType.INTERVAL_MILLISECOND){
    40.  
    41. if (interval<(-2^32)||interval>(2^31)){
    42.  
    43. throw new TaskException("interval超出范围，除了类型为INTERVAL_MILLISECOND的数据间隔定时的interval范围必须在-2^32~2^31 (-2147483648 ~ 2147483647)");
    44.  
    45. }
    46.  
    47. }
    48.  
    49. this.interval = interval;
    50.  
    51. this.repeatCount = repeatCount;
    52.  
    53. }
    54.  
    55.  
    56.  
    57. public IntervalInfo(Class taskClass, String taskName, String groupName, String description, TriggerType type, Long interval,Integer repeatCount) {
    58.  
    59. super(taskClass, taskName, groupName, description, type);
    60.  
    61. if (type != TriggerType.INTERVAL_MILLISECOND){
    62.  
    63. if (interval<(-2^32)||interval>(2^31)){
    64.  
    65. throw new TaskException("interval超出范围，除了类型为INTERVAL_MILLISECOND的数据间隔定时的interval范围必须在-2^32~2^31 (-2147483648 ~ 2147483647)");
    66.  
    67. }
    68.  
    69. }
    70.  
    71. this.interval = interval;
    72.  
    73. this.repeatCount = repeatCount;
    74.  
    75. }
    76.  
    77.  
    78.  
    79. public Long getInterval() {
    80.  
    81. return interval;
    82.  
    83. }
    84.  
    85.  
    86.  
    87. public void setInterval(Long interval) {
    88.  
    89. this.interval = interval;
    90.  
    91. }
    92.  
    93.  
    94.  
    95. public Integer getRepeatCount() {
    96.  
    97. return repeatCount;
    98.  
    99. }
    100.  
    101.  
    102.  
    103. public void setRepeatCount(Integer repeatCount) {
    104.  
    105. this.repeatCount = repeatCount;
    106.  
    107. }
    108.  
    109.  
    110.  
    111.  
    112.  
    113. }

    2.抽象任务类

    1. /**
    3. * 抽象任务类
    5. * @author jiangwei
    7. *
    9. */
    10.  
    11. public interface QuartzTaskJob extends Job{
    12.  
    13.  
    14.  
    15. /**
    17. * 执行定时任务
    19. */
    20.  
    21. @Override
    22.  
    23. void execute(JobExecutionContext context) throws JobExecutionException;
    24.  
    25.  
    26.  
    27. }

    2.1 实现一个测试任务

    1. /**
    3. * 实现一个测试任务
    5. * @author jiangwei
    7. *
    9. */
    10.  
    11. @Component
    12.  
    13. public class TestQuartz implements QuartzTaskJob{
    14.  
    15.  
    16.  
    17. private Logger log=LoggerFactory.getLogger(TestQuartz.class);
    18.  
    19.  
    20.  
    21. @Override
    22.  
    23. public void execute(JobExecutionContext context) throws JobExecutionException {
    24.  
    25. // 获取参数
    26.  
    27. JobDataMap jobDataMap = context.getTrigger().getJobDataMap();
    28.  
    29. // 获取任务名
    30.  
    31. String name = context.getJobDetail().getJobBuilder().build().getKey().getName();
    32.  
    33. // 获取任务分组
    34.  
    35. String group = context.getJobDetail().getJobBuilder().build().getKey().getGroup();
    36.  
    37. // 获取任务描述
    38.  
    39. String description = context.getJobDetail().getDescription();
    40.  
    41. if (context.getTrigger() instanceof SimpleTrigger){
    42.  
    43. // 运行次数
    44.  
    45. System.out.println(((SimpleTrigger)context.getTrigger()).getTimesTriggered());
    46.  
    47. }
    48.  
    49. log.info("----------------------" +
    50.  
    51. "\n任务组:{}\n任务名:{}\n任务描述:{}\n获取参数paramKey:{}\n" +
    52.  
    53. "----------------------"
    54.  
    55. ,name,group,description,jobDataMap.getString("paramKey"));
    56.  
    57.  
    58.  
    59. try {
    60.  
    61. // QuartzJobManager.getInstance().jobdelete(this.getClass().getSimpleName(),"ah");//执行完此任务就删除自己
    62.  
    63. } catch (Exception e) {
    64.  
    65. e.printStackTrace();
    66.  
    67. }
    68.  
    69. }
    70.  
    71. }

    3. 构建触发器的不同实现

    3.1 抽象触发器实现

    1. /**
    3. * 触发器工厂
    5. *
    7. * @author jiangwei
    9. *
    11. */
    12.  
    13. public interface ITriggerFactory {
    14.  
    15.  
    16.  
    17.  
    18.  
    19. /**
    21. * 判断是否为该类型的触发器
    23. *
    25. * @param triggerType 触发器类型
    27. * @return boolean 如果是该类型的触发器返回true 否则返回false
    29. */
    30.  
    31. public boolean check(TriggerType triggerType);
    32.  
    33.  
    34.  
    35. /**
    37. * 创建触发器
    39. * @param taskInfo：定时任务基础信息
    41. * @return Trigger
    43. */
    44.  
    45. public Trigger build(TaskInfo taskInfo);
    46.  
    47.  
    48.  
    49. }

    3.2 CRON触发器

    1. /**
    3. *
    5. * CRON触发器
    7. *
    9. * @author jiangwei
    11. *
    13. */
    14.  
    15. @Component
    16.  
    17. public class CronTrigger implements ITriggerFactory{
    18.  
    19.  
    20.  
    21. @Override
    22.  
    23. public boolean check(TriggerType triggerType) {
    24.  
    25. return triggerType==TriggerType.CRON;
    26.  
    27. }
    28.  
    29.  
    30.  
    31. @Override
    32.  
    33. public Trigger build(TaskInfo taskInfo) {
    34.  
    35. if (!(taskInfo instanceof CronInfo)){
    36.  
    37. throw new TaskException("构建类型为CRON定时必须传入CronTimingModel.class的实现类");
    38.  
    39. }
    40.  
    41. //按新的cronExpression表达式构建一个新的trigger
    42.  
    43. CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(((CronInfo) taskInfo).getCronExpression());
    44.  
    45. return TriggerBuilder.newTrigger().withIdentity(taskInfo.getTaskName(), taskInfo.getTaskName())
    46.  
    47. .withSchedule(scheduleBuilder).build();
    48.  
    49. }
    50.  
    51.  
    52.  
    53. }

    3.3 固定间隔触发器

    1. /**
    3. *
    5. * 固定间隔触发器
    7. *
    9. * @author jiangwei
    11. *
    13. */
    14.  
    15. @Component
    16.  
    17. public class IntervalTrigger implements ITriggerFactory{
    18.  
    19.  
    20.  
    21. @Override
    22.  
    23. public boolean check(TriggerType triggerType) {
    24.  
    25. return triggerType == TriggerType.INTERVAL_MINUTE || triggerType == TriggerType.INTERVAL_SECOND || triggerType == TriggerType.INTERVAL_MILLISECOND||triggerType == TriggerType.INTERVAL_HOUR;
    26.  
    27. }
    28.  
    29.  
    30.  
    31. @Override
    32.  
    33. public Trigger build(TaskInfo taskInfo) {
    34.  
    35. if (!(taskInfo instanceof IntervalInfo)){
    36.  
    37. throw new TaskException("构建类型为INTERVAL定时必须传入IntervalTimingMode.class的实现类");
    38.  
    39. }
    40.  
    41. //创建触发器
    42.  
    43. SimpleScheduleBuilder simpleScheduleBuilder = SimpleScheduleBuilder.simpleSchedule();
    44.  
    45. Long interval = ((IntervalInfo) taskInfo).getInterval();
    46.  
    47. Integer repeatCount = ((IntervalInfo) taskInfo).getRepeatCount();
    48.  
    49. switch (taskInfo.getType()){
    50.  
    51. case INTERVAL_MINUTE:
    52.  
    53. simpleScheduleBuilder.withIntervalInMinutes(Math.toIntExact(interval));
    54.  
    55. break;
    56.  
    57. case INTERVAL_HOUR:
    58.  
    59. simpleScheduleBuilder.withIntervalInHours(Math.toIntExact(interval));
    60.  
    61. break;
    62.  
    63. case INTERVAL_SECOND:
    64.  
    65. simpleScheduleBuilder.withIntervalInSeconds(Math.toIntExact(interval));
    66.  
    67. break;
    68.  
    69. case INTERVAL_MILLISECOND:
    70.  
    71. simpleScheduleBuilder.withIntervalInMilliseconds(interval);
    72.  
    73. break;
    74.  
    75. default:
    76.  
    77. break;
    78.  
    79. }
    80.  
    81. if (repeatCount==null){
    82.  
    83. // 无限重复
    84.  
    85. simpleScheduleBuilder.repeatForever();
    86.  
    87. }else {
    88.  
    89. simpleScheduleBuilder.withRepeatCount(repeatCount);
    90.  
    91. }
    92.  
    93. return TriggerBuilder.newTrigger().withIdentity(taskInfo.getTaskName(), taskInfo.getTaskName())
    94.  
    95. .withSchedule(simpleScheduleBuilder).build();
    96.  
    97. }
    98.  
    99.  
    100.  
    101. }

    3.4 构建触发器工厂

    1. /**
    3. *
    5. * 构建触发器工厂
    7. * 触发器管理器, 用来生成触发器
    9. *
    11. * @author jiangwei
    13. *
    15. */
    16.  
    17. @Component
    18.  
    19. public class TriggerManager {
    20.  
    21.  
    22.  
    23. private final List triggerFactories;
    24.  
    25.  
    26.  
    27. public TriggerManager(List triggerFactories) {
    28.  
    29. this.triggerFactories = triggerFactories;
    30.  
    31. }
    32.  
    33.  
    34.  
    35. /**
    37. * 生成对应的触发器
    39. *
    41. * @param timingModel 触发器model
    43. * @return org.quartz.Trigger
    45. * @author YuanXiaohan
    47. * @date 2021/12/16 2:53 下午
    49. */
    50.  
    51. public Trigger build(TaskInfo taskInfo) {
    52.  
    53. for (ITriggerFactory triggerFactory : triggerFactories) {
    54.  
    55. if (triggerFactory.check(taskInfo.getType())) {
    56.  
    57. return triggerFactory.build(taskInfo);
    58.  
    59. }
    60.  
    61. }
    62.  
    63. return null;
    64.  
    65. }
    66.  
    67.  
    68.  
    69. }

    3. 构建定时管理类

    1. /**
    3. * 构建定时管理类
    5. *
    7. * 添加定时
    9. * 更新定时触发器
    11. * 更新任务参数
    13. * 删除任务
    15. * 暂停任务
    17. * 将暂停的任务恢复执行
    19. * 启动所有任务
    21. * 关闭定时任务
    23. * 获取所有任务
    25. * @author jiangwei
    27. *
    29. */
    30.  
    31. @Configuration
    32.  
    33. public class QuartzTaskManager {
    34.  
    35.  
    36.  
    37. private Logger log=LoggerFactory.getLogger(QuartzTaskManager.class);
    38.  
    39.  
    40.  
    41. private final Scheduler scheduler;
    42.  
    43.  
    44.  
    45. private final Boolean initStatus;
    46.  
    47.  
    48.  
    49. private final TriggerManager triggerManager;
    50.  
    51.  
    52.  
    53. private static QuartzTaskManager taskManager;
    54.  
    55.  
    56.  
    57. public QuartzTaskManager(Scheduler scheduler, TriggerManager triggerManager) {
    58.  
    59. this.scheduler = scheduler;
    60.  
    61. taskManager = this;
    62.  
    63. boolean status = true;
    64.  
    65. try {
    66.  
    67. // 启动调度器
    68.  
    69. scheduler.start();
    70.  
    71. } catch (SchedulerException e) {
    72.  
    73. log.error("定时器调度器启动失败，定时器不可用！", e);
    74.  
    75. status = false;
    76.  
    77. }
    78.  
    79. initStatus = status;
    80.  
    81. this.triggerManager = triggerManager;
    82.  
    83. }
    84.  
    85.  
    86.  
    87. public static QuartzTaskManager getInstance(){
    88.  
    89. return taskManager;
    90.  
    91. }
    92.  
    93.  
    94.  
    95.  
    96.  
    97. /**
    99. * 添加定时任务
    101. *
    103. * @param timingModel 任务model
    105. */
    106.  
    107. public void addTask(TaskInfo taskInfo) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
    108.  
    109. InstantiationException, SchedulerException {
    110.  
    111. checkTimingInit();
    112.  
    113. // 构建任务信息
    114.  
    115. JobDetail jobDetail = JobBuilder.newJob(taskInfo.getTaskClass().getDeclaredConstructor().newInstance().getClass())
    116.  
    117. .withDescription(taskInfo.getDescription())
    118.  
    119. .withIdentity(taskInfo.getTaskName(), taskInfo.getGroupName())
    120.  
    121. .build();
    122.  
    123.  
    124.  
    125. // 构建触发器
    126.  
    127. Trigger trigger = triggerManager.build(taskInfo);
    128.  
    129. // 将任务参数放入触发器中
    130.  
    131. if (taskInfo.getParam() != null && !taskInfo.getParam().isEmpty()) {
    132.  
    133. trigger.getJobDataMap().putAll(taskInfo.getParam());
    134.  
    135. }
    136.  
    137. // 启动任务
    138.  
    139. scheduler.scheduleJob(jobDetail, trigger);
    140.  
    141. }
    142.  
    143.  
    144.  
    145. /**
    147. * 更新任务，任务的标示（由taskName和groupName组成）不变，任务的触发器（触发频率）发生变化
    149. *
    151. * @param timingModel 任务model
    153. */
    154.  
    155. public void updateTask(TaskInfo taskInfo) throws SchedulerException {
    156.  
    157. // 获取到任务
    158.  
    159. TriggerKey triggerKey = TriggerKey.triggerKey(taskInfo.getTaskName(), taskInfo.getGroupName());
    160.  
    161.  
    162.  
    163. // 构建触发器
    164.  
    165. Trigger trigger = triggerManager.build(taskInfo);
    166.  
    167. // 将任务参数放入触发器中
    168.  
    169. if (taskInfo.getParam() != null && !taskInfo.getParam().isEmpty()) {
    170.  
    171. trigger.getJobDataMap().putAll(taskInfo.getParam());
    172.  
    173. }
    174.  
    175. // 将新的触发器绑定到任务标示上重新执行
    176.  
    177. scheduler.rescheduleJob(triggerKey, trigger);
    178.  
    179. }
    180.  
    181.  
    182.  
    183. /**
    185. * 更新任务参数
    187. *
    189. * @param taskName 任务名
    191. * @param groupName 任务组名
    193. * @param param 参数
    195. */
    196.  
    197. public void updateTask(String taskName, String groupName, Map param) throws SchedulerException {
    198.  
    199. // 获取到任务
    200.  
    201. TriggerKey triggerKey = TriggerKey.triggerKey(taskName, groupName);
    202.  
    203. Trigger trigger = scheduler.getTrigger(triggerKey);
    204.  
    205.  
    206.  
    207. //修改参数
    208.  
    209. trigger.getJobDataMap().putAll(param);
    210.  
    211.  
    212.  
    213. // 将新的触发器绑定到任务标示上重新执行
    214.  
    215. scheduler.rescheduleJob(triggerKey, trigger);
    216.  
    217. }
    218.  
    219.  
    220.  
    221. /**
    223. * 删除任务
    225. *
    227. * @param taskName 任务名
    229. * @param groupName 任务组
    231. */
    232.  
    233. public void deleteTask(String taskName, String groupName) throws SchedulerException {
    234.  
    235. // 暂停任务对应的触发器
    236.  
    237. scheduler.pauseTrigger(TriggerKey.triggerKey(taskName, groupName));
    238.  
    239. // 删除任务对应的触发器
    240.  
    241. scheduler.unscheduleJob(TriggerKey.triggerKey(taskName, groupName));
    242.  
    243. // 删除任务
    244.  
    245. scheduler.deleteJob(JobKey.jobKey(taskName, groupName));
    246.  
    247. }
    248.  
    249.  
    250.  
    251. /**
    253. * 暂停任务
    255. *
    257. * @param taskName 添加任务时timingMode中的taskName
    259. * @param groupName 添加任务时timingMode中的groupName
    261. */
    262.  
    263. public void pauseTask(String taskName, String groupName) throws SchedulerException {
    264.  
    265. scheduler.pauseJob(JobKey.jobKey(taskName, groupName));
    266.  
    267. }
    268.  
    269.  
    270.  
    271.  
    272.  
    273. /**
    275. * 将暂停的任务恢复执行
    277. *
    279. * @param taskName 添加任务时timingMode中的taskName
    281. * @param groupName 添加任务时timingMode中的groupName
    283. */
    284.  
    285. public void resumeTask(String taskName, String groupName) throws SchedulerException {
    286.  
    287. scheduler.resumeJob(JobKey.jobKey(taskName, groupName));
    288.  
    289. }
    290.  
    291.  
    292.  
    293. /**
    295. * 启动所有任务
    297. *
    299. */
    300.  
    301. public void startAllTasks() {
    302.  
    303. try {
    304.  
    305. scheduler.start();
    306.  
    307. } catch (Exception e) {
    308.  
    309. throw new RuntimeException(e);
    310.  
    311. }
    312.  
    313. }
    314.  
    315.  
    316.  
    317. /**
    319. * 关闭定时任务，回收所有的触发器资源
    321. *
    323. */
    324.  
    325. public void shutdownAllTasks() {
    326.  
    327. try {
    328.  
    329. if (!scheduler.isShutdown()) {
    330.  
    331. scheduler.shutdown();
    332.  
    333. }
    334.  
    335. } catch (Exception e) {
    336.  
    337. throw new RuntimeException(e);
    338.  
    339. }
    340.  
    341. }
    342.  
    343.  
    344.  
    345.  
    346.  
    347. /**
    349. * 获取所有的任务,暂时无法获取到任务执行类和任务描述
    351. *
    353. * @return java.util.List
    355. * @author YuanXiaohan
    357. * @date 2021/12/16 3:37 下午
    359. */
    360.  
    361. public List getTaskList() throws SchedulerException {
    362.  
    363. GroupMatcher matcher = GroupMatcher.anyJobGroup();
    364.  
    365. Set jobKeys = scheduler.getJobKeys(matcher);
    366.  
    367. List taskList = new ArrayList();
    368.  
    369. for (JobKey jobKey : jobKeys) {
    370.  
    371. Listextends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
    372.  
    373. for (Trigger trigger : triggers) {
    374.  
    375. TaskInfo taskInfo;
    376.  
    377. if (trigger instanceof CronTrigger) {
    378.  
    379. taskInfo = new CronInfo(null, jobKey.getName(), jobKey.getGroup(), null, ((CronTrigger) trigger).getCronExpression());
    380.  
    381. taskInfo.setTaskStatus(scheduler.getTriggerState(trigger.getKey()).name());
    382.  
    383. taskList.add(taskInfo);
    384.  
    385. } else {
    386.  
    387. log.warn("name:{},group:{}的定时任务类型未知，请拓展QuartzTaskManager.getTaskList的任务类型解析", jobKey.getName(), jobKey.getGroup());
    388.  
    389. }
    390.  
    391. }
    392.  
    393. }
    394.  
    395. return taskList;
    396.  
    397. }
    398.  
    399.  
    400.  
    401.  
    402.  
    403. /**
    405. * 校验定时调度器是否初始化完成
    407. */
    408.  
    409. private void checkTimingInit() {
    410.  
    411. if (!initStatus) {
    412.  
    413. throw new TaskException("定时器未初始化，添加定时器失败!");
    414.  
    415. }
    416.  
    417. }
    418.  
    419.  
    420.  
    421. }

    4. Quartz注入到SpringBoot

    1. /**
    3. * Quartz注入到SpringBoot
    5. * @author jiangwei
    7. *
    9. */
    10.  
    11. @Component
    12.  
    13. public class TaskJobFactory extends AdaptableJobFactory{
    14.  
    15.  
    16.  
    17. private final AutowireCapableBeanFactory capableBeanFactory;
    18.  
    19.  
    20.  
    21. public TaskJobFactory(AutowireCapableBeanFactory capableBeanFactory) {
    22.  
    23. this.capableBeanFactory = capableBeanFactory;
    24.  
    25. }
    26.  
    27.  
    28.  
    29. @Override
    30.  
    31. protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
    32.  
    33. //调用父类的方法
    34.  
    35. Object jobInstance = super.createJobInstance(bundle);
    36.  
    37. //进行注入
    38.  
    39. capableBeanFactory.autowireBean(jobInstance);
    40.  
    41. return jobInstance;
    42.  
    43. }
    44.  
    45.  
    46.  
    47. }

    5. 执行

    1. public class JwbastaThymeleafAdminApplicaiton implements CommandLineRunner{
    2.  
    3.  
    4.  
    5. private static Logger logger=LoggerFactory.getLogger(JwbastaThymeleafAdminApplicaiton.class);
    6.  
    7.  
    8.  
    9. public static void main(String[] args) {
    10.  
    11. SpringApplication.run(JwbastaThymeleafAdminApplicaiton.class, args);
    12.  
    13. }
    14.  
    15.  
    16.  
    17. }
    18.  
    19.  
    20.  
    21. @Override
    22.  
    23. public void run(String... args) throws Exception {
    24.  
    25. //构建CRON定时
    26.  
    27. //CronTimingModel cronTimingModel = new CronTimingModel(TestQuartz.class, "测试名", "测试组", "测试描述", "*/1 * * * * ?");
    28.  
    29. // 构建固定间隔定时
    30.  
    31. IntervalInfo intervalTimingMode = new IntervalInfo(TestQuartz.class, "测试名", "测试组", "测试描述", TriggerType.INTERVAL_SECOND, 5L,null);
    32.  
    33. HashMap param = new HashMap<>();
    34.  
    35. param.put("paramKey","获取到参数了");
    36.  
    37. intervalTimingMode.setParam(param);
    38.  
    39. QuartzTaskManager.getInstance().addTask(intervalTimingMode);
    40.  
    41. }
    42.  
    43.  
    44.  
    45. }

    jwbasta官网

  • 相关阅读:
    【pandas小技巧】--修改列的名称
    Lua中如何实现类似gdb的断点调试--05优化断点信息数据结构
    VUE之旅—day3
    王道数据结构课后代码题p150 15.设有一棵满二叉树(所有结点值均不同)，已知其先序序列为 pre，设计一个算法求其后序序列post。（c语言代码实现）
    poj 2182 Lost Cows （树状数组 || 线段树）
    如何解决AI场景下的冯诺伊曼陷阱？
    DiagnosisPrintDialog 使用广播导致关闭不了的问题
    LeetCode 775. 全局倒置与局部倒置
    手机厂商“互卷”之年：“机海战术”失灵，“慢节奏”打法崛起
    R语言读取（加载）txt格式数据为dataframe、为dataframe中的两个离散变量构建列联表
  • 原文地址：https://blog.csdn.net/xiaowei20091124/article/details/126778764