feat: 定时任务功能拆分

cutejava/cutejava-job/pom.xml

@@ -0,0 +1,37 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>cutejava</artifactId>
+        <groupId>cn.odboy</groupId>
+        <version>1.3.0</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>cutejava-job</artifactId>
+    <name>定时任务模块</name>
+
+    <dependencies>
+        <dependency>
+            <groupId>cn.odboy</groupId>
+            <artifactId>cutejava-tools</artifactId>
+            <version>1.3.0</version>
+        </dependency>
+
+        <!-- quartz -->
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-quartz</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.quartz-scheduler</groupId>
+            <artifactId>quartz-jobs</artifactId>
+            <version>2.3.2</version>
+        </dependency>
+        <dependency>
+            <groupId>com.mchange</groupId>
+            <artifactId>c3p0</artifactId>
+            <version>0.10.1</version>
+        </dependency>
+    </dependencies>
+</project>

cutejava/cutejava-job/src/main/java/cn/odboy/config/JobRunner.java

@@ -0,0 +1,33 @@
+package cn.odboy.config;
+
+import cn.odboy.mapper.QuartzJobMapper;
+import cn.odboy.domain.QuartzJob;
+import cn.odboy.util.QuartzManage;
+import lombok.RequiredArgsConstructor;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+@RequiredArgsConstructor
+public class JobRunner implements ApplicationRunner {
+    private static final Logger log = LoggerFactory.getLogger(JobRunner.class);
+    private final QuartzJobMapper quartzJobMapper;
+    private final QuartzManage quartzManage;
+
+    /**
+     * 项目启动时重新激活启用的定时任务
+     *
+     * @param applicationArguments /
+     */
+    @Override
+    public void run(ApplicationArguments applicationArguments) {
+        List<QuartzJob> quartzJobs = quartzJobMapper.findByIsPauseIsFalse();
+        quartzJobs.forEach(quartzManage::addJob);
+        log.info("Timing task injection complete");
+    }
+}

cutejava/cutejava-job/src/main/java/cn/odboy/config/QuartzConfig.java

@@ -0,0 +1,48 @@
+package cn.odboy.config;
+
+import lombok.extern.slf4j.Slf4j;
+import org.quartz.spi.TriggerFiredBundle;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.context.annotation.Scope;
+import org.springframework.lang.NonNull;
+import org.springframework.scheduling.quartz.AdaptableJobFactory;
+import org.springframework.stereotype.Component;
+
+/**
+ * 定时任务配置
+ */
+@Slf4j
+@Configuration
+@Scope("singleton")
+public class QuartzConfig {
+    /**
+     * 解决Job中注入Spring Bean为null的问题
+     */
+    @Component("quartzJobFactory")
+    public static class QuartzJobFactory extends AdaptableJobFactory {
+
+        private final AutowireCapableBeanFactory capableBeanFactory;
+
+        @Autowired
+        public QuartzJobFactory(AutowireCapableBeanFactory capableBeanFactory) {
+            this.capableBeanFactory = capableBeanFactory;
+        }
+
+        @NonNull
+        @Override
+        protected Object createJobInstance(@NonNull TriggerFiredBundle bundle) throws Exception {
+            try {
+                // 调用父类的方法，把Job注入到spring中
+                Object jobInstance = super.createJobInstance(bundle);
+                capableBeanFactory.autowireBean(jobInstance);
+                log.debug("Job instance created and autowired: {}", jobInstance.getClass().getName());
+                return jobInstance;
+            } catch (Exception e) {
+                log.error("Error creating job instance for bundle: {}", bundle, e);
+                throw e;
+            }
+        }
+    }
+}

cutejava/cutejava-job/src/main/java/cn/odboy/domain/QuartzJob.java

@@ -0,0 +1,67 @@
+package cn.odboy.domain;
+
+import cn.odboy.base.BaseEntity;
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Getter;
+import lombok.Setter;
+
+import javax.validation.constraints.NotBlank;
+import javax.validation.constraints.NotNull;
+
+
+@Getter
+@Setter
+@TableName("sys_quartz_job")
+public class QuartzJob extends BaseEntity {
+
+    public static final String JOB_KEY = "JOB_KEY";
+
+    @TableId(value = "job_id", type = IdType.AUTO)
+    @NotNull(groups = {Update.class})
+    private Long id;
+
+    @TableField(exist = false)
+    @ApiModelProperty(value = "用于子任务唯一标识", hidden = true)
+    private String uuid;
+
+    @ApiModelProperty(value = "定时器名称")
+    private String jobName;
+
+    @NotBlank
+    @ApiModelProperty(value = "Bean名称")
+    private String beanName;
+
+    @NotBlank
+    @ApiModelProperty(value = "方法名称")
+    private String methodName;
+
+    @ApiModelProperty(value = "参数")
+    private String params;
+
+    @NotBlank
+    @ApiModelProperty(value = "cron表达式")
+    private String cronExpression;
+
+    @ApiModelProperty(value = "状态，暂时或启动")
+    private Boolean isPause = false;
+
+    @ApiModelProperty(value = "负责人")
+    private String personInCharge;
+
+    @ApiModelProperty(value = "报警邮箱")
+    private String email;
+
+    @ApiModelProperty(value = "子任务")
+    private String subTask;
+
+    @ApiModelProperty(value = "失败后暂停")
+    private Boolean pauseAfterFailure;
+
+    @NotBlank
+    @ApiModelProperty(value = "备注")
+    private String description;
+}

cutejava/cutejava-job/src/main/java/cn/odboy/domain/QuartzLog.java

@@ -0,0 +1,47 @@
+package cn.odboy.domain;
+
+import cn.odboy.base.MyObject;
+import com.baomidou.mybatisplus.annotation.*;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+
+import java.sql.Timestamp;
+
+@Data
+@TableName("sys_quartz_log")
+@EqualsAndHashCode(callSuper = false)
+public class QuartzLog extends MyObject {
+
+    @TableId(value = "log_id", type = IdType.AUTO)
+    @ApiModelProperty(value = "ID", hidden = true)
+    private Long id;
+
+    @ApiModelProperty(value = "任务名称", hidden = true)
+    private String jobName;
+
+    @ApiModelProperty(value = "bean名称", hidden = true)
+    private String beanName;
+
+    @ApiModelProperty(value = "方法名称", hidden = true)
+    private String methodName;
+
+    @ApiModelProperty(value = "参数", hidden = true)
+    private String params;
+
+    @ApiModelProperty(value = "cron表达式", hidden = true)
+    private String cronExpression;
+
+    @ApiModelProperty(value = "状态", hidden = true)
+    private Boolean isSuccess;
+
+    @ApiModelProperty(value = "异常详情", hidden = true)
+    private String exceptionDetail;
+
+    @ApiModelProperty(value = "执行耗时", hidden = true)
+    private Long time;
+
+    @TableField(fill = FieldFill.INSERT)
+    @ApiModelProperty(value = "创建时间", hidden = true)
+    private Timestamp createTime;
+}

cutejava/cutejava-job/src/main/java/cn/odboy/domain/dto/QuartzJobQueryCriteria.java

@@ -0,0 +1,27 @@
+package cn.odboy.domain.dto;
+
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.sql.Timestamp;
+import java.util.List;
+
+
+@Data
+public class QuartzJobQueryCriteria {
+
+    @ApiModelProperty(value = "定时任务名称")
+    private String jobName;
+
+    @ApiModelProperty(value = "是否成功")
+    private Boolean isSuccess;
+
+    @ApiModelProperty(value = "创建时间")
+    private List<Timestamp> createTime;
+
+    @ApiModelProperty(value = "页码", example = "1")
+    private Integer page = 1;
+
+    @ApiModelProperty(value = "每页数据量", example = "10")
+    private Integer size = 10;
+}

cutejava/cutejava-job/src/main/java/cn/odboy/mapper/QuartzJobMapper.java

@@ -0,0 +1,21 @@
+package cn.odboy.mapper;
+
+import cn.odboy.domain.dto.QuartzJobQueryCriteria;
+import cn.odboy.domain.QuartzJob;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+@Mapper
+public interface QuartzJobMapper extends BaseMapper<QuartzJob> {
+
+    IPage<QuartzJob> findAll(@Param("criteria") QuartzJobQueryCriteria criteria, Page<Object> page);
+
+    List<QuartzJob> findAll(@Param("criteria") QuartzJobQueryCriteria criteria);
+
+    List<QuartzJob> findByIsPauseIsFalse();
+}

cutejava/cutejava-job/src/main/java/cn/odboy/mapper/QuartzLogMapper.java

@@ -0,0 +1,20 @@
+package cn.odboy.mapper;
+
+import cn.odboy.domain.dto.QuartzJobQueryCriteria;
+import cn.odboy.domain.QuartzLog;
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
+
+
+@Mapper
+public interface QuartzLogMapper extends BaseMapper<QuartzLog> {
+
+    IPage<QuartzLog> findAll(@Param("criteria") QuartzJobQueryCriteria criteria, Page<Object> page);
+
+    List<QuartzLog> findAll(@Param("criteria") QuartzJobQueryCriteria criteria);
+}

cutejava/cutejava-job/src/main/java/cn/odboy/rest/QuartzJobController.java

@@ -0,0 +1,125 @@
+package cn.odboy.rest;
+
+import cn.odboy.domain.QuartzJob;
+import cn.odboy.domain.QuartzLog;
+import cn.odboy.domain.dto.QuartzJobQueryCriteria;
+import cn.odboy.exception.BadRequestException;
+import cn.odboy.service.QuartzJobService;
+import cn.odboy.util.PageResult;
+import cn.odboy.util.SpringBeanHolder;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.validation.annotation.Validated;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.Set;
+
+
+@Slf4j
+@RestController
+@RequiredArgsConstructor
+@RequestMapping("/api/jobs")
+@Api(tags = "系统:定时任务管理")
+public class QuartzJobController {
+
+    private static final String ENTITY_NAME = "quartzJob";
+    private final QuartzJobService quartzJobService;
+
+    @ApiOperation("查询定时任务")
+    @GetMapping
+    @PreAuthorize("@el.check('timing:list')")
+    public ResponseEntity<PageResult<QuartzJob>> queryQuartzJob(QuartzJobQueryCriteria criteria) {
+        Page<Object> page = new Page<>(criteria.getPage(), criteria.getSize());
+        return new ResponseEntity<>(quartzJobService.queryAll(criteria, page), HttpStatus.OK);
+    }
+
+    @ApiOperation("导出任务数据")
+    @GetMapping(value = "/download")
+    @PreAuthorize("@el.check('timing:list')")
+    public void exportQuartzJob(HttpServletResponse response, QuartzJobQueryCriteria criteria) throws IOException {
+        quartzJobService.download(quartzJobService.queryAll(criteria), response);
+    }
+
+    @ApiOperation("导出日志数据")
+    @GetMapping(value = "/logs/download")
+    @PreAuthorize("@el.check('timing:list')")
+    public void exportQuartzJobLog(HttpServletResponse response, QuartzJobQueryCriteria criteria) throws IOException {
+        quartzJobService.downloadLog(quartzJobService.queryAllLog(criteria), response);
+    }
+
+    @ApiOperation("查询任务执行日志")
+    @GetMapping(value = "/logs")
+    @PreAuthorize("@el.check('timing:list')")
+    public ResponseEntity<PageResult<QuartzLog>> queryQuartzJobLog(QuartzJobQueryCriteria criteria) {
+        Page<Object> page = new Page<>(criteria.getPage(), criteria.getSize());
+        return new ResponseEntity<>(quartzJobService.queryAllLog(criteria, page), HttpStatus.OK);
+    }
+
+    @ApiOperation("新增定时任务")
+    @PostMapping
+    @PreAuthorize("@el.check('timing:add')")
+    public ResponseEntity<Object> createQuartzJob(@Validated @RequestBody QuartzJob resources) {
+        if (resources.getId() != null) {
+            throw new BadRequestException("A new " + ENTITY_NAME + " cannot already have an ID");
+        }
+        // 验证Bean是不是合法的，合法的定时任务 Bean 需要用 @Service 定义
+        checkBean(resources.getBeanName());
+        quartzJobService.create(resources);
+        return new ResponseEntity<>(HttpStatus.CREATED);
+    }
+
+    @ApiOperation("修改定时任务")
+    @PutMapping
+    @PreAuthorize("@el.check('timing:edit')")
+    public ResponseEntity<Object> updateQuartzJob(@Validated(QuartzJob.Update.class) @RequestBody QuartzJob resources) {
+        // 验证Bean是不是合法的，合法的定时任务 Bean 需要用 @Service 定义
+        checkBean(resources.getBeanName());
+        quartzJobService.update(resources);
+        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
+    }
+
+    @ApiOperation("更改定时任务状态")
+    @PutMapping(value = "/{id}")
+    @PreAuthorize("@el.check('timing:edit')")
+    public ResponseEntity<Object> updateQuartzJobStatus(@PathVariable Long id) {
+        quartzJobService.updateIsPause(quartzJobService.getById(id));
+        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
+    }
+
+    @ApiOperation("执行定时任务")
+    @PutMapping(value = "/exec/{id}")
+    @PreAuthorize("@el.check('timing:edit')")
+    public ResponseEntity<Object> executionQuartzJob(@PathVariable Long id) {
+        quartzJobService.execution(quartzJobService.getById(id));
+        return new ResponseEntity<>(HttpStatus.NO_CONTENT);
+    }
+
+    @ApiOperation("删除定时任务")
+    @DeleteMapping
+    @PreAuthorize("@el.check('timing:del')")
+    public ResponseEntity<Object> deleteQuartzJob(@RequestBody Set<Long> ids) {
+        quartzJobService.delete(ids);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    /**
+     * 验证Bean是不是合法的，合法的定时任务 Bean 需要用 @Service 定义
+     *
+     * @param beanName Bean名称
+     */
+    private void checkBean(String beanName) {
+        // 避免调用攻击者可以从SpringContextHolder获得控制jdbcTemplate类
+        // 并使用getDeclaredMethod调用jdbcTemplate的queryForMap函数，执行任意sql命令。
+        if (!SpringBeanHolder.getAllServiceBeanName().contains(beanName)) {
+            throw new BadRequestException("非法的 Bean，请重新输入！");
+        }
+    }
+}

cutejava/cutejava-job/src/main/java/cn/odboy/service/QuartzJobService.java

@@ -0,0 +1,112 @@
+package cn.odboy.service;
+
+import cn.odboy.domain.dto.QuartzJobQueryCriteria;
+import cn.odboy.domain.QuartzJob;
+import cn.odboy.domain.QuartzLog;
+import cn.odboy.util.PageResult;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.IService;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.List;
+import java.util.Set;
+
+
+public interface QuartzJobService extends IService<QuartzJob> {
+
+    /**
+     * 分页查询
+     *
+     * @param criteria 条件
+     * @param page     分页参数
+     * @return /
+     */
+    PageResult<QuartzJob> queryAll(QuartzJobQueryCriteria criteria, Page<Object> page);
+
+    /**
+     * 查询全部
+     *
+     * @param criteria 条件
+     * @return /
+     */
+    List<QuartzJob> queryAll(QuartzJobQueryCriteria criteria);
+
+    /**
+     * 分页查询日志
+     *
+     * @param criteria 条件
+     * @param page     分页参数
+     * @return /
+     */
+    PageResult<QuartzLog> queryAllLog(QuartzJobQueryCriteria criteria, Page<Object> page);
+
+    /**
+     * 查询全部
+     *
+     * @param criteria 条件
+     * @return /
+     */
+    List<QuartzLog> queryAllLog(QuartzJobQueryCriteria criteria);
+
+    /**
+     * 创建
+     *
+     * @param resources /
+     */
+    void create(QuartzJob resources);
+
+    /**
+     * 编辑
+     *
+     * @param resources /
+     */
+    void update(QuartzJob resources);
+
+    /**
+     * 删除任务
+     *
+     * @param ids /
+     */
+    void delete(Set<Long> ids);
+
+    /**
+     * 更改定时任务状态
+     *
+     * @param quartzJob /
+     */
+    void updateIsPause(QuartzJob quartzJob);
+
+    /**
+     * 立即执行定时任务
+     *
+     * @param quartzJob /
+     */
+    void execution(QuartzJob quartzJob);
+
+    /**
+     * 导出定时任务
+     *
+     * @param queryAll 待导出的数据
+     * @param response /
+     * @throws IOException /
+     */
+    void download(List<QuartzJob> queryAll, HttpServletResponse response) throws IOException;
+
+    /**
+     * 导出定时任务日志
+     *
+     * @param queryAllLog 待导出的数据
+     * @param response    /
+     * @throws IOException /
+     */
+    void downloadLog(List<QuartzLog> queryAllLog, HttpServletResponse response) throws IOException;
+
+    /**
+     * 执行子任务
+     *
+     * @param tasks /
+     * @throws InterruptedException /
+     */
+    void executionSubJob(String[] tasks) throws InterruptedException;
+}

cutejava/cutejava-job/src/main/java/cn/odboy/service/impl/QuartzJobServiceImpl.java

@@ -0,0 +1,172 @@
+package cn.odboy.service.impl;
+
+import cn.hutool.core.util.IdUtil;
+import cn.hutool.core.util.StrUtil;
+import cn.odboy.domain.dto.QuartzJobQueryCriteria;
+import cn.odboy.exception.BadRequestException;
+import cn.odboy.mapper.QuartzJobMapper;
+import cn.odboy.mapper.QuartzLogMapper;
+import cn.odboy.domain.QuartzJob;
+import cn.odboy.domain.QuartzLog;
+import cn.odboy.service.QuartzJobService;
+import cn.odboy.util.*;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import lombok.RequiredArgsConstructor;
+import org.quartz.CronExpression;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import javax.servlet.http.HttpServletResponse;
+import java.io.IOException;
+import java.util.*;
+
+@RequiredArgsConstructor
+@Service(value = "quartzJobService")
+public class QuartzJobServiceImpl extends ServiceImpl<QuartzJobMapper, QuartzJob> implements QuartzJobService {
+
+    private final QuartzJobMapper quartzJobMapper;
+    private final QuartzLogMapper quartzLogMapper;
+    private final QuartzManage quartzManage;
+    private final RedisUtil redisUtil;
+
+    @Override
+    public PageResult<QuartzJob> queryAll(QuartzJobQueryCriteria criteria, Page<Object> page) {
+        return PageUtil.toPage(quartzJobMapper.findAll(criteria, page));
+    }
+
+    @Override
+    public PageResult<QuartzLog> queryAllLog(QuartzJobQueryCriteria criteria, Page<Object> page) {
+        return PageUtil.toPage(quartzLogMapper.findAll(criteria, page));
+    }
+
+    @Override
+    public List<QuartzJob> queryAll(QuartzJobQueryCriteria criteria) {
+        return quartzJobMapper.findAll(criteria);
+    }
+
+    @Override
+    public List<QuartzLog> queryAllLog(QuartzJobQueryCriteria criteria) {
+        return quartzLogMapper.findAll(criteria);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void create(QuartzJob resources) {
+        if (!CronExpression.isValidExpression(resources.getCronExpression())) {
+            throw new BadRequestException("cron表达式格式错误");
+        }
+        save(resources);
+        quartzManage.addJob(resources);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void update(QuartzJob resources) {
+        if (!CronExpression.isValidExpression(resources.getCronExpression())) {
+            throw new BadRequestException("cron表达式格式错误");
+        }
+        if (StringUtil.isNotBlank(resources.getSubTask())) {
+            List<String> tasks = Arrays.asList(resources.getSubTask().split("[,，]"));
+            if (tasks.contains(resources.getId().toString())) {
+                throw new BadRequestException("子任务中不能添加当前任务ID");
+            }
+        }
+        saveOrUpdate(resources);
+        quartzManage.updateJobCron(resources);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void updateIsPause(QuartzJob quartzJob) {
+        // 置换暂停状态
+        if (quartzJob.getIsPause()) {
+            quartzManage.resumeJob(quartzJob);
+            quartzJob.setIsPause(false);
+        } else {
+            quartzManage.pauseJob(quartzJob);
+            quartzJob.setIsPause(true);
+        }
+        saveOrUpdate(quartzJob);
+    }
+
+    @Override
+    public void execution(QuartzJob quartzJob) {
+        quartzManage.runJobNow(quartzJob);
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void delete(Set<Long> ids) {
+        for (Long id : ids) {
+            QuartzJob quartzJob = getById(id);
+            quartzManage.deleteJob(quartzJob);
+            removeById(quartzJob);
+        }
+    }
+
+    @Override
+    @Transactional(rollbackFor = Exception.class)
+    public void executionSubJob(String[] tasks) throws InterruptedException {
+        for (String id : tasks) {
+            if (StrUtil.isBlank(id)) {
+                // 如果是手动清除子任务id，会出现id为空字符串的问题
+                continue;
+            }
+            QuartzJob quartzJob = getById(Long.parseLong(id));
+            // 执行任务
+            String uuid = IdUtil.simpleUUID();
+            quartzJob.setUuid(uuid);
+            // 执行任务
+            execution(quartzJob);
+            // 获取执行状态，如果执行失败则停止后面的子任务执行
+            Boolean result = redisUtil.get(uuid, Boolean.class);
+            while (result == null) {
+                // 休眠5秒，再次获取子任务执行情况
+                Thread.sleep(5000);
+                result = redisUtil.get(uuid, Boolean.class);
+            }
+            if (!result) {
+                redisUtil.del(uuid);
+                break;
+            }
+        }
+    }
+
+    @Override
+    public void download(List<QuartzJob> quartzJobs, HttpServletResponse response) throws IOException {
+        List<Map<String, Object>> list = new ArrayList<>();
+        for (QuartzJob quartzJob : quartzJobs) {
+            Map<String, Object> map = new LinkedHashMap<>();
+            map.put("任务名称", quartzJob.getJobName());
+            map.put("Bean名称", quartzJob.getBeanName());
+            map.put("执行方法", quartzJob.getMethodName());
+            map.put("参数", quartzJob.getParams());
+            map.put("表达式", quartzJob.getCronExpression());
+            map.put("状态", quartzJob.getIsPause() ? "暂停中" : "运行中");
+            map.put("描述", quartzJob.getDescription());
+            map.put("创建日期", quartzJob.getCreateTime());
+            list.add(map);
+        }
+        FileUtil.downloadExcel(list, response);
+    }
+
+    @Override
+    public void downloadLog(List<QuartzLog> queryAllLog, HttpServletResponse response) throws IOException {
+        List<Map<String, Object>> list = new ArrayList<>();
+        for (QuartzLog quartzLog : queryAllLog) {
+            Map<String, Object> map = new LinkedHashMap<>();
+            map.put("任务名称", quartzLog.getJobName());
+            map.put("Bean名称", quartzLog.getBeanName());
+            map.put("执行方法", quartzLog.getMethodName());
+            map.put("参数", quartzLog.getParams());
+            map.put("表达式", quartzLog.getCronExpression());
+            map.put("异常详情", quartzLog.getExceptionDetail());
+            map.put("耗时/毫秒", quartzLog.getTime());
+            map.put("状态", quartzLog.getIsSuccess() ? "成功" : "失败");
+            map.put("创建日期", quartzLog.getCreateTime());
+            list.add(map);
+        }
+        FileUtil.downloadExcel(list, response);
+    }
+}

cutejava/cutejava-job/src/main/java/cn/odboy/task/TestTask.java

@@ -0,0 +1,21 @@
+package cn.odboy.task;
+
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.stereotype.Service;
+
+@Slf4j
+@Service
+public class TestTask {
+
+    public void run() {
+        log.info("run 执行成功");
+    }
+
+    public void run1(String str) {
+        log.info("run1 执行成功，参数为： {}", str);
+    }
+
+    public void run2() {
+        log.info("run2 执行成功");
+    }
+}

cutejava/cutejava-job/src/main/java/cn/odboy/util/ExecutionJob.java

@@ -0,0 +1,115 @@
+package cn.odboy.util;
+
+import cn.hutool.extra.template.Template;
+import cn.hutool.extra.template.TemplateConfig;
+import cn.hutool.extra.template.TemplateEngine;
+import cn.hutool.extra.template.TemplateUtil;
+import cn.odboy.domain.dto.EmailDto;
+import cn.odboy.mapper.QuartzLogMapper;
+import cn.odboy.domain.QuartzJob;
+import cn.odboy.domain.QuartzLog;
+import cn.odboy.service.QuartzJobService;
+import cn.odboy.service.EmailService;
+import cn.odboy.util.RedisUtil;
+import cn.odboy.util.SpringBeanHolder;
+import cn.odboy.util.StringUtil;
+import cn.odboy.util.ThrowableUtil;
+import org.quartz.JobExecutionContext;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+import org.springframework.scheduling.quartz.QuartzJobBean;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.Future;
+
+public class ExecutionJob extends QuartzJobBean {
+
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    // 此处仅供参考，可根据任务执行情况自定义线程池参数
+    private final ThreadPoolTaskExecutor executor = SpringBeanHolder.getBean("taskAsync");
+
+    @Override
+    public void executeInternal(JobExecutionContext context) {
+        // 获取任务
+        QuartzJob quartzJob = (QuartzJob) context.getMergedJobDataMap().get(QuartzJob.JOB_KEY);
+        // 获取spring bean
+        QuartzLogMapper quartzLogMapper = SpringBeanHolder.getBean(QuartzLogMapper.class);
+        QuartzJobService quartzJobService = SpringBeanHolder.getBean(QuartzJobService.class);
+        RedisUtil redisUtil = SpringBeanHolder.getBean(RedisUtil.class);
+
+        String uuid = quartzJob.getUuid();
+
+        QuartzLog log = new QuartzLog();
+        log.setJobName(quartzJob.getJobName());
+        log.setBeanName(quartzJob.getBeanName());
+        log.setMethodName(quartzJob.getMethodName());
+        log.setParams(quartzJob.getParams());
+        long startTime = System.currentTimeMillis();
+        log.setCronExpression(quartzJob.getCronExpression());
+        try {
+            // 执行任务
+            QuartzRunnable task = new QuartzRunnable(quartzJob.getBeanName(), quartzJob.getMethodName(), quartzJob.getParams());
+            Future<?> future = executor.submit(task);
+            future.get();
+            long times = System.currentTimeMillis() - startTime;
+            log.setTime(times);
+            if (StringUtil.isNotBlank(uuid)) {
+                redisUtil.set(uuid, true);
+            }
+            // 任务状态
+            log.setIsSuccess(true);
+            logger.info("任务执行成功，任务名称：{}, 执行时间：{}毫秒", quartzJob.getJobName(), times);
+            // 判断是否存在子任务
+            if (StringUtil.isNotBlank(quartzJob.getSubTask())) {
+                String[] tasks = quartzJob.getSubTask().split("[,，]");
+                // 执行子任务
+                quartzJobService.executionSubJob(tasks);
+            }
+        } catch (Exception e) {
+            if (StringUtil.isNotBlank(uuid)) {
+                redisUtil.set(uuid, false);
+            }
+            logger.error("任务执行失败，任务名称：{}", quartzJob.getJobName());
+            long times = System.currentTimeMillis() - startTime;
+            log.setTime(times);
+            // 任务状态 0：成功 1：失败
+            log.setIsSuccess(false);
+            log.setExceptionDetail(ThrowableUtil.getStackTrace(e));
+            // 任务如果失败了则暂停
+            if (quartzJob.getPauseAfterFailure() != null && quartzJob.getPauseAfterFailure()) {
+                quartzJob.setIsPause(false);
+                //更新状态
+                quartzJobService.updateIsPause(quartzJob);
+            }
+            if (quartzJob.getEmail() != null) {
+                EmailService emailService = SpringBeanHolder.getBean(EmailService.class);
+                // 邮箱报警
+                if (StringUtil.isNoneBlank(quartzJob.getEmail())) {
+                    EmailDto emailDto = taskAlarm(quartzJob, ThrowableUtil.getStackTrace(e));
+                    emailService.send(emailDto, emailService.find());
+                }
+            }
+        } finally {
+            quartzLogMapper.insert(log);
+        }
+    }
+
+    private EmailDto taskAlarm(QuartzJob quartzJob, String msg) {
+        EmailDto emailDto = new EmailDto();
+        emailDto.setSubject("定时任务【" + quartzJob.getJobName() + "】执行失败，请尽快处理！");
+        Map<String, Object> data = new HashMap<>(16);
+        data.put("task", quartzJob);
+        data.put("msg", msg);
+        TemplateEngine engine = TemplateUtil.createEngine(new TemplateConfig("template", TemplateConfig.ResourceMode.CLASSPATH));
+        Template template = engine.getTemplate("taskAlarm.ftl");
+        emailDto.setContent(template.render(data));
+        List<String> emails = Arrays.asList(quartzJob.getEmail().split("[,，]"));
+        emailDto.setTos(emails);
+        return emailDto;
+    }
+}

cutejava/cutejava-job/src/main/java/cn/odboy/util/QuartzManage.java

@@ -0,0 +1,165 @@
+package cn.odboy.util;
+
+import cn.odboy.exception.BadRequestException;
+import cn.odboy.domain.QuartzJob;
+import lombok.extern.slf4j.Slf4j;
+import org.quartz.*;
+import org.quartz.impl.triggers.CronTriggerImpl;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.Date;
+
+import static org.quartz.TriggerBuilder.newTrigger;
+
+@Slf4j
+@Component
+public class QuartzManage {
+
+    private static final String JOB_NAME = "TASK_";
+
+    @Resource
+    private Scheduler scheduler;
+
+    public void addJob(QuartzJob quartzJob) {
+        try {
+            // 构建job信息
+            JobDetail jobDetail = JobBuilder.newJob(ExecutionJob.class).
+                    withIdentity(JOB_NAME + quartzJob.getId()).build();
+
+            //通过触发器名和cron 表达式创建 Trigger
+            Trigger cronTrigger = TriggerBuilder.newTrigger()
+                    .withIdentity(JOB_NAME + quartzJob.getId())
+                    .startNow()
+                    .withSchedule(CronScheduleBuilder.cronSchedule(quartzJob.getCronExpression()))
+                    .build();
+
+            cronTrigger.getJobDataMap().put(QuartzJob.JOB_KEY, quartzJob);
+
+            //重置启动时间
+            ((CronTriggerImpl) cronTrigger).setStartTime(new Date());
+
+            //执行定时任务，如果是持久化的，这里会报错，捕获输出
+            try {
+                scheduler.scheduleJob(jobDetail, cronTrigger);
+            } catch (ObjectAlreadyExistsException e) {
+                log.warn("定时任务已存在，跳过加载");
+            }
+
+            // 暂停任务
+            if (quartzJob.getIsPause()) {
+                pauseJob(quartzJob);
+            }
+        } catch (Exception e) {
+            log.error("创建定时任务失败", e);
+            throw new BadRequestException("创建定时任务失败");
+        }
+    }
+
+    /**
+     * 更新job cron表达式
+     *
+     * @param quartzJob /
+     */
+    public void updateJobCron(QuartzJob quartzJob) {
+        try {
+            TriggerKey triggerKey = TriggerKey.triggerKey(JOB_NAME + quartzJob.getId());
+            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
+            // 如果不存在则创建一个定时任务
+            if (trigger == null) {
+                addJob(quartzJob);
+                trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
+            }
+            CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(quartzJob.getCronExpression());
+            trigger = trigger.getTriggerBuilder().withIdentity(triggerKey).withSchedule(scheduleBuilder).build();
+            //重置启动时间
+            ((CronTriggerImpl) trigger).setStartTime(new Date());
+            trigger.getJobDataMap().put(QuartzJob.JOB_KEY, quartzJob);
+
+            scheduler.rescheduleJob(triggerKey, trigger);
+            // 暂停任务
+            if (quartzJob.getIsPause()) {
+                pauseJob(quartzJob);
+            }
+        } catch (Exception e) {
+            log.error("更新定时任务失败", e);
+            throw new BadRequestException("更新定时任务失败");
+        }
+
+    }
+
+    /**
+     * 删除一个job
+     *
+     * @param quartzJob /
+     */
+    public void deleteJob(QuartzJob quartzJob) {
+        try {
+            JobKey jobKey = JobKey.jobKey(JOB_NAME + quartzJob.getId());
+            scheduler.pauseJob(jobKey);
+            scheduler.deleteJob(jobKey);
+        } catch (Exception e) {
+            log.error("删除定时任务失败", e);
+            throw new BadRequestException("删除定时任务失败");
+        }
+    }
+
+    /**
+     * 恢复一个job
+     *
+     * @param quartzJob /
+     */
+    public void resumeJob(QuartzJob quartzJob) {
+        try {
+            TriggerKey triggerKey = TriggerKey.triggerKey(JOB_NAME + quartzJob.getId());
+            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
+            // 如果不存在则创建一个定时任务
+            if (trigger == null) {
+                addJob(quartzJob);
+            }
+            JobKey jobKey = JobKey.jobKey(JOB_NAME + quartzJob.getId());
+            scheduler.resumeJob(jobKey);
+        } catch (Exception e) {
+            log.error("恢复定时任务失败", e);
+            throw new BadRequestException("恢复定时任务失败");
+        }
+    }
+
+    /**
+     * 立即执行job
+     *
+     * @param quartzJob /
+     */
+    public void runJobNow(QuartzJob quartzJob) {
+        try {
+            TriggerKey triggerKey = TriggerKey.triggerKey(JOB_NAME + quartzJob.getId());
+            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
+            // 如果不存在则创建一个定时任务
+            if (trigger == null) {
+                addJob(quartzJob);
+            }
+            JobDataMap dataMap = new JobDataMap();
+            dataMap.put(QuartzJob.JOB_KEY, quartzJob);
+            JobKey jobKey = JobKey.jobKey(JOB_NAME + quartzJob.getId());
+            scheduler.triggerJob(jobKey, dataMap);
+        } catch (Exception e) {
+            log.error("定时任务执行失败", e);
+            throw new BadRequestException("定时任务执行失败");
+        }
+    }
+
+    /**
+     * 暂停一个job
+     *
+     * @param quartzJob /
+     */
+    public void pauseJob(QuartzJob quartzJob) {
+        try {
+            JobKey jobKey = JobKey.jobKey(JOB_NAME + quartzJob.getId());
+            scheduler.pauseJob(jobKey);
+        } catch (Exception e) {
+            log.error("定时任务暂停失败", e);
+            throw new BadRequestException("定时任务暂停失败");
+        }
+    }
+}

cutejava/cutejava-job/src/main/java/cn/odboy/util/QuartzRunnable.java

@@ -0,0 +1,43 @@
+package cn.odboy.util;
+
+import cn.odboy.util.SpringBeanHolder;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.util.ReflectionUtils;
+
+import java.lang.reflect.Method;
+import java.util.concurrent.Callable;
+
+/**
+ * 执行定时任务
+ */
+@Slf4j
+public class QuartzRunnable implements Callable<Object> {
+
+    private final Object target;
+    private final Method method;
+    private final String params;
+
+    QuartzRunnable(String beanName, String methodName, String params)
+            throws NoSuchMethodException, SecurityException {
+        this.target = SpringBeanHolder.getBean(beanName);
+        this.params = params;
+        if (StringUtils.isNotBlank(params)) {
+            this.method = target.getClass().getDeclaredMethod(methodName, String.class);
+        } else {
+            this.method = target.getClass().getDeclaredMethod(methodName);
+        }
+    }
+
+    @Override
+    @SuppressWarnings({"unchecked", "all"})
+    public Object call() throws Exception {
+        ReflectionUtils.makeAccessible(method);
+        if (StringUtils.isNotBlank(params)) {
+            method.invoke(target, params);
+        } else {
+            method.invoke(target);
+        }
+        return null;
+    }
+}

cutejava/cutejava-job/src/main/resources/mapper/QuartzJobMapper.xml

@@ -0,0 +1,51 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
+<mapper namespace="cn.odboy.mapper.QuartzJobMapper">
+
+    <resultMap id="BaseResultMap" type="cn.odboy.domain.QuartzJob">
+        <id column="job_id" property="id" jdbcType="BIGINT"/>
+        <result column="job_name" property="jobName" jdbcType="VARCHAR"/>
+        <result column="bean_name" property="beanName" jdbcType="VARCHAR"/>
+        <result column="method_name" property="methodName" jdbcType="VARCHAR"/>
+        <result column="params" property="params" jdbcType="VARCHAR"/>
+        <result column="cron_expression" property="cronExpression" jdbcType="VARCHAR"/>
+        <result column="is_pause" property="isPause" jdbcType="TINYINT"/>
+        <result column="person_in_charge" property="personInCharge" jdbcType="VARCHAR"/>
+        <result column="email" property="email" jdbcType="VARCHAR"/>
+        <result column="sub_task" property="subTask" jdbcType="VARCHAR"/>
+        <result column="pause_after_failure" property="pauseAfterFailure" jdbcType="TINYINT"/>
+        <result column="description" property="description" jdbcType="VARCHAR"/>
+        <result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
+        <result column="update_time" property="updateTime" jdbcType="TIMESTAMP"/>
+        <result column="create_by" property="createBy" jdbcType="VARCHAR"/>
+        <result column="update_by" property="updateBy" jdbcType="VARCHAR"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        job_id
+        , job_name, bean_name, method_name, params, cron_expression, is_pause, person_in_charge, email, sub_task,
+        pause_after_failure, description, create_time, update_time, create_by, update_by
+    </sql>
+
+    <select id="findAll" resultMap="BaseResultMap">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM sys_quartz_job
+        <where>
+            <if test="criteria.jobName != null and criteria.jobName != ''">
+                AND job_name LIKE CONCAT('%',#{criteria.jobName},'%')
+            </if>
+            <if test="criteria.createTime != null and criteria.createTime.size() > 0">
+                AND update_time BETWEEN #{criteria.createTime[0]} AND #{criteria.createTime[1]}
+            </if>
+        </where>
+        ORDER BY job_id DESC
+    </select>
+
+    <select id="findByIsPauseIsFalse" resultMap="BaseResultMap">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM sys_quartz_job
+        WHERE is_pause = 0
+    </select>
+</mapper>

cutejava/cutejava-job/src/main/resources/mapper/QuartzLogMapper.xml

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" >
+<mapper namespace="cn.odboy.mapper.QuartzLogMapper">
+
+    <resultMap id="BaseResultMap" type="cn.odboy.domain.QuartzLog">
+        <id column="log_id" property="id" jdbcType="BIGINT"/>
+        <result column="job_name" property="jobName" jdbcType="VARCHAR"/>
+        <result column="bean_name" property="beanName" jdbcType="VARCHAR"/>
+        <result column="method_name" property="methodName" jdbcType="VARCHAR"/>
+        <result column="params" property="params" jdbcType="VARCHAR"/>
+        <result column="cron_expression" property="cronExpression" jdbcType="VARCHAR"/>
+        <result column="is_success" property="isSuccess" jdbcType="VARCHAR"/>
+        <result column="exception_detail" property="exceptionDetail" jdbcType="BIGINT"/>
+        <result column="time" property="time" jdbcType="BIGINT"/>
+        <result column="create_time" property="createTime" jdbcType="TIMESTAMP"/>
+    </resultMap>
+
+    <sql id="Base_Column_List">
+        log_id
+        , job_name, bean_name, method_name, params, cron_expression, is_success, exception_detail, time,
+        create_time
+    </sql>
+
+    <select id="findAll" resultMap="BaseResultMap">
+        SELECT
+        <include refid="Base_Column_List"/>
+        FROM sys_quartz_log
+        <where>
+            <if test="criteria.jobName != null and criteria.jobName != ''">
+                AND job_name LIKE CONCAT('%',#{criteria.jobName},'%')
+            </if>
+            <if test="criteria.isSuccess != null">
+                AND is_success = #{criteria.isSuccess}
+            </if>
+            <if test="criteria.createTime != null and criteria.createTime.size() > 0">
+                AND create_time BETWEEN #{criteria.createTime[0]} AND #{criteria.createTime[1]}
+            </if>
+        </where>
+        ORDER BY log_id DESC
+    </select>
+
+</mapper>