springboot整合Quartz定时任务管理

最新推荐文章于 2024-08-17 21:24:20 发布
最新推荐文章于 2024-08-17 21:24:20 发布
阅读量244 收藏
点赞数
分类专栏： springboot 定时任务 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SuperChen12356/article/details/119610036
版权

pom.xml

<!-- SpringBoot 整合 Quartz 定时任务 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
            <version>2.3.5.RELEASE</version>
        </dependency>

sql

DROP TABLE IF EXISTS `scheduled_task`;
CREATE TABLE `scheduled_task` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `taskkey` varchar(128) DEFAULT NULL COMMENT '任务key值（使用bean名称）',
  `taskdesc` varchar(128) DEFAULT NULL COMMENT '任务描述',
  `taskcron` varchar(128) DEFAULT NULL COMMENT '任务表达式',
  `initstartflag` int(1) DEFAULT '1' COMMENT '程序初始化是否启动 1 是 0 否',
  `createtime` varchar(30) DEFAULT NULL COMMENT '创建时间',
  `createuser` varchar(15) DEFAULT NULL COMMENT '创建工作人员',
  `createuserid` int(6) DEFAULT NULL COMMENT '创建人员id',
  `del` int(1) DEFAULT NULL COMMENT '是否删除',
  `updateuser` varchar(15) DEFAULT NULL COMMENT '修改人员',
  `updateuserid` int(6) DEFAULT NULL COMMENT '修改人员id',
  `updatetime` varchar(30) DEFAULT NULL COMMENT '修改时间',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8 COMMENT='定时任务表';

ScheduledTaskConfig

import com.xnhy.educationadmin.controller.schedule.ScheduledTaskJob;
import com.xnhy.educationadmin.pojo.ScheduledTaskEnum;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

import java.util.Map;

@Configuration
public class ScheduledTaskConfig {

    /**
     * 日志
     */
    private static final Logger LOGGER = LogManager.getLogger(ScheduledTaskConfig.class);

    @Bean
    public ThreadPoolTaskScheduler threadPoolTaskScheduler() {
        LOGGER.info("创建定时任务调度线程池 start");
        ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();
        threadPoolTaskScheduler.setPoolSize(20);
        threadPoolTaskScheduler.setThreadNamePrefix("taskExecutor-");
        threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);
        threadPoolTaskScheduler.setAwaitTerminationSeconds(60);
        LOGGER.info("创建定时任务调度线程池 end");
        return threadPoolTaskScheduler;
    }

    /**
     * 初始化定时任务Map
     * key :任务key
     * value : 执行接口实现
     */
    @Bean(name = "scheduledTaskJobMap")
    public Map<String, ScheduledTaskJob> scheduledTaskJobMap() {
        return ScheduledTaskEnum.initScheduledTask();
    }
}

enum

import com.xnhy.educationadmin.controller.schedule.OperationScheduleTask;
import com.xnhy.educationadmin.controller.schedule.ScheduledTask01;
import com.xnhy.educationadmin.controller.schedule.ScheduledTaskJob;
import com.xnhy.educationadmin.controller.schedule.VideoCompressPathTask;
import com.xnhy.educationadmin.controller.search.AlbumSearchTask;
import com.xnhy.educationadmin.controller.search.ContentSearchTask;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 定时任务枚举
 * 2021-08-07
 * >>> 2021-08-09 chen
 */
public enum ScheduledTaskEnum {
    /**
     * 运营位定时任务
     * 2021-08-09
     * chenchao
     */
    TASK_01("OperationScheduleTask", new OperationScheduleTask()),
    // 测试定时任务
    TASK_02("scheduledTask01", new ScheduledTask01()),
    /**
     * 视频压缩路径定时任务
     * 2021-08-09
     * chenchao
     */
    TASK_03("VideoCompressPathTask", new VideoCompressPathTask()),
    // elasticsearch 数据同步 专辑数据
    TASK_04("AlbumSearchTask", new AlbumSearchTask()),
    // elasticsearch 数据同步 单集数据
    TASK_05("ContentSearchTask", new ContentSearchTask()),
    ;// 定义的值，如果有新的定时任务需要添加值 chenchao 2021-08-09
    /**
     * 定时任务key
     */
    private String taskKey;
    /**
     * 定时任务 执行实现类
     */
    private ScheduledTaskJob scheduledTaskJob;

    ScheduledTaskEnum(String taskKey, ScheduledTaskJob scheduledTaskJob) {
        this.taskKey = taskKey;
        this.scheduledTaskJob = scheduledTaskJob;
    }

    /**
     * 初始化 所有任务
     */
    public static Map<String, ScheduledTaskJob> initScheduledTask() {
        if (ScheduledTaskEnum.values().length < 0) {
            return new ConcurrentHashMap<>();
        }
        Map<String, ScheduledTaskJob> scheduledTaskJobMap = new ConcurrentHashMap<>();
        for (ScheduledTaskEnum taskEnum : ScheduledTaskEnum.values()) {
            scheduledTaskJobMap.put(taskEnum.taskKey, taskEnum.scheduledTaskJob);
        }
        return scheduledTaskJobMap;
    }
}

ScheduledTaskJob

/**
 * 调度任务公共父接口
 */
public interface ScheduledTaskJob extends Runnable {
}

ScheduledTask01

package com.xnhy.educationadmin.controller.schedule;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * 任务 01
 */
public class ScheduledTask01 implements ScheduledTaskJob {
    /**
     * 日志
     */
    private static final Logger LOGGER = LogManager.getLogger(ScheduledTask01.class);

    @Override
    public void run() {
        LOGGER.info("ScheduledTask => 01  run  当前线程名称 {} ", Thread.currentThread().getName());
    }
}

controller

import com.alibaba.fastjson.JSONObject;
import com.xnhy.educationadmin.domain.common.ScheduledTaskVO;
import com.xnhy.educationadmin.service.schedule.ScheduledTaskService;
import com.xnhy.educationadmin.util.AjaxJson;
import com.xnhy.educationadmin.util.Util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;

/**
 * 定时任务 controller
 */
@RestController
@RequestMapping("/scheduled")
public class ScheduledController {


    @Autowired
    private ScheduledTaskService scheduledTaskService;
    /**
     * 所有任务列表
     */
    @RequestMapping("/taskList")
    public Object taskList(ScheduledTaskVO vo, HttpServletRequest request) {
        AjaxJson json = new AjaxJson();
        try {
            if (!Util.isEmpty(vo.getPage())){
                vo.setPage((vo.getPage() - 1)*vo.getLimit());
            }
            // 管理页面搜索功能
            String search = request.getParameter("searchParams");
            if (!Util.isEmpty(search)){
                JSONObject jsonObject = JSONObject.parseObject(search);
                vo.setTaskdesc(Util.toSearchObject(jsonObject,"title"));
            }
            json.setCode(0);
            json.setCount(scheduledTaskService.countScheduledTask(vo));
            json.setData(scheduledTaskService.listScheduledTask(vo));
        }catch (Exception e){
            json.setCode(1);
            json.setMsg(e.toString());
            e.printStackTrace();
        }
        return json;
    }

    /**
     * 根据任务key => 启动任务
     */
    @RequestMapping("/start")
    public Object start(@RequestParam("taskKey") String taskKey) {
        AjaxJson json= new AjaxJson();
        try {
            scheduledTaskService.start(taskKey);
            json.setCode(0);
            json.setMsg("开启成功");
        }catch (Exception e){
            json.setCode(1);
            json.setMsg(e.toString());
            e.printStackTrace();
        }
        return json;
    }

    /**
     * 根据任务key => 停止任务
     */
    @RequestMapping("/stop")
    public Object stop(@RequestParam("taskKey") String taskKey) {
        AjaxJson json= new AjaxJson();
        try {
            scheduledTaskService.stop(taskKey);
            json.setCode(0);
            json.setMsg("关闭成功");
        }catch (Exception e){
            json.setCode(1);
            json.setMsg(e.toString());
            e.printStackTrace();
        }
        return json;
    }

    /**
     * 根据任务key => 重启任务
     */
    @RequestMapping("/restart")
    public String restart(@RequestParam("taskKey") String taskKey) {
        scheduledTaskService.restart(taskKey);
        return "restart success";
    }

    /**
     * 添加详情
     * @param request
     * @param vo
     * @return
     */
    @RequestMapping("/addDetail")
    public Object addDetail(HttpServletRequest request,ScheduledTaskVO vo){
        AjaxJson json = new AjaxJson();
        try {
            String username =request.getSession().getAttribute("username").toString();
            String  userId = request.getSession().getAttribute("userid").toString();
            vo.setCreatetime(Util.getNow(null));
            vo.setCreateuser(username);
            vo.setCreateuserid(Integer.parseInt(userId));
            vo.setDel(1);
            scheduledTaskService.insertSelective(vo);
            json.setMsg("请求成功");
            json.setCode(0);
        }catch (Exception e){
            json.setMsg(e.toString());
            json.setCode(1);
            e.printStackTrace();
        }
        return json;
    }

    /**
     * 修改
     * @param request
     * @param vo
     * @return
     */
    @RequestMapping("/updateDetail")
    public Object updateDetail(HttpServletRequest request,ScheduledTaskVO vo){
        AjaxJson json = new AjaxJson();
        try {
            String username =request.getSession().getAttribute("username").toString();
            String  userId = request.getSession().getAttribute("userid").toString();
            vo.setUpdatetime(Util.getNow(null));
            vo.setUpdateuser(username);
            vo.setUpdateuserid(Integer.parseInt(userId));
            vo.setDel(1);
            scheduledTaskService.updateByPrimaryKeySelective(vo);
            json.setMsg("修改成功");
            json.setCode(0);
        }catch (Exception e){
            json.setMsg(e.toString());
            json.setCode(1);
            e.printStackTrace();
        }
        return json;
    }

    @RequestMapping("/remove")
    public Object remove(@RequestParam(value = "id", required = false, defaultValue = "")String id){
        AjaxJson json = new AjaxJson();
        try {
            String[] str = id.split(",");
            for (int i = 0;i<str.length;i++) {
                scheduledTaskService.deleteByPrimaryKey(Integer.parseInt(str[i]));
            }
            json.setCode(0);
            json.setMsg("删除成功");
        }catch (Exception e){
            json.setCode(1);
            json.setMsg(e.toString());
            e.printStackTrace();
        }
        return json;
    }
}

service

package com.xnhy.educationadmin.service.schedule;

import com.xnhy.educationadmin.domain.common.ScheduledTaskVO;

import java.util.List;

public interface ScheduledTaskService {
    /**
     * 所有任务列表
     */
    List<ScheduledTaskVO> taskList();

    /**
     * 根据任务key 启动任务
     */
    Boolean start(String taskKey);

    /**
     * 根据任务key 停止任务
     */
    Boolean stop(String taskKey);

    /**
     * 根据任务key 重启任务
     */
    Boolean restart(String taskKey);


    /**
     * 程序启动时初始化  ==> 启动所有正常状态的任务
     */
    void initAllTask(List<ScheduledTaskVO> scheduledTaskBeanList);

    /**
     * 数据列表
     * @param record
     * @return
     */
    List<ScheduledTaskVO> listScheduledTask(ScheduledTaskVO record);

    /**
     * 总数
     * @param record
     * @return
     */
    long countScheduledTask(ScheduledTaskVO record);

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table bj_xnhy_scheduled_task
     *
     * @mbg.generated
     */
    int insertSelective(ScheduledTaskVO record);

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table bj_xnhy_scheduled_task
     *
     * @mbg.generated
     */
    ScheduledTaskVO selectByPrimaryKey(Integer id);

    /**
     * This method was generated by MyBatis Generator.
     * This method corresponds to the database table bj_xnhy_scheduled_task
     *
     * @mbg.generated
     */
    int updateByPrimaryKeySelective(ScheduledTaskVO record);

    /**
     * 删除
     * @param id
     * @return
     */
    int deleteByPrimaryKey(Integer id);

}

serviceImpl

import com.xnhy.educationadmin.controller.schedule.ScheduledTaskJob;
import com.xnhy.educationadmin.dao.common.ScheduledTaskMapper;
import com.xnhy.educationadmin.domain.common.ScheduledTaskVO;
import com.xnhy.educationadmin.service.schedule.ScheduledTaskService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.TriggerContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;
import org.springframework.scheduling.support.CronTrigger;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.locks.ReentrantLock;

@Service
public class ScheduledTaskServiceImpl implements ScheduledTaskService {

    private static final Logger LOGGER = LogManager.getLogger(LogManager.ROOT_LOGGER_NAME);

    @Autowired
    private ScheduledTaskMapper taskMapper;// 修改成自己的mapper
    /**
     * 可重入锁
     */
    private ReentrantLock lock = new ReentrantLock();
    /**
     * 定时任务线程池
     */
    @Autowired
    private ThreadPoolTaskScheduler threadPoolTaskScheduler;
    /**
     * 所有定时任务存放Map
     * key :任务 key
     * value:任务实现
     */
    @Autowired
    @Qualifier(value = "scheduledTaskJobMap")
    private Map<String, ScheduledTaskJob> scheduledTaskJobMap;

    /**
     * 存放已经启动的任务map
     */
    private Map<String, ScheduledFuture> scheduledFutureMap = new ConcurrentHashMap<>();

    /**
     * 所有任务列表
     */
    @Override
    public List<ScheduledTaskVO> taskList() {
        LOGGER.info(">>>>>> 获取任务列表开始 >>>>>> ");
        //数据库查询所有任务 => 未做分页
        List<ScheduledTaskVO> taskBeanList = taskMapper.getAllTask();
        if (CollectionUtils.isEmpty(taskBeanList)) {
            return new ArrayList<>();
        }

        for (ScheduledTaskVO taskBean : taskBeanList) {
            String taskKey = taskBean.getTaskkey();
            //是否启动标记处理
            taskBean.setStartFlag(this.isStart(taskKey));
        }
        LOGGER.info(">>>>>> 获取任务列表结束 >>>>>> ");
        return taskBeanList;
    }


    /**
     * 根据任务key 启动任务
     */
    @Override
    public Boolean start(String taskKey) {
        LOGGER.info(">>>>>> 启动任务 {} 开始 >>>>>>"+taskKey);
        //添加锁放一个线程启动，防止多人启动多次
        lock.lock();
        LOGGER.info(">>>>>> 添加任务启动锁完毕");
        try {
            //校验是否已经启动
            if (this.isStart(taskKey)) {
                LOGGER.info(">>>>>> 当前任务已经启动，无需重复启动！");
                return false;
            }
            //校验任务是否存在
            if (!scheduledTaskJobMap.containsKey(taskKey)) {
                return false;
            }
            //根据key数据库获取任务配置信息
            ScheduledTaskVO scheduledTask = taskMapper.getByKey(taskKey);
            //启动任务
            this.doStartTask(scheduledTask);
        } finally {
            // 释放锁
            lock.unlock();
            LOGGER.info(">>>>>> 释放任务启动锁完毕");
        }
       LOGGER.info(">>>>>> 启动任务 {} 结束 >>>>>>"+taskKey);
        return true;
    }

    /**
     * 根据 key 停止任务
     */
    @Override
    public Boolean stop(String taskKey) {
        LOGGER.info(">>>>>> 进入停止任务 {}  >>>>>>"+ taskKey);
        //当前任务实例是否存在
        boolean taskStartFlag = scheduledFutureMap.containsKey(taskKey);
        //LOGGER.info(">>>>>> 当前任务实例是否存在 {}", taskStartFlag);
        if (taskStartFlag) {
            //获取任务实例
            ScheduledFuture scheduledFuture = scheduledFutureMap.get(taskKey);
            //关闭实例
            scheduledFuture.cancel(true);
        }
        LOGGER.info(">>>>>> 结束停止任务 {}  >>>>>>"+ taskKey);
        return taskStartFlag;
    }

    /**
     * 根据任务key 重启任务
     */
    @Override
    public Boolean restart(String taskKey) {
        LOGGER.info(">>>>>> 进入重启任务 {}  >>>>>>"+ taskKey);
        //先停止
        this.stop(taskKey);
        //再启动
        return this.start(taskKey);
    }

    /**
     * 程序启动时初始化  ==> 启动所有正常状态的任务
     */
    @Override
    public void initAllTask(List<ScheduledTaskVO> scheduledTaskBeanList) {
        LOGGER.info("程序启动 ==> 初始化所有任务开始 ！size={}"+ scheduledTaskBeanList.size());
        if (CollectionUtils.isEmpty(scheduledTaskBeanList)) {
            return;
        }
        for (ScheduledTaskVO scheduledTask : scheduledTaskBeanList) {
            //任务 key
            String taskKey = scheduledTask.getTaskkey();
            //校验是否已经启动
            if (this.isStart(taskKey)) {
                continue;
            }
            //启动任务
            this.doStartTask(scheduledTask);
        }
        LOGGER.info("程序启动 ==> 初始化所有任务结束 ！size={}"+scheduledTaskBeanList.size());
    }

    @Override
    public List<ScheduledTaskVO> listScheduledTask(ScheduledTaskVO record) {
        LOGGER.info(">>>>>> 获取任务列表开始 >>>>>> ");
        //数据库查询所有任务 => 未做分页
        List<ScheduledTaskVO> taskBeanList = taskMapper.listScheduledTask(record);
        if (CollectionUtils.isEmpty(taskBeanList)) {
            return new ArrayList<>();
        }

        for (ScheduledTaskVO taskBean : taskBeanList) {
            String taskKey = taskBean.getTaskkey();
            //是否启动标记处理
            taskBean.setStartFlag(this.isStart(taskKey));
        }
        LOGGER.info(">>>>>> 获取任务列表结束 >>>>>> ");
        return taskBeanList;
    }

    @Override
    public long countScheduledTask(ScheduledTaskVO record) {
        return taskMapper.countScheduledTask(record);
    }

    @Override
    public int insertSelective(ScheduledTaskVO record) {
        return taskMapper.insertSelective(record);
    }

    @Override
    public ScheduledTaskVO selectByPrimaryKey(Integer id) {
        return taskMapper.selectByPrimaryKey(id);
    }

    @Override
    public int updateByPrimaryKeySelective(ScheduledTaskVO record) {
        return taskMapper.updateByPrimaryKeySelective(record);
    }

    @Override
    public int deleteByPrimaryKey(Integer id) {
        return taskMapper.deleteByPrimaryKey(id);
    }

    /**
     * 执行启动任务
     */
    private void doStartTask(ScheduledTaskVO scheduledTask) {
        try {
            //任务key
            String taskKey = scheduledTask.getTaskkey();
            //定时表达式
            String taskCron = scheduledTask.getTaskcron();
            //获取需要定时调度的接口
            ScheduledTaskJob scheduledTaskJob = scheduledTaskJobMap.get(taskKey);
            LOGGER.info(">>>>>> 任务 [ {} ] ,cron={"+ scheduledTask.getTaskdesc()+"}---bean名称："+taskKey+"---表达式："+taskCron);
            ScheduledFuture scheduledFuture = threadPoolTaskScheduler.schedule(scheduledTaskJob,
                    new Trigger() {
                        @Override
                        public Date nextExecutionTime(TriggerContext triggerContext) {
                            CronTrigger cronTrigger = new CronTrigger(taskCron);
                            return cronTrigger.nextExecutionTime(triggerContext);
                        }
                    });
            //将启动的任务放入 map
            scheduledFutureMap.put(taskKey, scheduledFuture);
        }catch (Exception e){
            LOGGER.info("启动定时任务报错："+e.toString());
            e.printStackTrace();
        }
    }

    /**
     * 任务是否已经启动
     */
    private Boolean isStart(String taskKey) {
        //校验是否已经启动
        if (scheduledFutureMap.containsKey(taskKey)) {
            if (!scheduledFutureMap.get(taskKey).isCancelled()) {
                return true;
            }
        }
        return false;
    }
}

BeanContext

package com.xnhy.educationadmin.util;

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

//手动获取Spring中的bean  注意这个类要一定交给spring来管理
@Component
public class BeanContext implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        BeanContext.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext(){
        return applicationContext;
    }

    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException {
        return (T)applicationContext.getBean(name);
    }

    public static <T> T getBean(Class<T> clz) throws BeansException {
        return (T)applicationContext.getBean(clz);
    }
}

初始化加载数据

package com.xnhy.educationadmin.controller.schedule;

import com.xnhy.educationadmin.dao.common.ScheduledTaskMapper;
import com.xnhy.educationadmin.domain.common.ScheduledTaskVO;
import com.xnhy.educationadmin.service.schedule.ScheduledTaskService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

import java.util.List;

/**
 * @see @Order注解的执行优先级是按value值从小到大顺序。
 * 项目启动完毕后开启需要自启的任务
 */
@Component
@Order(value = 1)
public class ScheduledTaskRunner implements ApplicationRunner {
    /**
     * 日志
     */
    private static final Logger LOGGER = LogManager.getLogger(ScheduledTaskRunner.class);

    @Autowired
    private ScheduledTaskMapper taskMapper;

    @Autowired
    private ScheduledTaskService scheduledTaskService;

    /**
     * 程序启动完毕后,需要自启的任务
     */
    @Override
    public void run(ApplicationArguments applicationArguments) throws Exception {
        LOGGER.info(" >>>>>> 项目启动完毕, 开启 => 需要自启的任务 开始!");
        List<ScheduledTaskVO> scheduledTaskBeanList = taskMapper.getAllNeedStartTask();
        scheduledTaskService.initAllTask(scheduledTaskBeanList);
        LOGGER.info(" >>>>>> 项目启动完毕, 开启 => 需要自启的任务 结束！");
    }
}

定时任务加载service需要BeanContext，不然会报错空指针异常

......其他定时任务
  private OperationService operationService ;

    @Override
    public void run() {
        try {
            operationService = BeanContext.getApplicationContext().getBean(OperationService.class);
            log.info("------------运营位定时任务---start");
            ......

部分sql，添加修改的省略了


  <sql id="queryConditions">
    <!-- 查询条件 -->
    <if test='taskdesc != null  and taskdesc !=""'>
      and x.taskdesc LIKE concat('%',#{taskdesc,jdbcType=VARCHAR},'%')
    </if>
  </sql>
  <!--  总数-->
  <select id="countScheduledTask" resultType="java.lang.Long" parameterType="com.xnhy.educationadmin.domain.common.ScheduledTaskVO">
    select
    count(x.id)
    from bj_xnhy_scheduled_task x
    where 1 = 1
    <include refid="queryConditions"/>
  </select>

  <!-- 列表 -->
  <select id="listScheduledTask" resultMap="BaseResultMap">
    select
    <include refid="Base_Column_List" />
    from bj_xnhy_scheduled_task x
    where 1 = 1
    <include refid="queryConditions"/>
    ORDER BY x.createtime DESC
    <if test='page != null and limit != null'>
      limit #{page,jdbcType=INTEGER},#{limit,jdbcType=INTEGER}
    </if>
  </select>

  <!-- 根据key 获取 任务信息-->
  <select id="getByKey" resultType="com.xnhy.educationadmin.domain.common.ScheduledTaskVO"
    parameterType="java.lang.String">
      SELECT x.*
      FROM bj_xnhy_scheduled_task x
      WHERE x.taskkey = #{taskKey,jdbcType=VARCHAR}
  </select>

  <!--获取程序初始化需要自启的任务信息-->
  <select id="getAllNeedStartTask" resultType="com.xnhy.educationadmin.domain.common.ScheduledTaskVO">
    SELECT x.*
    FROM bj_xnhy_scheduled_task X
    WHERE x.del =1 AND x.initstartflag = 1
  </select>

  <!-- 获取所有任务-->
  <select id="getAllTask" resultType="com.xnhy.educationadmin.domain.common.ScheduledTaskVO">
     SELECT x.*
     FROM bj_xnhy_scheduled_task x WHERE x.del =1
  </select>

ScheduledTaskVO

package com.xnhy.educationadmin.domain.common;

import com.xnhy.educationadmin.domain.system.BasicDO;
import lombok.Data;

/**
 *
 * This class was generated by MyBatis Generator.
 * This class corresponds to the database table bj_xnhy_scheduled_task
 *
 * @mbg.generated do_not_delete_during_merge
 */
@Data
public class ScheduledTaskVO extends BasicDO {
    /**
     * Database Column Remarks:
     *   主键
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.id
     *
     * @mbg.generated
     */
    private Integer id;

    /**
     * Database Column Remarks:
     *   任务key值（使用bean名称）
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.taskkey
     *
     * @mbg.generated
     */
    private String taskkey;

    /**
     * Database Column Remarks:
     *   任务描述
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.taskdesc
     *
     * @mbg.generated
     */
    private String taskdesc;

    /**
     * Database Column Remarks:
     *   任务表达式
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.taskcron
     *
     * @mbg.generated
     */
    private String taskcron;

    /**
     * Database Column Remarks:
     *   程序初始化是否启动 1 是 0 否
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.initstartflag
     *
     * @mbg.generated
     */
    private Integer initstartflag;

    /**
     * 当前是否已启动
     */
    private boolean startFlag;
    /**
     * Database Column Remarks:
     *   创建时间
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.createtime
     *
     * @mbg.generated
     */
    private String createtime;

    /**
     * Database Column Remarks:
     *   创建工作人员
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.createuser
     *
     * @mbg.generated
     */
    private String createuser;

    /**
     * Database Column Remarks:
     *   创建人员id
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.createuserid
     *
     * @mbg.generated
     */
    private Integer createuserid;

    /**
     * Database Column Remarks:
     *   是否删除
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.del
     *
     * @mbg.generated
     */
    private Integer del;

    /**
     * Database Column Remarks:
     *   修改人员
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.updateuser
     *
     * @mbg.generated
     */
    private String updateuser;

    /**
     * Database Column Remarks:
     *   修改人员id
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.updateuserid
     *
     * @mbg.generated
     */
    private Integer updateuserid;

    /**
     * Database Column Remarks:
     *   修改时间
     *
     * This field was generated by MyBatis Generator.
     * This field corresponds to the database column bj_xnhy_scheduled_task.updatetime
     *
     * @mbg.generated
     */
    private String updatetime;
}
SuperChen12356
关注
专栏目录
【SpringBoot】82、SpringBoot集成Quartz实现动态管理定时任务
Asurplus
06-29 3万+
Quartz 是一个开源的作业调度框架，它完全由 Java 写成，并设计用于 J2SE 和 J2EE 应用中。它提供了巨大的灵 活性而不牺牲简单性。你能够用它来为执行一个作业而创建简单的或复杂的调度。它有很多特征，如：数据库支持，集群，插件，EJB 作业预构 建，JavaMail 及其它，支持 cron-like 表达式等等
Quartz+Spring Boot实现动态管理定时任务
08-26
最近做项目遇到动态管理定时任务的需求，刚拿到这个需求还真不知道从哪下手，经过一番思考，终于找出实现思路，接下来通过本文给大家介绍了Quartz+Spring Boot实现动态管理定时任务的相关知识,需要的朋友可以参考下
SpringBoot整合Quartz定时任务管理
weixin_30555515的博客
01-11 57
pom.xml 　　　　<!-- quartz --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-quartz<...
【Spring Boot】定时任务
最新发布
2401_83045332的博客
08-17 3269
在Spring Boot中，定时任务的实现通常使用@Scheduled注解。@Scheduled可以用于在指定的时间间隔或特定的时间点执行任务。Spring提供了多种方式来配置定时任务，如使用固定速率，固定延迟或Cron表达式等。如果是分布式系统或者想要时间可以灵活变化，可以选择一些定时任务框架xxl-job,elastic-job等在 Spring Boot 中，通过使用@Scheduled。
spring boot 定时任务管理
^无心人^_-的博客
06-09 705
spring boot 有scheduler 可以做定时任务，我们也可以通过scheduler做定时任务管理，实现新增，删除，修改定时任务功能。测试调用的定时任务方法 和 类。当项目启动完成就加载定时任务。创建获取对象容器工具类。创建定时任务执行线程。
SpringBoot的定时任务动态管理
怪只怪满眼尽是人间烟火
01-30 688
地址：GitHub - guoyixing/super-scheduled: SpringBoot的定时调用的加强工具，实现定时任务动态管理，后续加入可视化管理、调度日志、集群任务统一管理
SpringBoot定时任务动态管理
aw277866304的博客
12-07 1121
1.作用 无需对系统进行启停操作即可对定时任务进行增删改、启停和重启，对比于只使用了@Scheduled标签的定时任务更灵活多变。不推荐任务集群时使用，会重复执行。 2.前期准备 2.1 创建定时任务表 create table `cj_scheduled_task` ( `id` varchar(50) primary key comment '主键id', `task_class` varchar(100) not null comment '定时任务完整类名', ...
springboot整合quartz定时任务yml文件配置方式
03-23
在Spring Boot应用中整合Quartz定时任务是一种常见的需求，它可以帮助我们执行周期性的后台任务，如数据同步、报表生成等。Spring Boot与Quartz的结合提供了便捷的配置方式，特别是通过YAML（YAML Ain't Markup ...
Springboot整合Quartz实现定时任务数据库动态配置
03-17
本篇文章将详细探讨如何在Spring Boot项目中整合Quartz，并通过MySQL数据库实现定时任务的动态配置。 首先，我们需要在项目中添加依赖。在Spring Boot的`pom.xml`文件中，引入Spring Boot的`spring-boot-starter-...
SpringBoot 整合Quartz（集群）实现定时任务调度
02-14
SpringBoot整合Quartz实现定时任务调度是企业级应用中常见的需求，主要用于自动化执行某些周期性的任务，例如数据备份、报表生成、系统维护等。Quartz是一个功能强大的开源作业调度框架，能够灵活地定义任务和调度...
从0到1搭建SpringBoot整合Quartz定时任务框架（保姆级教学+Gitee源码）
黄团团的个人博客
06-28 2552
Quartz是一个完全由Java编写的开源作业调度框架，在Java应用程序中进行作业调度提供了强大功能，以下是Quartz的四个核心概念。1、Job（接口）：它只有一个execute方法需要被重写，重写的内容就是咱们需要执行的具体内容。2、JobDetail（调度信息）：表示一个具体的可执行的调度程序，Job是这个可执行调度程序中所需要执行的具体内容，另外JobDetail还包含了这个任务的调度方案和策略。3、Trigger（触发器）：代表一个调度参数的配置，动态去执行咱们的定时任务。
Spring定时任务管理
10-21
Spring定时任务的几种实现，欢迎交流！
springboot-quartz-demo:quartz实现定制化定时任务-基于springboot
05-11
master分支上是使用springboot+quartz+mysql+kafka实现定制化定时任务功能 系统启动初始化加载已有的定时任务 启动or暂停定时任务 立即运行定时任务 实时新增及修改定时任务 定时任务的详细监控 博客地址: 注意此项目需要kafka服务，新手请参照kafka官网 定时任务界面效果图 feature_es分支上是用springboot结合elastic search做的搜索引擎 博客地址: 注意:这个项目里面也需要kafka，里面有很多东西需要完善，但是基本的搜索功能是有的，有兴趣的小伙伴可以自行研究完善 搜索界面效果如下图:
Springboot2-Quartz 后台可动态配置的定时任务
02-28
SpringBoot2 与 Quartz 整合的Demo。 后台可添加、修改、移除 定时任务。 也可查看当前任务的状态 灵活的定时任务
SpringBoot实现Quartz定时任务管理
qq_32328217的博客
08-30 576
本篇将记录SpringBoot集成Quartz实现定时任务持久化到数据库，并实现定时任务添加、修改、删除、暂停、继续执行。 导入相关依赖 首先先创建一个springboot项目，创建完成后，在pom.xml文件里引入依赖： <parent> <artifactId>spring-boot-starter-parent</artifactId> <groupId>org.springframework.boot</grou.
springboot：定时任务
热门推荐
戏拈秃笔的博客
06-23 1万+
springboot实现定时任务的五种方法
SpringBoot 定时任务动态管理通用解决方案！
m0_71777195的博客
01-13 207
SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改。增强器实现的整体思路与SpringAop的思路一致，实现没有Aop复杂。接口，将这个类标记为后处理器，后处理器会在每个bean实例化之后执行。使用cglib代理增强器，将增强器全部代理成调用链节点Point。(2) 使用后处理器拦截SpringBoot原本的定时任务。(4) cglib动态代理实现。(5) 定时任务执行器实现。
Spring Boot 实现定时任务动态管理，太爽了！
良月柒
06-24 359
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 10分钟。来自：https://blog.csdn.net/qq_34886352/article/details/106494637一、功能说明SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改。二、快速使用具体的...
SpringBoot整合Quartz实现任务调度详解
Spring Boot结合Quartz提供了一种灵活的方式来管理并执行复杂、多样的定时任务。通过这种方式，我们可以更好地定制任务的执行策略，满足业务上的各种需求。而Quartz的强大功能，如并发控制、故障恢复等，也为任务...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

SuperChen12356

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值