SpringBoot动态定时任务-整合数据库

最新推荐文章于 2024-03-01 20:30:58 发布
最新推荐文章于 2024-03-01 20:30:58 发布
阅读量1.6k 收藏 4
点赞数 2
分类专栏： java 文章标签： 数据库 spring boot mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yingmengxuepingbao/article/details/122733551
版权

最近使用定时任务比较多，想起之前有一次用到过，但没有代码了。重新整理一份，仅供参考！

数据库使用的是mysql:

DROP TABLE IF EXISTS `bj_wcs`.`wcs_huakang_cron`;

-- ----------------------------

-- Table structure for wcs_huakang_cron

-- ----------------------------

CREATE TABLE `wcs_huakang_cron`  (

  `cron_id` varchar(30) not NULL COMMENT '唯一标识' PRIMARY KEY,

  `task_name` varchar(30) DEFAULT NULL COMMENT '任务名称',

  `cron` varchar(30) not NULL COMMENT '任务表达式',

  `class_name` varchar(255) not NULL COMMENT '类路径名称',

  `method_name` varchar(100) not NULL COMMENT '类的方法名',

  `type` varchar(30) DEFAULT NULL COMMENT '任务类型',

  `state` varchar(30) DEFAULT 0 COMMENT '任务状态：0：正常（启动）;1:不正常（停止）',

  `create_by` varchar(30) DEFAULT NULL COMMENT '创建人',

  `create_time` datetime DEFAULT NULL COMMENT '创建时间'

)ENGINE=InnoDB DEFAULT CHARSET=utf8 ROW_FORMAT=DYNAMIC COMMENT='定时任务管理表';

开发环境SpringBoot

============controller层：==================================

package com.penghaisoft.wcs.corn.controller;

/**

 * @Description

 * @Author zx

 * @Date 2022-01-21

 **/

import com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron;

import com.penghaisoft.wcs.corn.service.Scheduler;

import com.penghaisoft.wcs.corn.service.WcsHuakangCronService;

import org.springframework.beans.BeanUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.PathVariable;

import org.springframework.web.bind.annotation.RequestBody;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

import javax.annotation.PostConstruct;

import java.lang.reflect.Field;

import java.util.ArrayList;

import java.util.List;

/**

 * 动态定时任务Controller

 */

@RestController

@RequestMapping("/wcsHuakangCronController/")

public class WcsHuakangCronController {

    @Autowired

    private Scheduler scheduler;

    @Autowired

    private WcsHuakangCronService wcsHuakangCronService;

    /**

     * 启动一个动态定时任务

     * http://localhost:10085/wcsHuakangCron/start/2

     */

    @RequestMapping("start/{cronId}")

    public String start(@PathVariable("cronId") String cronId){

        scheduler.start(cronId);

        return "操作成功";

    }

    /**

     * 停止一个动态定时任务

     * http://localhost:10085/wcsHuakangCron/stop/2

     */

    @RequestMapping("stop/{cronId}")

    public String stop(@PathVariable("cronId") String cronId){

        scheduler.stop(cronId);

        return "操作成功";

    }

    /**

     * 更新一个动态定时任务

     * http://localhost:9090/wcs/wcsHuakangCron/save?taskId=2&taskExp=0/2 * * * * ?&taskClass=cn.huanzi.qch.springboottimer.task.MyRunnable3

     */

    @RequestMapping("save")

    public String save(WcsHuakangCron task) throws IllegalAccessException {

        //先更新表数据

        WcsHuakangCron wcsHuakangCron = wcsHuakangCronService.selectByPrimaryKey(task.getCronId());

        //null值忽略

        List<String> ignoreProperties = new ArrayList<>(7);

        //反射获取Class的属性（Field表示类中的成员变量）

        for (Field field : task.getClass().getDeclaredFields()) {

            //获取授权

            field.setAccessible(true);

            //属性名称

            String fieldName = field.getName();

            //属性的值

            Object fieldValue = field.get(task);

            //找出值为空的属性，我们复制的时候不进行赋值

            if(null == fieldValue){

                ignoreProperties.add(fieldName);

            }

        }

        //org.springframework.beans BeanUtils.copyProperties(A,B)：A中的值付给B

        BeanUtils.copyProperties(task, wcsHuakangCron,ignoreProperties.toArray(new String[0]));

        wcsHuakangCronService.insert(wcsHuakangCron);

        Scheduler.mysql_tasks.clear();

        //停止旧任务

        scheduler.stop(wcsHuakangCron.getCronId());

        //重新启动

        scheduler.start(wcsHuakangCron.getCronId());

        return "操作成功";

    }

    /**

     * 启动多个动态定时任务

     * http://localhost:10085/wcsHuakangCron/start/2

     */

    @RequestMapping("start/{List}")

    public String start(@RequestBody List<WcsHuakangCron> list){

        if(list.size()>0){

            //循环开启所有动态定时任务

            extracted(list);

            return "操作成功";

        }

        return "操作失败";

    }

    /**

     *功能描述: 默认加载开启所有定时任务

     * @author zhangx

     * @date 2022/1/22

     * @params

     * @return void

     */

    @PostConstruct

    public void startAll(){

          List<WcsHuakangCron> list= wcsHuakangCronService.findAll();

          if(list.size()>0){

              extracted(list);

          }

    }

    /**

     *功能描述: 循环开启所有动态定时任务

     * @author zhangx

     * @date 2022/1/22

     * @params

     * @return void

     */

    private void extracted(List<WcsHuakangCron> list) {

        if(list.size()>0) {

            for (WcsHuakangCron wcsHuakangCron : list) {

                scheduler.start(wcsHuakangCron.getCronId());

            }

        }

    }

}

==============server层=====================

-----------------------业务层-----------------------

package com.penghaisoft.wcs.corn.service;

import com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron;

import com.penghaisoft.wcs.util.MethodRunUtil;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.context.annotation.Configuration;

import org.springframework.scheduling.annotation.EnableScheduling;

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

import org.springframework.scheduling.support.CronTrigger;

import java.lang.reflect.Method;

import java.util.ArrayList;

import java.util.List;

import java.util.concurrent.ConcurrentHashMap;

import java.util.concurrent.ScheduledFuture;

/**

 * @Description 创建定时器

 * @Author zx

 * @Date 2022-01-22

 **/

@Slf4j

@Configuration //1.主要用于标记配置类，兼备component的效果。

@EnableScheduling // 2.开启定时任务

public class Scheduler  {//implements SchedulingConfigurer

    //数据库的任务

    public static ConcurrentHashMap<String, WcsHuakangCron> mysql_tasks = new ConcurrentHashMap<>(10);

    //正在运行的任务

    public static ConcurrentHashMap<String, ScheduledFuture> runTasks = new ConcurrentHashMap<>(10);

    //线程池任务调度

    private ThreadPoolTaskScheduler threadPoolTaskScheduler = new ThreadPoolTaskScheduler();

    /**

     *功能描述: 查询定时任务的服务类

     */

    @Autowired

    private WcsHuakangCronService wcsHuakangCronService;

    /**

     * 初始化线程池任务调度

     */

    @Autowired

    public Scheduler(){

        this.threadPoolTaskScheduler.setPoolSize(10);

        this.threadPoolTaskScheduler.setThreadNamePrefix("task-thread-");

        this.threadPoolTaskScheduler.setWaitForTasksToCompleteOnShutdown(true);

        this.threadPoolTaskScheduler.initialize();

    }

    /**

     * 获取所有数据库里的定时任务

     */

    @Scheduled(cron = "1/4 * * * * *")

    private void getAllWcsHuakangCron(){

        //查询所有，并put到tasks

        Scheduler.mysql_tasks.clear();

        log.info("定时任务进来了！");

        List<WcsHuakangCron> list = wcsHuakangCronService.findAll();

        log.info("几条数据："+list.size());

        if(list.size()>0) {

            for (WcsHuakangCron wcsHuakangCron:list) {

                Scheduler.mysql_tasks.put(wcsHuakangCron.getCronId(), wcsHuakangCron);

                this.start(wcsHuakangCron.getCronId());

            }

        }

    }

    /**

     * 根据定时任务id，启动定时任务

     */

    public void start(String cronId){

        try {

            //如果为空，重新获取

            if(Scheduler.mysql_tasks.size() <= 0){

                this.getAllWcsHuakangCron();

            }

            WcsHuakangCron wcsHuakangCron = Scheduler.mysql_tasks.get(cronId);

            //

            String className = wcsHuakangCron.getClassName();

            //获取任务类

            Class<?> clazz = Class.forName(wcsHuakangCron.getClassName());

            //获取类名称的方法

            Method methods = clazz.getMethod(wcsHuakangCron.getMethodName());

            // 创建对象 Objects obj = (Objects) clazz.getConstructor().newInstance();

            //Cron表达式

            CronTrigger cron = new CronTrigger(wcsHuakangCron.getCron());

            //执行，并put到runTasks

            //Scheduler.runTasks.put(cronId, Objects.requireNonNull(this.threadPoolTaskScheduler.schedule(runnable, cron)));

            this.threadPoolTaskScheduler.schedule(new MethodRunUtil(className,methods),cron);

            this.updateTaskStatus(cronId,"0");

            log.info("{}，任务启动！",cronId);

        } catch (ClassNotFoundException  | NoSuchMethodException  e) {

            log.error("{}，任务启动失败...",cronId);

            e.printStackTrace();

        }

    }

    /**

     * 根据定时任务id，停止定时任务

     */

   public void stop(String taskId){

        Scheduler.runTasks.get(taskId).cancel(true);

        Scheduler.runTasks.remove(taskId);

        this.updateTaskStatus(taskId,"1");

        log.info("{}，任务停止...",taskId);

    }

    /**

     * 更新数据库动态定时任务状态

     */

    private void updateTaskStatus(String taskId,String status){

        WcsHuakangCron wcsHuakangCron = wcsHuakangCronService.selectByPrimaryKey(taskId);

        wcsHuakangCron.setState(status);

        wcsHuakangCronService.updateByPrimaryKey(wcsHuakangCron);

    }

  /*  @Override

    public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {

        taskRegistrar.addTriggerTask(() -> {

                    if (!CollectionUtils.isEmpty(wcsHuakangCronList)) {

                        log.info("检测动态定时任务列表...");

                        List<WcsHuakangCron> tts = new ArrayList<>();

                        wcsHuakangCronList.forEach(WcsHuakangCron -> {

                                    WcsHuakangCron tt = new WcsHuakangCron();

                                    tt.setCron(WcsHuakangCron.getCron());

                                    tt.setCronId("dynamic-task-" + WcsHuakangCron.getCronId());

                                    tts.add(tt);

                                });

                    }

                }

                , triggerContext -> new PeriodicTrigger(5L, TimeUnit.SECONDS).nextExecutionTime(triggerContext));

    }*/

}

查询数据：

package com.penghaisoft.wcs.corn.service;

import com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron;

import java.util.List;

/**

 * @Description 定时任务管理

 * @Author zx

 * @Date 2022/01/21

 **/

public interface WcsHuakangCronService {

    int deleteByPrimaryKey(String cronId);

    int insert(WcsHuakangCron record);

    int insertSelective(WcsHuakangCron record);

    WcsHuakangCron selectByPrimaryKey(String cronId);

    int updateByPrimaryKeySelective(WcsHuakangCron record);

    int updateByPrimaryKey(WcsHuakangCron record);

    /**

     *功能描述: 查询所有定时任务

     * @author zhangx

     * @date 2022/1/21

     * @param

     * @return

     */

    List<WcsHuakangCron> findAll();

}

=============service实现层===============================

package com.penghaisoft.wcs.corn.service.impl;

import com.penghaisoft.wcs.corn.model.dao.WcsHuakangCronMapper;

import com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron;

import com.penghaisoft.wcs.corn.service.WcsHuakangCronService;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.List;

/**

 * @Description

 * @Author zx

 * @Date 2022-01-21

 **/

@Service("wcsHuakangCronService")

public class WcsHuakangCronServiceImpl implements WcsHuakangCronService {

    @Autowired

    private WcsHuakangCronMapper wcsHuakangCronMapper;

    @Override

    public int deleteByPrimaryKey(String cronId) {

        return wcsHuakangCronMapper.deleteByPrimaryKey(cronId);

    }

    @Override

    public int insert(WcsHuakangCron record) {

        return wcsHuakangCronMapper.insert(record);

    }

    @Override

    public int insertSelective(WcsHuakangCron record) {

        return wcsHuakangCronMapper.insertSelective(record);

    }

    @Override

    public WcsHuakangCron selectByPrimaryKey(String cronId) {

        return wcsHuakangCronMapper.selectByPrimaryKey(cronId);

    }

    @Override

    public int updateByPrimaryKeySelective(WcsHuakangCron record) {

        return wcsHuakangCronMapper.updateByPrimaryKeySelective(record);

    }

    @Override

    public int updateByPrimaryKey(WcsHuakangCron record) {

        return wcsHuakangCronMapper.updateByPrimaryKey(record);

    }

    /**

     *功能描述: 查询所有定时任务

     * @author zhangx

     * @date 2022/1/21

     * @param

     * @return

     */

    @Override

    public List<WcsHuakangCron> findAll() {

        return wcsHuakangCronMapper.findAll();

    }

}

================mapper层：============================

package com.penghaisoft.wcs.corn.model.dao;

import com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron;

import org.springframework.stereotype.Repository;

import java.util.List;

/**

 * @Description 定时任务管理

 * @Author zx

 * @Date 2022/01/21

 **/

@Repository

public interface WcsHuakangCronMapper {

    int deleteByPrimaryKey(String cronId);

    int insert(WcsHuakangCron record);

    int insertSelective(WcsHuakangCron record);

    WcsHuakangCron selectByPrimaryKey(String cronId);

    int updateByPrimaryKeySelective(WcsHuakangCron record);

    int updateByPrimaryKey(WcsHuakangCron record);

    /**

     *功能描述: 查询所有定时任务

     * @author zhangx

     * @date 2022/1/21

     * @param

     * @return

     */

    List<WcsHuakangCron> findAll();

}

================实体类：============================

package com.penghaisoft.wcs.corn.model.entity;

import lombok.Data;

import java.util.Date;

/**

 *功能描述:定时任务管理类

 * @author zhangx

 * @date 2022/1/21

 * @param

 * @return 

 */

@Data

public class WcsHuakangCron {

    private String cronId;//定时任务id

    private String taskName;//定时任务名称

    private String cron;//定时任务Cron表达式

    private String className;//定时任务任务类完整路径

    private String methodName;//定时任务任务类的方法名

    private String type;//类型

    private String state; //定时任务状态，0停用 1启用

    private String createBy;//创建人

    private Date createTime;//创建时间

    public String getCronId() {

        return cronId;

    }

    public void setCronId(String cronId) {

        this.cronId = cronId == null ? null : cronId.trim();

    }

    public String getTaskName() {

        return taskName;

    }

    public void setTaskName(String taskName) {

        this.taskName = taskName == null ? null : taskName.trim();

    }

    public String getCron() {

        return cron;

    }

    public void setCron(String cron) {

        this.cron = cron == null ? null : cron.trim();

    }

    public String getClassName() {

        return className;

    }

    public void setClassName(String className) {

        this.className = className == null ? null : className.trim();

    }

    public String getMethodName() {

        return methodName;

    }

    public void setMethodName(String methodName) {

        this.methodName = methodName == null ? null : methodName.trim();

    }

    public String getType() {

        return type;

    }

    public void setType(String type) {

        this.type = type == null ? null : type.trim();

    }

    public String getState() {

        return state;

    }

    public void setState(String state) {

        this.state = state == null ? null : state.trim();

    }

    public String getCreateBy() {

        return createBy;

    }

    public void setCreateBy(String createBy) {

        this.createBy = createBy == null ? null : createBy.trim();

    }

    public Date getCreate() {

        return createTime;

    }

    public void setCreate(Date createTime) {

        this.createTime = createTime;

    }

}

============mapper.xml=============================

<?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="com.penghaisoft.wcs.corn.model.dao.WcsHuakangCronMapper">

  <resultMap id="BaseResultMap" type="com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron">

    <id column="cron_id" jdbcType="VARCHAR" property="cronId" />

    <result column="task_name" jdbcType="VARCHAR" property="taskName" />

    <result column="cron" jdbcType="VARCHAR" property="cron" />

    <result column="class_name" jdbcType="VARCHAR" property="className" />

    <result column="method_name" jdbcType="VARCHAR" property="methodName" />

    <result column="type" jdbcType="VARCHAR" property="type" />

    <result column="state" jdbcType="VARCHAR" property="state" />

    <result column="create_by" jdbcType="VARCHAR" property="createBy" />

    <result column="create_time" jdbcType="TIMESTAMP" property="createTime" />

  </resultMap>

  <sql id="Base_Column_List">

    cron_id, task_name, cron, class_name, method_name, type, state, create_by, create_time

  </sql>

  <select id="selectByPrimaryKey" parameterType="java.lang.String" resultMap="BaseResultMap">

    select 

    <include refid="Base_Column_List" />

    from wcs_huakang_cron

    where cron_id = #{cronId,jdbcType=VARCHAR}

  </select>

  <!--查询所有的定时任务-->

  <select id="findAll"  resultMap="BaseResultMap">

    select

    <include refid="Base_Column_List" />

    from wcs_huakang_cron

  </select>

  <delete id="deleteByPrimaryKey" parameterType="java.lang.String">

    delete from wcs_huakang_cron

    where cron_id = #{cronId,jdbcType=VARCHAR}

  </delete>

  <insert id="insert" parameterType="com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron">

    insert into wcs_huakang_cron (cron_id, task_name, cron, 

      class_name, method_name, type, 

      state, create_by, create_time

      )

    values (#{cronId,jdbcType=VARCHAR}, #{taskName,jdbcType=VARCHAR}, #{cron,jdbcType=VARCHAR}, 

      #{className,jdbcType=VARCHAR}, #{methodName,jdbcType=VARCHAR}, #{type,jdbcType=VARCHAR}, 

      #{state,jdbcType=VARCHAR}, #{createBy,jdbcType=VARCHAR}, #{createTime,jdbcType=TIMESTAMP}

      )

  </insert>

  <insert id="insertSelective" parameterType="com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron">

    insert into wcs_huakang_cron

    <trim prefix="(" suffix=")" suffixOverrides=",">

      <if test="cronId != null">

        cron_id,

      </if>

      <if test="taskName != null">

        task_name,

      </if>

      <if test="cron != null">

        cron,

      </if>

      <if test="className != null">

        class_name,

      </if>

      <if test="methodName != null">

        method_name,

      </if>

      <if test="type != null">

        type,

      </if>

      <if test="state != null">

        state,

      </if>

      <if test="createBy != null">

        create_by,

      </if>

      <if test="createTime != null">

        create_time,

      </if>

    </trim>

    <trim prefix="values (" suffix=")" suffixOverrides=",">

      <if test="cronId != null">

        #{cronId,jdbcType=VARCHAR},

      </if>

      <if test="taskName != null">

        #{taskName,jdbcType=VARCHAR},

      </if>

      <if test="cron != null">

        #{cron,jdbcType=VARCHAR},

      </if>

      <if test="className != null">

        #{className,jdbcType=VARCHAR},

      </if>

      <if test="methodName != null">

        #{methodName,jdbcType=VARCHAR},

      </if>

      <if test="type != null">

        #{type,jdbcType=VARCHAR},

      </if>

      <if test="state != null">

        #{state,jdbcType=VARCHAR},

      </if>

      <if test="createBy != null">

        #{createBy,jdbcType=VARCHAR},

      </if>

      <if test="createTime != null">

        #{createTime,jdbcType=TIMESTAMP},

      </if>

    </trim>

  </insert>

  <update id="updateByPrimaryKeySelective" parameterType="com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron">

    update wcs_huakang_cron

    <set>

      <if test="taskName != null">

        task_name = #{taskName,jdbcType=VARCHAR},

      </if>

      <if test="cron != null">

        cron = #{cron,jdbcType=VARCHAR},

      </if>

      <if test="className != null">

        class_name = #{className,jdbcType=VARCHAR},

      </if>

      <if test="methodName != null">

        method_name = #{methodName,jdbcType=VARCHAR},

      </if>

      <if test="type != null">

        type = #{type,jdbcType=VARCHAR},

      </if>

      <if test="state != null">

        state = #{state,jdbcType=VARCHAR},

      </if>

      <if test="createBy != null">

        create_by = #{createBy,jdbcType=VARCHAR},

      </if>

      <if test="createTime != null">

        create_time = #{createTime,jdbcType=TIMESTAMP},

      </if>

    </set>

    where cron_id = #{cronId,jdbcType=VARCHAR}

  </update>

  <update id="updateByPrimaryKey" parameterType="com.penghaisoft.wcs.corn.model.entity.WcsHuakangCron">

    update wcs_huakang_cron

    set task_name = #{taskName,jdbcType=VARCHAR},

      cron = #{cron,jdbcType=VARCHAR},

      class_name = #{className,jdbcType=VARCHAR},

      method_name = #{methodName,jdbcType=VARCHAR},

      type = #{type,jdbcType=VARCHAR},

      state = #{state,jdbcType=VARCHAR},

      create_by = #{createBy,jdbcType=VARCHAR},

      create_time = #{createTime,jdbcType=TIMESTAMP}

    where cron_id = #{cronId,jdbcType=VARCHAR}

  </update>

</mapper>

 

 

 

樱梦雪苹宝
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot——创建定时任务（配合数据库动态执行）
命中的缘分的博客
11-15 2555
序言：创建定时任务非常简单，主要有两种创建方式：一、基于注解(@Scheduled) 二、基于接口（SchedulingConfigurer）. 前者相信大家都很熟悉，但是实际使用中我们往往想从数据库中读取指定时间来动态执行定时任务，这时候基于接口的定时任务就大派用场了。 一、静态定时任务（基于注解） 基于注解来创建定时任务非常简单，只需几行代码便可完成。 @Scheduled 除了支持灵活...
Spring Boot实现动态数据库配置
liinux-Talk is cheap,show me the code.
01-11 2999
1. 需求背景 ​ 在一些Web后台应用中，通常存在这样一种应用场景：当管理员第一次访问系统时，会自动跳转到系统初始化页面，要求管理员填写数据库主机地址，数据库名称，数据库管理员账户，数据库管理员密码以及系统的管理员账户和密码，然后点击安装按钮开始初始化后台数据，当后台数据初始化完成，页面将跳转到系统后台的登录页面。那么，如何使用Spring Boot完成这样一个功能呢？ ​ 在Spring ...
springboot双数据库定时同步
06-18
springboot双数据库定时同步,可以是mysql，SqlServer
基于springboot定时任务的后台管理，使用数据库配置定时任务相关信息，修改，关闭定时任务不需重启项目
yaoyipeng的博客
03-12 1974
创建完数据库，创建对应的ScheduledController，ScheduledService和ScheduledMapper和Scheduled实体类，相关代码我就不发了，控制层将定时任务相关信息修改后记得重启你修改过的定时任务，调用scheduledTaskService.restart(传入此定时任务的实体类信息);然后我们新建一个定时任务的公共接口，所有定时任务中的类（也就是表中的job_key字段填写的类名）都必须实现此接口。然后项目启动时初始化定时任务。首先创建定时任务线程池。
【quartz】从数据库中读取配置实现动态定时任务
qq_37634156的博客
06-25 4196
实现方式 1、定时任务表实体 2、反射调用scheduleJob中定义的方法 3、创建正常状态下的job执行工厂 4、若一个方法一次执行不完下次轮转时则等待改方法执行完后才执行下一次操作 5、创建需要运行的定时任务类 6、SpringBean工厂工具类 7、其他用到的工具类 字符串工具类 日志工具类 数据分析常量类 接口返回参数类 其中ResultEnum类如下： 8、sql语句 注释的很
基于数据库的动态定时任务
骑个小蜗牛的博客
01-25 2万+
文章目录1.实现原理2.源码解析数据库表实体类任务类调度配置类操作数据库Service定时任务初始化类刷新定时任务接口类3.注意事项 1.实现原理 @EnableScheduling开启任务调度； 自定义调度线程池； 数据库定义定时任务； 启动完成时，加载数据库定时任务并提交到线程池； 调用接口触发线程池中任务的更新（新增、删除、修改）； 2.源码解析 数据库表 CREATE TABLE `timed_task` ( `id` bigint(20) NOT NULL COMMENT '主键',
Springboot整合Quartz实现定时任务数据库动态配置
热门推荐
识时务者的个人博客
04-06 15万+
Springboot整合Quartz实现定时任务数据库动态配置
Springboot2.0.1整合Quartz动态定时任务
09-15
本文将深入探讨如何在SpringBoot 2.0.1版本中整合Quartz，实现动态定时任务，并结合MyBatis-Plus进行数据操作。 首先，我们要在SpringBoot项目中引入Quartz和MyBatis-Plus的依赖。在`pom.xml`文件中，添加如下依赖...
springboot整合quartz，实现数据库方式执行定时任务
11-19
如果需要动态管理定时任务，可以设计一个REST API来增删改查数据库中的`qrtz_jobs`、`qrtz_triggers`等相关表。 总结，通过Spring Boot整合Quartz，我们可以利用数据库存储定时任务，实现任务的灵活管理和持久化。...
springboot整合Quartz实现动态配置定时任务的方法
08-29
SpringBoot 整合 Quartz 实现动态配置定时任务的方法 SpringBoot 整合 Quartz 实现动态配置定时任务的方法是指在 SpringBoot 项目中使用 Quartz 框架来实现定时任务的动态配置。这种方法可以实现任务的动态添加、...
SpringBoot2.0整合Quartz定时任务,实现基于数据库如mysql的动态任务
12-27
在Spring Boot 2.0中整合Quartz定时任务，可以实现基于数据库如MySQL的动态任务管理，这在很多需要周期性执行任务的应用场景中非常实用。以下将详细讲解这一过程。 首先，我们要在项目的`pom.xml`文件中添加Quartz...
springboot启用定时任务
weixin_42260782的博客
10-26 379
项目里是一个配置类加一个任务类： 配置类SpringTaskConfig @Configuration @EnableScheduling public class SpringTaskConfig { } 任务类MyTask @Component public class MyTask { private Logger log = LoggerFactory.getLogger(MyTask.class); /** * 每日零点执行 */ @Schedule
springboot项目中的定时
qq_51770163的博客
05-19 1251
spring boot项目中的定时器
springboot实现定时任务定时查找数据库
浩浩的博客
08-03 840
定时任务
spring boot 实现定时任务（Spring Task）
最新发布
sumMStar的博客
03-01 1738
功能非常强大，是基于日历的作业调度，而是精准指定间隔，所以相比CroTrigger更加常用。CroTrigger是基于Cron表达式的。假如说，这个的意思是每隔15秒执行一次方法​ 为了方便用户设置定时任务，cron守护进程引入了一种简单的语法规则，即cron表达式。cron表达式由6个字段组成，分别表示秒、分、小时、日期、月份和星期几。每个字段都可以设置一个数字、一组数字（用逗号分隔）、一段数字范围（用短横线分隔）、通配符（表示任意值）或者特定的字符（如星期几的英文缩写）。
各数据库SQL查询结果多行数据合并成一行
qq_41512902的博客
07-08 3万+
各数据库SQL查询结果多行数据合并成一行
【定时任务】SpringBoot多线程并发动态执行定时任务
weixin_65690086的博客
07-14 3908
【定时任务】SpringBoot多线程并发动态执行定时任务
a标签只能点击一次/a标签点击一次后失效
yingmengxuepingbao的专栏
11-05 1万+
大家好： 在使用Spring MVC 后，做
springboot quartz 定时任务
08-27
- *2* *3* [SpringBoot整合Quartz实现定时任务](https://blog.csdn.net/qq_29305715/article/details/123517569)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值