• springboot之quartz动态可控定时任务

    Quartz

            Quartz是一个开源的任务调度框架，可以用来实现定时任务的调度，如定时发送邮件、定时备份数据等。Quartz具有很高的可靠性和灵活性，支持集群部署和分布式调度，并且提供了丰富的API和插件，可以轻松实现复杂的调度需求。Quartz的工作原理是通过Job和Trigger两个核心概念来实现的，Job是具体需要执行的任务，Trigger用来触发任务的执行时机。在Quartz中，可以通过定义各种Trigger来实现不同的调度策略，如简单调度、Cron调度等。Quartz还提供了很多内置的Job和Trigger实现，如邮件发送、HTTP请求等，可以方便地用来实现常见的任务调度需求。

     核心

            Quartz的核心组件包含Scheduler、Job和Trigger。这三个核心组件共同组成了Quartz的任务调度机制，使得开发人员可以通过配置简单的定时任务来实现复杂的调度策略。

    Scheduler

            是Quartz的核心组件，它负责调度和执行任务。Scheduler有一个任务管理器，负责维护任务列表，并根据Triggers的定义来决定何时执行任务。Scheduler还提供了API，通过API可以动态地添加、删除和修改任务。

    1. 管理作业：Scheduler负责管理Quartz中的所有作业，包括创建、修改和删除作业。

    2. 触发器管理：Scheduler负责管理Quartz中的所有触发器，包括创建、修改和删除触发器。

    3. 作业执行：Scheduler负责执行Quartz中的所有作业，并记录作业执行情况。

    4. 调度管理：Scheduler负责管理Quartz的整个调度过程，包括启动调度器、暂停调度器和恢复调度器。

    5. 监控和统计：Scheduler提供了各种监控和统计信息，以帮助开发人员了解Quartz的运行状况。

    Job

            Job是一个接口，它定义了需要执行的逻辑，开发人员需要实现该接口，并在其中编写需要执行的业务逻辑。

    Trigger

            Trigger是一个定义了任务执行时间的对象，Quartz提供了多种类型的Trigger，例如

    1. SimpleTrigger：简单触发器，用于在指定时间执行一次或者按照指定的时间间隔重复执行。

    2. CronTrigger：Cron触发器，用于按照类似于Unix/Linux系统中Cron表达式的方式指定复杂的时间计划，例如每周五下午五点执行。

    3. CalendarIntervalTrigger：日历间隔触发器，用于按照在指定时间间隔内执行的时间计划，例如每隔一小时执行一次。

    4. DailyTimeIntervalTrigger：每日时间间隔触发器，用于按照每日指定时间间隔执行的时间计划，例如每天上午10点和下午3点各执行一次。

      实战

        我这里采用jdk17   Springboot3.1.2+mybatis-flex+openapi3与mysql来实现一个动态控制任务的demo

    1. <properties>
    2.         <java.version>17java.version>
    3.         <mybatis-flex.version>1.7.2mybatis-flex.version>
    4.         <fastjson.version>1.2.47fastjson.version>
    5. properties>
    6.  
    7. <dependencyManagement>
    8.         <dependencies>
    9.             <dependency>
    10.                 <groupId>com.github.xiaoymingroupId>
    11.                 <artifactId>knife4j-dependenciesartifactId>
    12.                 <version>4.1.0version>
    13.                 <type>pomtype>
    14.                 <scope>importscope>
    15.             dependency>
    16.         dependencies>
    17.     dependencyManagement>
    18.     <dependencies>
    19.         <dependency>
    20.             <groupId>org.springframework.bootgroupId>
    21.             <artifactId>spring-boot-starter-webartifactId>
    22.         dependency>
    23.         <dependency>
    24.             <groupId>com.github.xiaoymingroupId>
    25.             <artifactId>knife4j-openapi3-jakarta-spring-boot-starterartifactId>
    26.         dependency>
    27.  
    28.         <dependency>
    29.             <groupId>com.mysqlgroupId>
    30.             <artifactId>mysql-connector-jartifactId>
    31.             <scope>runtimescope>
    32.         dependency>
    33.         <dependency>
    34.             <groupId>org.projectlombokgroupId>
    35.             <artifactId>lombokartifactId>
    36.             <optional>trueoptional>
    37.         dependency>
    38.         
    39.        
    40.         <dependency>
    41.             <groupId>org.springframework.bootgroupId>
    42.             <artifactId>spring-boot-starter-jdbcartifactId>
    43.         dependency>
    44.         <dependency>
    45.             <groupId>org.springframework.bootgroupId>
    46.             <artifactId>spring-boot-starter-quartzartifactId>
    47.         dependency>
    48.         <dependency>
    49.             <groupId>com.mybatis-flexgroupId>
    50.             <artifactId>mybatis-flex-spring-boot-starterartifactId>
    51.             <version>${mybatis-flex.version}version>
    52.         dependency>
    53.         <dependency>
    54.             <groupId>com.alibabagroupId>
    55.             <artifactId>fastjsonartifactId>
    56.             <version>${fastjson.version}version>
    57.         dependency>
    58.     dependencies>
    1. mybatis-flex:
    2.   datasource:
    3.     ds1:
    4.       url: jdbc:mysql://127.0.0.1:3306/test
    5.       username: root
    6.       password: zkb.com
    7. springdoc:
    8.   swagger-ui:
    9.     path: /swagger-ui.html
    10.     tags-sorter: alpha
    11.   api-docs:
    12.     path: /v3/api-docs
    13.   group-configs:
    14.     - group: '接口'
    15.       paths-to-match: '/**'
    16.       packages-to-scan: com.zxs.springbootmybatisflex.controller.client
    17.   default-flat-param-object: true
    18.  
    1. package com.zxs.springbootmybatisflex.quartz;
    2.  
    3. import com.zxs.springbootmybatisflex.entity.SysJob;
    4. import com.zxs.springbootmybatisflex.zenum.JobEnum;
    5. import org.quartz.Job;
    6. import org.quartz.JobExecutionContext;
    7.  
    8. public class QuartzJob implements Job {
    9.  
    10.     @Override
    11.     public void execute(JobExecutionContext context) {
    12.         SysJob sysJob = (SysJob) context.getJobDetail().getJobDataMap().get(JobEnum.Key.getCode());
    13.         QuartzUtil.runJob(sysJob.getInvokeTarget());
    14.     }
    15. }
    16.  
    1. package com.zxs.springbootmybatisflex.quartz;
    2.  
    3. import com.zxs.springbootmybatisflex.entity.JobVo;
    4. import com.zxs.springbootmybatisflex.entity.SysJob;
    5. import com.zxs.springbootmybatisflex.uitl.SpringContextHolder;
    6. import com.zxs.springbootmybatisflex.zenum.ActionEnum;
    7. import com.zxs.springbootmybatisflex.zenum.JobEnum;
    8. import lombok.SneakyThrows;
    9. import org.quartz.*;
    10. import org.springframework.util.ObjectUtils;
    11.  
    12. import java.lang.reflect.Method;
    13. import java.util.Date;
    14.  
    15. public class QuartzUtil {
    16.  
    17.     @SneakyThrows
    18.     public static void startJob(SysJob sysJob) {
    19.         // 获取调度器 Scheduler
    20.         Scheduler scheduler = SchedulerStatic.getScheduler();
    21.         Integer jobId = sysJob.getJobId();
    22.         String jobGroup = sysJob.getJobGroup();
    23.  
    24.         // 构造一个job
    25.         JobKey jobKey = JobKey.jobKey(jobId.toString(), jobGroup);
    26.         JobDetail jobDetail = JobBuilder
    27.                 .newJob(QuartzJob.class)
    28.                 .withIdentity(jobKey)
    29.                 .build();
    30.  
    31.         // 构造cron调度器
    32.         CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule(sysJob.getCronExpression());
    33.         getMisfirePolicy(sysJob, cronScheduleBuilder);
    34.  
    35.         // 构造触发器 trigger
    36.         TriggerKey triggerKey = TriggerKey.triggerKey(jobId.toString(), jobGroup);
    37.         CronTrigger trigger = TriggerBuilder
    38.                 .newTrigger()
    39.                 .withIdentity(triggerKey)
    40.                 .withSchedule(cronScheduleBuilder)
    41.                 .build();
    42.  
    43.         // 放入job信息,为后续执行改任务的具体方法做铺垫(需要反射调用), 在execute中获取并应用
    44.         jobDetail.getJobDataMap().put(JobEnum.Key.getCode(), sysJob);
    45.         // 判断该任务是否存在,修改任务,先删除然后添加
    46.         if (scheduler.checkExists(jobKey)) {
    47.             // 防止创建时存在数据问题 先移除，然后在执行创建操作
    48.             scheduler.deleteJob(jobKey);
    49.         }
    50.         // 判断任务是否过期
    51.         CronExpression cron = new CronExpression(sysJob.getCronExpression());
    52.         Date nextValidTimeAfter = cron.getNextValidTimeAfter(new Date(System.currentTimeMillis()));
    53.         if (!ObjectUtils.isEmpty(nextValidTimeAfter)) {
    54.             // 执行调度任务
    55.             scheduler.scheduleJob(jobDetail, trigger);
    56.         }
    57.     }
    58.  
    59.  
    60.     @SneakyThrows
    61.     public static void doJob(JobVo sysJob,String action) {
    62.         // 获取调度器 Scheduler
    63.         Scheduler scheduler = SchedulerStatic.getScheduler();
    64.         // 构造一个job
    65.         JobKey jobKey = JobKey.jobKey(sysJob.getJobId().toString(), sysJob.getJobGroup());
    66.         // 判断该任务是否存在,修改任务,先删除然后添加
    67.         if (!scheduler.checkExists(jobKey)) {
    68.             return;
    69.         }
    70.         switch (action){
    71.             case ActionEnum.check:    //
    72.                 System.out.println(true);
    73.                 break;
    74.             case ActionEnum.pause:   //暂停
    75.                 scheduler.pauseJob(jobKey);
    76.                 break;
    77.             case ActionEnum.resume:   //继续
    78.                 scheduler.resumeJob(jobKey);
    79.                 break;
    80.             case ActionEnum.delete:    //删除
    81.                 scheduler.deleteJob(jobKey);
    82.                 break;
    83.             default:
    84.                 scheduler.checkExists(jobKey);
    85.                 break;
    86.         }
    87.  
    88.     }
    89.  
    90.     private static void getMisfirePolicy(SysJob sysJob, CronScheduleBuilder cronScheduleBuilder) {
    91.         String s= sysJob.getMisfirePolicy();
    92.         if(s.equals(JobEnum.MISFIRE_DEFAULT.getCode())){
    93.         }else if(s.equals(JobEnum.MISFIRE_IGNORE.getCode())){
    94.             cronScheduleBuilder.withMisfireHandlingInstructionIgnoreMisfires();
    95.         } else if(s.equals(JobEnum.MISFIRE_FIRE_AND_PROCEED.getCode())){
    96.             cronScheduleBuilder.withMisfireHandlingInstructionFireAndProceed();
    97.         } else if(s.equals(JobEnum.MISFIRE_DO_NOTHING.getCode())){
    98.             cronScheduleBuilder.withMisfireHandlingInstructionDoNothing();
    99.         }else{
    100.             throw new RuntimeException("The task misfire policy '" + sysJob.getMisfirePolicy() + "' cannot be used in cron schedule tasks");
    101.         }
    102.     }
    103.  
    104.     public static void invokeMethod(Object bean, String methodName) throws Exception {
    105.         Method method = bean.getClass().getMethod(methodName);
    106.         method.invoke(bean);
    107.     }
    108.     public static void runJob(String invokeTarget){
    109.         String[] parts = invokeTarget.split("\\.");
    110.         String beanName = parts[0];
    111.         String methodName = parts[1];
    112.         Object bean = SpringContextHolder.getBean(beanName);
    113.         try {
    114.             QuartzUtil.invokeMethod(bean, methodName);
    115.         } catch (Exception e) {
    116.             throw new RuntimeException("Error running job", e);
    117.         }
    118.     }
    119.  
    120.  
    121. }
    1. package com.zxs.springbootmybatisflex.quartz;
    2.  
    3. import org.quartz.Scheduler;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.stereotype.Component;
    6.  
    7. @Component
    8. public class SchedulerStatic {
    9.  
    10.     private static Scheduler scheduler;
    11.  
    12.     @Autowired
    13.     public SchedulerStatic(Scheduler scheduler) {
    14.         SchedulerStatic.scheduler = scheduler;
    15.     }
    16.  
    17.     public static Scheduler getScheduler() {
    18.         return scheduler;
    19.     }
    20. }
    1. package com.zxs.springbootmybatisflex.config;
    2.  
    3. import org.springframework.cache.annotation.EnableCaching;
    4. import org.springframework.context.annotation.Configuration;
    5.  
    6. @EnableCaching
    7. @Configuration
    8. public class CacheConfig {
    9. }
    1. package com.zxs.springbootmybatisflex.config;
    2.  
    3. import com.mybatisflex.core.mybatis.FlexConfiguration;
    4. import com.mybatisflex.spring.boot.ConfigurationCustomizer;
    5. import org.apache.ibatis.logging.stdout.StdOutImpl;
    6. import org.springframework.context.annotation.Configuration;
    7.  
    8. @Configuration
    9. public class MyConfigurationCustomizer implements ConfigurationCustomizer {
    10.  
    11.     @Override
    12.     public void customize(FlexConfiguration configuration) {
    13.         configuration.setLogImpl(StdOutImpl.class);
    14.     }
    15. }
    1. package com.zxs.springbootmybatisflex.config;
    2.  
    3. import com.github.xiaoymin.knife4j.spring.annotations.EnableKnife4j;
    4. import io.swagger.v3.oas.models.OpenAPI;
    5. import io.swagger.v3.oas.models.info.Info;
    6. import io.swagger.v3.oas.models.info.License;
    7. import org.springframework.context.annotation.Bean;
    8. import org.springframework.context.annotation.Configuration;
    9.  
    10. @Configuration
    11. @EnableKnife4j
    12. public class SwaggerConfig {
    13.     // 设置 openapi 基础参数
    14.     @Bean
    15.     public OpenAPI customOpenAPI() {
    16.         return new OpenAPI()
    17.                 .info(new Info()
    18.                         .title("zxs API 管理")
    19.                         .version("1.0")
    20.                         .description("探索mybatis-flex与quartz demo")
    21.                         .license(new License().name("Apache 2.0")));
    22.     }
    23. }
    1. package com.zxs.springbootmybatisflex.controller.client;
    2.  
    3.  
    4. import com.zxs.springbootmybatisflex.entity.JobVo;
    5. import com.zxs.springbootmybatisflex.entity.SysJob;
    6. import com.zxs.springbootmybatisflex.quartz.QuartzUtil;
    7. import com.zxs.springbootmybatisflex.service.SysJobService;
    8. import com.zxs.springbootmybatisflex.uitl.DataResult;
    9. import com.zxs.springbootmybatisflex.zenum.ActionEnum;
    10. import io.swagger.v3.oas.annotations.Operation;
    11. import io.swagger.v3.oas.annotations.tags.Tag;
    12. import jakarta.annotation.Resource;
    13. import org.springframework.util.ObjectUtils;
    14. import org.springframework.web.bind.annotation.*;
    15.  
    16. import java.util.List;
    17.  
    18. /**
    19.  * 定时任务调度表(SysJob)表控制层
    20.  *
    21.  * @author makejava
    22.  * @since 2023-10-19 09:17:58
    23.  */
    24. @RestController
    25. @Tag(name = "任务中心")
    26. @RequestMapping("sysJob")
    27. public class SysJobController {
    28.     /**
    29.      * 服务对象
    30.      */
    31.     @Resource
    32.     private SysJobService sysJobService;
    33.  
    34.  
    35.  
    36.  
    37.     @Operation(summary = "获取任务列表", description = "获取任务列表")
    38.     @PostMapping("/getJobList")
    39.     public DataResult<SysJob>> getJobList() {
    40.         DataResult<SysJob>> result = new DataResult<>();
    41.         List<SysJob> list =sysJobService.list();
    42.         result.setData(list);
    43.         return result;
    44.     }
    45.  
    46.     @Operation(summary = "根据主键获取任务信息")
    47.     @PostMapping("/getJobById/{id}")
    48.     public DataResult<SysJob> getJobById(@PathVariable(value = "id") Integer id) {
    49.         DataResult<SysJob> result = new DataResult<>();
    50.         result.setData(sysJobService.getById(id));
    51.         return result;
    52.     }
    53.     @PostMapping("/saveJob")
    54.     @Operation(summary="新增/修改任务",description="新增/修改任务,并加入的调度器中执行")
    55.     public  DataResult<Boolean> saveJob(SysJob sysJob) {
    56.         DataResult<Boolean> result = new DataResult<>();
    57.         result.setData(sysJobService.saveOrUpdate(sysJob));
    58.         QuartzUtil.startJob(sysJob);
    59.         return result;
    60.     }
    61.  
    62.     @PostMapping("/deleteJob/{id}")
    63.     @Operation(summary="删除任务",description="删除任务,并删除调度器中执行的该任务")
    64.     public DataResult<Boolean> deleteJob(@PathVariable(value = "id") Integer id) {
    65.         DataResult<Boolean> result = new DataResult<>();
    66.         SysJob sysJob = sysJobService.getById(id);
    67.         boolean data = this.sysJobService.removeById(id);
    68.         result.setData(data);
    69.         if(!ObjectUtils.isEmpty(sysJob)) {
    70.             JobVo jobVo = new JobVo();
    71.             jobVo.setJobId(sysJob.getJobId());
    72.             jobVo.setJobGroup(sysJob.getJobGroup());
    73.             QuartzUtil.doJob(jobVo, ActionEnum.delete);
    74.         }
    75.         return result;
    76.     }
    77.  
    78.  
    79.     @GetMapping("/getJobAndJoin/{id}")
    80.     @Operation(summary="开启/关闭任务",description="获取一个任务,修改任务,并加入/丢出的调度器中执行")
    81.     public DataResult<SysJob> getJobAndJoin(@PathVariable(value = "id") Integer id) {
    82.         DataResult<SysJob> result = new DataResult<>();
    83.         SysJob one = sysJobService.getById(id);
    84.         if("0".equals(one.getStatus())){
    85.             one.setStatus("1");
    86.         }else{
    87.             one.setStatus("0");
    88.         }
    89.         sysJobService.updateById(one);
    90.         QuartzUtil.startJob(one);
    91.         result.setData(one);
    92.         return result;
    93.     }
    94.  
    95.  
    96.  
    97.     @PostMapping("/runJob")
    98.     @Operation(summary="手动执行任务",description="手动执行任务")
    99.     public DataResult<Boolean> runJob(String invokeTarget) {
    100.         DataResult<Boolean> result = new DataResult<>();
    101.         QuartzUtil.runJob(invokeTarget);
    102.         return result;
    103.     }
    104.  
    105.  
    106.  
    107.     @PostMapping("/checkJob")
    108.     @Operation(summary="检查任务",description="检测任务")
    109.     public  DataResult<Boolean> checkJob(JobVo jobVo) {
    110.         DataResult<Boolean> result = new DataResult<>();
    111.         QuartzUtil.doJob(jobVo,ActionEnum.check);
    112.         return result;
    113.     }
    114.  
    115.     @PostMapping("/resumeJob")
    116.     @Operation(summary="恢复任务",description="恢复任务")
    117.     public  DataResult<Boolean> resumeJob(JobVo sysJob) {
    118.         DataResult<Boolean> result = new DataResult<>();
    119.         QuartzUtil.doJob(sysJob,ActionEnum.resume);
    120.         return result;
    121.     }
    122.  
    123.     @PostMapping("/pauseJob")
    124.     @Operation(summary="暂停任务",description="暂停任务")
    125.     public  DataResult<Boolean> pauseJob(JobVo sysJob) {
    126.         DataResult<Boolean> result = new DataResult<>();
    127.         QuartzUtil.doJob(sysJob,ActionEnum.pause);
    128.         return result;
    129.     }
    130.  
    131. }
    132.  
    1. package com.zxs.springbootmybatisflex.dao;
    2.  
    3.  
    4. import com.mybatisflex.core.BaseMapper;
    5. import com.zxs.springbootmybatisflex.entity.SysJob;
    6. import org.apache.ibatis.annotations.Mapper;
    7.  
    8. /**
    9.  * 定时任务调度表(SysJob)表数据库访问层
    10.  *
    11.  * @author makejava
    12.  * @since 2023-10-19 09:17:58
    13.  */
    14. @Mapper
    15. public interface SysJobDao extends BaseMapper<SysJob> {
    16.  
    17. }
    18.  
    1. package com.zxs.springbootmybatisflex.entity;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.io.Serializable;
    6.  
    7. @Data
    8. public class JobVo implements Serializable {
    9.     private Integer jobId;
    10.     private String jobGroup;
    11. }
    1. package com.zxs.springbootmybatisflex.entity;
    2.  
    3.  
    4. import com.fasterxml.jackson.annotation.JsonFormat;
    5. import com.mybatisflex.annotation.Id;
    6. import com.mybatisflex.annotation.KeyType;
    7. import com.mybatisflex.annotation.Table;
    8. import com.mybatisflex.core.activerecord.Model;
    9. import io.swagger.v3.oas.annotations.media.Schema;
    10. import lombok.Data;
    11.  
    12. import java.util.Date;
    13.  
    14. /**
    15.  * 定时任务调度表(SysJob)表实体类
    16.  *
    17.  * @author makejava
    18.  * @since 2023-10-19 09:17:59
    19.  */
    20. @Data
    21. @Schema(description="定时任务调度表")
    22. @Table("sys_job")
    23. public class SysJob extends Model<SysJob> {
    24.  
    25. 	@Schema(description="任务ID")
    26.     @Id(keyType = KeyType.Auto)
    27.     private Integer jobId;
    28.  
    29.  
    30. 	@Schema(description="任务名称")
    31.     private String jobName;
    32.  
    33.  
    34. 	@Schema(description="任务组名")
    35.     private String jobGroup;
    36.  
    37.  
    38. 	@Schema(description="调用目标字符串")
    39.     private String invokeTarget;
    40.  
    41.  
    42. 	@Schema(description="cron执行表达式")
    43.     private String cronExpression;
    44.  
    45.  
    46. 	@Schema(description="计划执行错误策略（1立即执行 2执行一次 3放弃执行）")
    47.     private String misfirePolicy;
    48.  
    49.  
    50. 	@Schema(description="是否并发执行（0允许 1禁止）")
    51.     private String concurrent;
    52.  
    53.  
    54. 	@Schema(description="状态（0正常 1暂停）")
    55.     private String status;
    56.  
    57.  
    58. 	@Schema(description="创建者")
    59.     private String createBy;
    60.  
    61.  
    62. 	@Schema(description="创建时间")
    63.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    64.     private Date createTime;
    65.  
    66.  
    67. 	@Schema(description="更新者")
    68.     private String updateBy;
    69.  
    70.  
    71. 	@Schema(description="更新时间")
    72.     @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    73.     private Date updateTime;
    74.  
    75.  
    76. 	@Schema(description="备注信息")
    77.     private String remark;
    78.  
    79.  
    80. 	@Schema(description="0-正常，1-删除")
    81.     private Integer deleteStatus;
    82.  
    83. }
    84.  
    1. package com.zxs.springbootmybatisflex.exception.code;
    2.  
    3.  
    4. public enum BaseResponseCode implements ResponseCodeInterface {
    5.     /**
    6.      * 这个要和前段约定好
    7.      * 引导用户去登录界面的
    8.      * code=401001 引导用户重新登录
    9.      * code=401002 token 过期刷新token
    10.      * code=401008 无权限访问
    11.      */
    12.     SUCCESS(200,"操作成功"),
    13.     SYSTEM_BUSY(500001, "系统繁忙，请稍候再试"),
    14.     OPERATION_ERRO(500002,"操作失败"),
    15.     METHODARGUMENTNOTVALIDEXCEPTION(500003, "方法参数校验异常"),
    16.     ;
    17.  
    18.     /**
    19.      * 错误码
    20.      */
    21.     private final int code;
    22.     /**
    23.      * 错误消息
    24.      */
    25.     private final String msg;
    26.  
    27.     BaseResponseCode(int code, String msg) {
    28.         this.code = code;
    29.         this.msg = msg;
    30.     }
    31.  
    32.     @Override
    33.     public int getCode() {
    34.         return code;
    35.     }
    36.  
    37.     @Override
    38.     public String getMsg() {
    39.         return msg;
    40.     }
    41. }
    1. package com.zxs.springbootmybatisflex.exception.code;
    2.  
    3.  
    4. public interface ResponseCodeInterface {
    5.     int getCode();
    6.  
    7.     String getMsg();
    8. }
    1. package com.zxs.springbootmybatisflex.exception.handler;
    2.  
    3.  
    4. import com.zxs.springbootmybatisflex.exception.BusinessException;
    5. import com.zxs.springbootmybatisflex.exception.code.BaseResponseCode;
    6. import com.zxs.springbootmybatisflex.uitl.DataResult;
    7. import lombok.extern.slf4j.Slf4j;
    8. import org.springframework.validation.ObjectError;
    9. import org.springframework.web.bind.MethodArgumentNotValidException;
    10. import org.springframework.web.bind.annotation.ExceptionHandler;
    11. import org.springframework.web.bind.annotation.RestControllerAdvice;
    12.  
    13. import java.util.List;
    14.  
    15.  
    16. @RestControllerAdvice
    17. @Slf4j
    18. public class RestExceptionHandler {
    19.  
    20.  
    21.     @ExceptionHandler(Exception.class)
    22.     public <T> DataResult<T> handleException(Exception e){
    23.         log.error("Exception,exception:{}", e);
    24.         return DataResult.getResult(BaseResponseCode.SYSTEM_BUSY);
    25.     }
    26.  
    27.  
    28.     @ExceptionHandler(value = BusinessException.class)
    29.     <T> DataResult<T> businessExceptionHandler(BusinessException e) {
    30.         log.error("BusinessException,exception:{}", e);
    31.         return new DataResult<>(e.getMessageCode(),e.getDetailMessage());
    32.     }
    33.  
    34.  
    35.     @ExceptionHandler(MethodArgumentNotValidException.class)
    36.     <T> DataResult<T> methodArgumentNotValidExceptionHandler(MethodArgumentNotValidException e) {
    37.         log.error("methodArgumentNotValidExceptionHandler bindingResult.allErrors():{},exception:{}", e.getBindingResult().getAllErrors(), e);
    38.         List<ObjectError> errors = e.getBindingResult().getAllErrors();
    39.         return createValidExceptionResp(errors);
    40.     }
    41.     private <T> DataResult<T> createValidExceptionResp(List<ObjectError> errors) {
    42.         String[] msgs = new String[errors.size()];
    43.         int i = 0;
    44.         for (ObjectError error : errors) {
    45.             msgs[i] = error.getDefaultMessage();
    46.             log.info("msg={}",msgs[i]);
    47.             i++;
    48.         }
    49.         return DataResult.getResult(BaseResponseCode.METHODARGUMENTNOTVALIDEXCEPTION.getCode(), msgs[0]);
    50.     }
    51. }
    1. package com.zxs.springbootmybatisflex.exception;
    2.  
    3.  
    4. import com.zxs.springbootmybatisflex.exception.code.ResponseCodeInterface;
    5.  
    6. public class BusinessException extends RuntimeException{
    7.     /**
    8.      * 异常编号
    9.      */
    10.     private final int messageCode;
    11.  
    12.     /**
    13.      * 对messageCode 异常信息进行补充说明
    14.      */
    15.     private final String detailMessage;
    16.  
    17.     public BusinessException(int messageCode,String message) {
    18.         super(message);
    19.         this.messageCode = messageCode;
    20.         this.detailMessage = message;
    21.     }
    22.     /**
    23.      * 构造函数
    24.      * @param code 异常码
    25.      */
    26.     public BusinessException(ResponseCodeInterface code) {
    27.         this(code.getCode(), code.getMsg());
    28.     }
    29.  
    30.     public int getMessageCode() {
    31.         return messageCode;
    32.     }
    33.  
    34.     public String getDetailMessage() {
    35.         return detailMessage;
    36.     }
    37. }
    1. package com.zxs.springbootmybatisflex.exception;
    2.  
    3.  
    4. import com.zxs.springbootmybatisflex.exception.code.ResponseCodeInterface;
    5.  
    6. public class RoleSaveException extends RuntimeException{
    7.     /**
    8.      * 异常编号
    9.      */
    10.     private final int messageCode;
    11.  
    12.     /**
    13.      * 对messageCode 异常信息进行补充说明
    14.      */
    15.     private final String detailMessage;
    16.  
    17.     public RoleSaveException(int messageCode, String message) {
    18.         super(message);
    19.         this.messageCode = messageCode;
    20.         this.detailMessage = message;
    21.     }
    22.     /**
    23.      * 构造函数
    24.      * @param code 异常码
    25.      */
    26.     public RoleSaveException(ResponseCodeInterface code) {
    27.         this(code.getCode(), code.getMsg());
    28.     }
    29.  
    30.     public int getMessageCode() {
    31.         return messageCode;
    32.     }
    33.  
    34.     public String getDetailMessage() {
    35.         return detailMessage;
    36.     }
    37. }
    1. package com.zxs.springbootmybatisflex.quartz.task;
    2.  
    3. import org.springframework.stereotype.Service;
    4.  
    5. @Service("task")
    6. public class DoTask {
    7.     public void sout() {
    8.         System.out.println("我是干输出的");
    9.     }
    10.     public void ceshi() {
    11.         System.out.println("我是干测试的");
    12.     }
    13.     public void buzhidao() {
    14.         System.out.println("我不知道干啥的");
    15.     }
    16.     public void dajiangyou() {
    17.         System.out.println("我是打酱油的");
    18.     }
    19.     public void chuiniu() {
    20.         System.out.println("我是吹牛的");
    21.     }
    22.  
    23.     public void maren() {
    24.         System.out.println("我是骂人的");
    25.     }
    26.     public void duiren() {
    27.         System.out.println("我是怼人的");
    28.     }
    29.     public void yaofan() {
    30.         System.out.println("我是要饭的");
    31.     }
    32.     public void chifan() {
    33.         System.out.println("我是吃饭的");
    34.     }
    35. }
    1. package com.zxs.springbootmybatisflex.service.impl;
    2.  
    3. import com.mybatisflex.spring.service.impl.ServiceImpl;
    4. import com.zxs.springbootmybatisflex.dao.SysJobDao;
    5. import com.zxs.springbootmybatisflex.entity.SysJob;
    6. import com.zxs.springbootmybatisflex.service.SysJobService;
    7. import org.springframework.stereotype.Service;
    8.  
    9. /**
    10.  * 定时任务调度表(SysJob)表服务实现类
    11.  *
    12.  * @author makejava
    13.  * @since 2023-10-19 09:17:59
    14.  */
    15. @Service
    16. public class SysJobServiceImpl extends ServiceImpl implements SysJobService {
    17.  
    18.  
    19. }
    20.  
    1. package com.zxs.springbootmybatisflex.service;
    2.  
    3. import com.mybatisflex.core.service.IService;
    4. import com.zxs.springbootmybatisflex.entity.SysJob;
    5.  
    6. /**
    7.  * 定时任务调度表(SysJob)表服务接口
    8.  *
    9.  * @author makejava
    10.  * @since 2023-10-19 09:17:59
    11.  */
    12. public interface SysJobService extends IService<SysJob> {
    13.  
    14. }
    15.  
    1. package com.zxs.springbootmybatisflex.uitl;
    2.  
    3. import com.zxs.springbootmybatisflex.exception.code.BaseResponseCode;
    4. import com.zxs.springbootmybatisflex.exception.code.ResponseCodeInterface;
    5. import lombok.Data;
    6.  
    7.  
    8. @Data
    9. public class DataResult<T>{
    10.  
    11.     /**
    12.      * 请求响应code，0为成功 其他为失败
    13.      */
    14.     private int code;
    15.  
    16.     /**
    17.      * 响应异常码详细信息
    18.      */
    19.     private String msg;
    20.  
    21.     /**
    22.      * 响应内容 ， code 0 时为 返回 数据
    23.      */
    24.     private T data;
    25.  
    26.     public DataResult(int code, T data) {
    27.         this.code = code;
    28.         this.data = data;
    29.         this.msg=null;
    30.     }
    31.  
    32.     public DataResult(int code, String msg, T data) {
    33.         this.code = code;
    34.         this.msg = msg;
    35.         this.data = data;
    36.     }
    37.  
    38.     public DataResult(int code, String msg) {
    39.         this.code = code;
    40.         this.msg = msg;
    41.         this.data=null;
    42.     }
    43.  
    44.  
    45.     public DataResult() {
    46.         this.code= BaseResponseCode.SUCCESS.getCode();
    47.         this.msg=BaseResponseCode.SUCCESS.getMsg();
    48.         this.data=null;
    49.     }
    50.  
    51.     public DataResult(T data) {
    52.         this.data = data;
    53.         this.code=BaseResponseCode.SUCCESS.getCode();
    54.         this.msg=BaseResponseCode.SUCCESS.getMsg();
    55.     }
    56.  
    57.     public DataResult(ResponseCodeInterface responseCodeInterface) {
    58.         this.data = null;
    59.         this.code = responseCodeInterface.getCode();
    60.         this.msg = responseCodeInterface.getMsg();
    61.     }
    62.  
    63.     public DataResult(ResponseCodeInterface responseCodeInterface, T data) {
    64.         this.data = data;
    65.         this.code = responseCodeInterface.getCode();
    66.         this.msg = responseCodeInterface.getMsg();
    67.     }
    68.  
    69.     public static <T>DataResult success(){
    70.         return new <T>DataResult();
    71.     }
    72.  
    73.     public static <T>DataResult success(T data){
    74.         return new <T>DataResult(data);
    75.     }
    76.  
    77.     public static <T>DataResult getResult(int code,String msg,T data){
    78.         return new <T>DataResult(code,msg,data);
    79.     }
    80.  
    81.     public static <T>DataResult getResult(int code,String msg){
    82.         return new <T>DataResult(code,msg);
    83.     }
    84.  
    85.     public static <T>DataResult getResult(BaseResponseCode responseCode){
    86.         return new <T>DataResult(responseCode);
    87.     }
    88.  
    89.     public static <T>DataResult getResult(BaseResponseCode responseCode,T data){
    90.  
    91.         return new <T>DataResult(responseCode,data);
    92.     }
    93. }
    1. package com.zxs.springbootmybatisflex.uitl;
    2.  
    3. import org.apache.commons.lang3.Validate;
    4. import org.slf4j.Logger;
    5. import org.slf4j.LoggerFactory;
    6. import org.springframework.beans.BeansException;
    7. import org.springframework.beans.factory.DisposableBean;
    8. import org.springframework.context.ApplicationContext;
    9. import org.springframework.context.ApplicationContextAware;
    10. import org.springframework.stereotype.Component;
    11.  
    12. @Component
    13. public class SpringContextHolder implements ApplicationContextAware, DisposableBean {
    14.  
    15. 	private static ApplicationContext applicationContext = null;
    16.  
    17. 	private static Logger logger = LoggerFactory.getLogger(SpringContextHolder.class);
    18.  
    19. 	/**
    20. 	 * 取得存储在静态变量中的ApplicationContext.
    21. 	 */
    22. 	public static ApplicationContext getApplicationContext() {
    23. 		assertContextInjected();
    24. 		return applicationContext;
    25. 	}
    26.  
    27. 	/**
    28. 	 * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
    29. 	 */
    30. 	@SuppressWarnings("unchecked")
    31. 	public static <T> T getBean(String name) {
    32. 		assertContextInjected();
    33. 		return (T) applicationContext.getBean(name);
    34. 	}
    35.  
    36. 	/**
    37. 	 * 从静态变量applicationContext中取得Bean, 自动转型为所赋值对象的类型.
    38. 	 */
    39. 	public static <T> T getBean(Class<T> requiredType) {
    40. 		assertContextInjected();
    41. 		return applicationContext.getBean(requiredType);
    42. 	}
    43.  
    44. 	/**
    45. 	 * 清除SpringContextHolder中的ApplicationContext为Null.
    46. 	 */
    47. 	public static void clearHolder() {
    48. 		logger.debug("清除SpringContextHolder中的ApplicationContext:"
    49. 				+ applicationContext);
    50. 		applicationContext = null;
    51. 	}
    52.  
    53. 	/**
    54. 	 * 实现ApplicationContextAware接口, 注入Context到静态变量中.
    55. 	 */
    56. 	@Override
    57. 	public void setApplicationContext(ApplicationContext applicationContext)throws BeansException {
    58. //		logger.debug("注入ApplicationContext到SpringContextHolder:{}", applicationContext);
    59.  
    60. 		if (SpringContextHolder.applicationContext != null) {
    61. 			logger.warn("SpringContextHolder中的ApplicationContext被覆盖, 原有ApplicationContext为:" + SpringContextHolder.applicationContext);
    62. 		}
    63.  
    64. 		SpringContextHolder.applicationContext = applicationContext; // NOSONAR
    65. 	}
    66.  
    67. 	/**
    68. 	 * 实现DisposableBean接口, 在Context关闭时清理静态变量.
    69. 	 */
    70. 	@Override
    71. 	public void destroy() throws Exception {
    72. 		SpringContextHolder.clearHolder();
    73. 	}
    74.  
    75. 	/**
    76. 	 * 检查ApplicationContext不为空.
    77. 	 */
    78. 	private static void assertContextInjected() {
    79. 		Validate.validState(applicationContext != null, "applicaitonContext属性未注入, 请在applicationContext.xml中定义SpringContextHolder.");
    80. 	}
    81. }
    1. package com.zxs.springbootmybatisflex.zenum;
    2.  
    3.  
    4. public interface ActionEnum {
    5.     String pause="pause";
    6.     String resume="resume";
    7.     String check="check";
    8.     String delete="delete";
    9.     String start="start";
    10. }
    1. package com.zxs.springbootmybatisflex.zenum;
    2.  
    3.  
    4. public enum JobEnum implements JobInterface {
    5.  
    6.     Key("jobkey"),
    7.     MISFIRE_DEFAULT("0"),
    8.     MISFIRE_IGNORE("1"),
    9.     MISFIRE_FIRE_AND_PROCEED("2"),
    10.     MISFIRE_DO_NOTHING("3"),
    11.     PAUSE("1"),
    12.     ;
    13.  
    14.  
    15.     private final String code;
    16.  
    17.  
    18.     JobEnum(String code) {
    19.         this.code = code;
    20.     }
    21.  
    22.     @Override
    23.     public String getCode() {
    24.         return code;
    25.     }
    26.  
    27. }
    1. package com.zxs.springbootmybatisflex.zenum;
    2.  
    3.  
    4. public interface JobInterface {
    5.     String getCode();
    6. }
    1. package com.zxs.springbootmybatisflex;
    2.  
    3. import org.mybatis.spring.annotation.MapperScan;
    4. import org.springframework.boot.SpringApplication;
    5. import org.springframework.boot.autoconfigure.SpringBootApplication;
    6.  
    7. @SpringBootApplication
    8. @MapperScan("com.zxs.springbootmybatisflex.dao")
    9. public class SpringbootMybatisFlexApplication {
    10.  
    11.     public static void main(String[] args) {
    12.         SpringApplication.run(SpringbootMybatisFlexApplication.class, args);
    13.     }
    14.  
    15.  
    16. }
    1. "1.0" encoding="UTF-8"?>
    2. mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    3. <mapper namespace="com.zxs.springbootmybatisflex.dao.SysJobDao">
    4.  
    5.     <resultMap type="com.zxs.springbootmybatisflex.entity.SysJob" id="SysJobMap">
    6.         <result property="jobId" column="job_id" jdbcType="INTEGER"/>
    7.         <result property="jobName" column="job_name" jdbcType="VARCHAR"/>
    8.         <result property="jobGroup" column="job_group" jdbcType="VARCHAR"/>
    9.         <result property="invokeTarget" column="invoke_target" jdbcType="VARCHAR"/>
    10.         <result property="cronExpression" column="cron_expression" jdbcType="VARCHAR"/>
    11.         <result property="misfirePolicy" column="misfire_policy" jdbcType="VARCHAR"/>
    12.         <result property="concurrent" column="concurrent" jdbcType="VARCHAR"/>
    13.         <result property="status" column="status" jdbcType="VARCHAR"/>
    14.         <result property="createBy" column="create_by" jdbcType="VARCHAR"/>
    15.         <result property="createTime" column="create_time" jdbcType="TIMESTAMP"/>
    16.         <result property="updateBy" column="update_by" jdbcType="VARCHAR"/>
    17.         <result property="updateTime" column="update_time" jdbcType="TIMESTAMP"/>
    18.         <result property="remark" column="remark" jdbcType="VARCHAR"/>
    19.         <result property="deleteStatus" column="delete_status" jdbcType="INTEGER"/>
    20.     resultMap>
    21.  
    22.  
    23. mapper>
    24.  

    1.  
    2. DROP TABLE IF EXISTS `sys_job`;
    3. CREATE TABLE `sys_job`  (
    4.   `job_id` int(6) NOT NULL AUTO_INCREMENT COMMENT '任务ID',
    5.   `job_name` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT '' COMMENT '任务名称',
    6.   `job_group` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT 'DEFAULT' COMMENT '任务组名',
    7.   `invoke_target` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL COMMENT '调用目标字符串',
    8.   `cron_expression` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '' COMMENT 'cron执行表达式',
    9.   `misfire_policy` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '3' COMMENT '计划执行错误策略（1立即执行 2执行一次 3放弃执行）',
    10.   `concurrent` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '1' COMMENT '是否并发执行（0允许 1禁止）',
    11.   `status` char(1) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '0' COMMENT '状态（0正常 1暂停）',
    12.   `create_by` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '' COMMENT '创建者',
    13.   `create_time` datetime(0) NULL DEFAULT NULL COMMENT '创建时间',
    14.   `update_by` varchar(64) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '' COMMENT '更新者',
    15.   `update_time` datetime(0) NULL DEFAULT CURRENT_TIMESTAMP(0) ON UPDATE CURRENT_TIMESTAMP(0) COMMENT '更新时间',
    16.   `remark` varchar(500) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT '' COMMENT '备注信息',
    17.   `delete_status` int(1) NOT NULL DEFAULT 0 COMMENT '0-正常，1-删除',
    18.   PRIMARY KEY (`job_id`) USING BTREE
    19. ) ENGINE = InnoDB AUTO_INCREMENT = 10 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '定时任务调度表' ROW_FORMAT = Dynamic;
    20.  
    21. -- ----------------------------
    22. -- Records of sys_job
    23. -- ----------------------------
    24. INSERT INTO `sys_job` VALUES (1, '输出任务', 'DEFAULT', 'task.sout', '0/3 * * * * ?', '3', '0', '0', 'admin', '2023-06-09 11:27:28', 'zxs', '2023-10-19 10:51:17', '', 0);
    25. INSERT INTO `sys_job` VALUES (2, '测试任务', 'DEFAULT', 'task.ceshi', '0/4 * * * * ?', '3', '0', '1', '', NULL, 'zxs', '2023-10-18 16:28:02', '', 0);
    26. INSERT INTO `sys_job` VALUES (3, '我不知道干啥的', 'DEFAULT', 'task.buzhidao', '0/5 * * * * ?', '3', '0', '1', 'zxs', '2023-10-18 14:48:40', '', '2023-10-18 16:28:04', '', 0);
    27. INSERT INTO `sys_job` VALUES (4, '打酱油', 'DEFAULT', 'task.dajiangyou', '0/6 * * * * ?', '3', '0', '1', 'zxs', '2023-10-18 14:49:20', 'zxs', '2023-10-18 16:28:06', '', 0);
    28. INSERT INTO `sys_job` VALUES (5, '吹牛', 'DEFAULT', 'task.chuiniu', '0/7 * * * * ?', '3', '0', '1', 'zxs', '2023-10-18 14:50:53', '', '2023-10-18 16:28:07', '', 0);
    29. INSERT INTO `sys_job` VALUES (6, '骂人', 'DEFAULT', 'task.maren', '0/8 * * * * ?', '3', '0', '1', 'zxs', '2023-10-18 14:51:28', '', '2023-10-18 16:28:09', '', 0);
    30. INSERT INTO `sys_job` VALUES (7, '怼人的', 'DEFAULT', 'task.duiren', '0/4 * * * * ?', '3', '0', '1', 'zxs', '2023-10-18 15:22:34', '', '2023-10-18 16:28:10', '', 0);
    31. INSERT INTO `sys_job` VALUES (8, '要饭的', 'DEFAULT', 'task.yaofan', '0/5 * * * * ?', '3', '0', '1', 'zxs', '2023-10-18 15:23:38', '', '2023-10-18 16:28:12', '', 0);
    32. INSERT INTO `sys_job` VALUES (9, '吃饭的', 'DEFAULT', 'task.chifan', '0/6 * * * * ?', '3', '0', '1', 'zxs', '2023-10-18 15:24:08', 'zxs', '2023-10-18 16:28:15', '哈哈哈哈0', 0);
    33.  
    34. SET FOREIGN_KEY_CHECKS = 1;

    以上就是一个完整的demo了

    运行之后访问http://127.0.0.1:8080/doc.html

     可以看到我们开放的api

    测试

     执行以上的sql，有可以看到我内置的一些拿来测试的任务

     然后我随便找一个任务开启

     当任务状态为0的时候，该任务就是正常的运行中的状态

     当然你也可以控制一下，当服务关闭时，去把所有为0状态重置为1，把任务关闭掉，或者当服务重启时，去初始化把状态为0的任务加入执行器中，不然每次重启，任务都不在执行器中与数据库的状态不一致

    例如：

    1. @PreDestroy
    2. 	public void stop() {
    3. 		stopTask();
    4. 	}
    5. 	public void stopTask() {
    6. 		List<SysJob> jobs = sysJobService.list().stream()
    7. 				.map(s -> {
    8. 					s.setStatus("1");
    9. 					return s;
    10. 				})
    11. 				.collect(Collectors.toList());
    12. 		sysJobService.saveOrUpdateBatch(jobs);
    13. 	}

     https://download.csdn.net/download/qq_14926283/88445520

  • 相关阅读:
    Vue学习之--------深入理解Vuex、原理详解、实战应用（2022/9/1）
    金融业信贷风控算法10-神经网络模型
    行走的数字
    【STL】vector常见用法及模拟实现(附源码）
    Databend 开源周报第112期
    Verilog HDL复习总结
    JUC并发编程第七篇，volatile凭什么可以保证可见性和有序性？我们该如何正确使用它？
    1740. 找到⼆叉树中的距离
    【算法中的Java】— 判断语句
    陈志泊主编《数据库原理及应用教程第4版微课版》的实验题目参考答案实验4
  • 原文地址：https://blog.csdn.net/qq_14926283/article/details/133918620