Spring动态定时器

最新推荐文章于 2024-04-19 14:03:53 发布
最新推荐文章于 2024-04-19 14:03:53 发布
阅读量1.8k 收藏 2
点赞数 2
分类专栏： SSM动态定时器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/heima_2017/article/details/87888926
版权

大多数定时任务还是写在.xml配置里面的，这样写的最大缺点就是如果因为公司需要把定时任务执行的时间、或者是执行类更换，就需要修改.xml代码并重新提交发布版本才行。为此出了一种关联数据库动态设置定时任务技术,并可通过业务逻辑修改定时任务。
 

1. 我们需要在父项目的pom.xml文件中加入jar依赖：

<dependency><!--定时器-->
    <groupId>org.quartz-scheduler</groupId>
    <artifactId>quartz</artifactId>
    <version>1.8.6</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.11</version>
</dependency>

 2. 定义任务实体类

TaskProgramJob任务逻辑实体类,实现具体任务逻辑
package dmp.platform.model;

import dmp.platform.dao.VRepBookDao;
import dmp.platform.service.VTaskConfigService;
import org.quartz.Job;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;

import java.sql.Date;
import java.util.HashMap;
import java.util.Map;

public class TaskProgramJob implements Job {
    private VRepBookDao vRepBookDao;
    private VTaskConfigService vTaskConfigService;

    @Override
    public void execute(JobExecutionContext context) {
        //使用归并的JobDataMap
        JobDataMap dataMap = context.getJobDetail().getJobDataMap();
        String taskProgram = dataMap.getString("taskProgram");
        System.out.println("执行存储过程----------->   "+taskProgram+ "\t"+ System.currentTimeMillis());
        vRepBookDao = (VRepBookDao)dataMap.get("vRepBookDao");          //通过JobDataMap获取实例化对象赋值给属性
        vTaskConfigService = (VTaskConfigService)dataMap.get("vTaskConfigService");
        //执行存储过程参数
        Map map = new HashMap<>();
        map.put("date",new Date(System.currentTimeMillis()));  //系统时间
        map.put("procName",taskProgram);                            //存储过程名
        //获取组织Id
        String orgId = vRepBookDao.queryOrg_idByUsername(dataMap.getString("tcChangeuser"));
        map.put("orgId",orgId);

        //执行存储过程
        boolean flag = vTaskConfigService.executeStoredProcedure(map);
        if(flag){
            System.out.println("任务执行成功");
        }else{
            System.out.println("任务执行失败");
        }
    }

}

QuartzService初始化任务类,实现InitializingBean接口,在项目启动时自动运行一次重写的afterPropertiesSet方法,实现任务初始化
package dmp.platform.service;

import dmp.platform.dao.VRepBookDao;
import dmp.platform.model.TaskProgramJob;
import dmp.platform.model.VTaskConfig;
import dmp.platform.util.QuartzUtil;
import org.apache.log4j.Logger;
import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;

@Service
public class QuartzService implements InitializingBean {

    private Logger log = Logger.getLogger(QuartzService.class);

    //默认的任务组名，触发器组名
    @Value("${quartz.job_group_name}")
    private String JOB_GROUP_NAME ;
    @Value("${quartz.trigger_group_name}")
    private String TRIGGER_GROUP_NAME ;

    @Resource
    private VTaskConfigService vTaskConfigService;
    @Resource
    private VRepBookDao vRepBookDao;

    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("【系统启动】所有定时任务开启...");
        // 1- 根据条件从数据库获取定时任务详情
        List<VTaskConfig> jobList = vTaskConfigService.getTaskConfig();
        if (jobList == null || jobList.isEmpty()) {
            return;
        }

        // 2- 获取Scheduler
        Scheduler scheduler = QuartzUtil.scheduler;

        // 3- 循环添加数据库中的任务
        for (VTaskConfig j : jobList) {
            if (j.getIfStart()==1) {//启动定时器
                //任务设置
                JobDetail jobDetail = new JobDetail(j.getTaskId(), JOB_GROUP_NAME, TaskProgramJob.class);// 任务名，任务组，任务执行类
                JobDataMap jobDataMap = new JobDataMap();
                jobDataMap.put("taskProgram", j.getTaskProgram());
                jobDataMap.put("tcChangeuser", j.getTcChangeuser());  //任务创建者
                jobDataMap.put("vRepBookDao", vRepBookDao);  //在quartz中无法通过注解注入VRepBookDao属性,需要将spring注解创建的实例化bean通过JobDataMap传到job对象中
                jobDataMap.put("vTaskConfigService", vTaskConfigService);       //也不能new对象,因为new出来的实例中的属性无法通过spring注解自动注入
                jobDetail.setJobDataMap(jobDataMap);

                // 触发器
                CronTrigger trigger = new CronTrigger(j.getTaskId(), TRIGGER_GROUP_NAME);// 触发器名,触发器组
                String cronExpression = QuartzUtil.getCronExpression(j);
                System.out.println("定时时间: "  + cronExpression);
                trigger.setCronExpression(cronExpression);// 触发器时间设定
                scheduler.scheduleJob(jobDetail, trigger);

                // 启动
                if (!scheduler.isShutdown()) {
                    scheduler.start();
                }

                System.out.println("添加定时任务[jobName] -  " + j.getTaskProgram() + "---------" + j.getTaskId() + "&" + JOB_GROUP_NAME + "&" + TRIGGER_GROUP_NAME + "||||scheduler:  " + scheduler);
                log.info("添加定时任务[jobName] -  " + j.getTaskProgram());
            }
        }
    }
}

spring配置文件
默认的任务组名，触发器组名

扫描任务类QuartzUtil和TaskProgramJob,装配到spring的Bean容器中


QuartzUtil任务工具类,实现任务的增,删,改

package dmp.platform.util;

import dmp.platform.dao.VRepBookDao;
import dmp.platform.model.TaskProgramJob;
import dmp.platform.model.VTaskConfig;
import dmp.platform.service.VTaskConfigService;
import org.quartz.*;
import org.quartz.impl.StdSchedulerFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component   //标识此类自动装配到spring的bean容器中
public class QuartzUtil {

    //默认的任务组名，触发器组名
    @Value("${quartz.job_group_name}")
    private String JOB_GROUP_NAME ;
    @Value("${quartz.trigger_group_name}")
    private String TRIGGER_GROUP_NAME ;

    public static Scheduler scheduler;

    //静态代码块,在scheduler静态成员变量初始化之后执行一次,确保scheduler的唯一性
    static {
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        try {
            scheduler =  schedulerFactory.getScheduler();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }
    }

    @Resource
    private VTaskConfigService vTaskConfigService;
    @Resource
    private VRepBookDao vRepBookDao;

    /**
     * SchedulerFactory使用获取Scheduler
     *
     * @return
     * @throws Exception
     */
    /*private static Scheduler getScheduler() throws Exception {
        SchedulerFactory scheduler = new StdSchedulerFactory();
        return scheduler.getScheduler();
    }*/

    /**
     * @Author: xzh
     * @Date: Created in 09:56 2019/2/18 0018
     * @Description: 添加默认的任务组名,触发器组名的定时器
     */
    //添加定时任务
    public void addJob(VTaskConfig j) {
        try {

            JobDetail jobDetail = new JobDetail(j.getTaskId(), JOB_GROUP_NAME, TaskProgramJob.class);// 任务名，任务组，任务执行类
            JobDataMap jobDataMap = new JobDataMap();

            /*传递实例化对象
             *在quartz中无法通过注解注入VRepBookDao属性,需要将spring注解创建的实例化bean通过JobDataMap传到job对象中
             *也不能new对象,因为new出来的实例中的属性无法通过spring注解自动注入  */
            jobDataMap.put("vRepBookDao", vRepBookDao);
            jobDataMap.put("vTaskConfigService", vTaskConfigService);

            //传递参数
            jobDataMap.put("taskProgram", j.getTaskProgram());
            jobDataMap.put("tcChangeuser", j.getTcChangeuser());  //任务创建者
            jobDetail.setJobDataMap(jobDataMap);

            // 触发器
            CronTrigger trigger = new CronTrigger(j.getTaskId(), TRIGGER_GROUP_NAME);// 触发器名,触发器组
            String cronExpression = getCronExpression(j);
            trigger.setCronExpression(cronExpression);// 触发器时间设定
            scheduler.scheduleJob(jobDetail, trigger);

            // 启动
            if (!scheduler.isShutdown()) {
                scheduler.start();
            }
            System.out.println("添加定时任务[jobName] -  " + j.getTaskId() + "定时: " + cronExpression);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }

    }

    //修改定时任务
    public void modifyJob(VTaskConfig j) {
        try {
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(j.getTaskId(),TRIGGER_GROUP_NAME);
            if (trigger == null) {
                return;
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("修改定时任务[jobName] -  " + j.getTaskId());
        removeJob(j.getTaskId());
        addJob(j);

    }

    /**
     * @Description: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
     */
    public void removeJob(String jobName) {
        try {
            scheduler.pauseTrigger(jobName, TRIGGER_GROUP_NAME);// 停止触发器
            scheduler.unscheduleJob(jobName, TRIGGER_GROUP_NAME);// 移除触发器
            scheduler.deleteJob(jobName, JOB_GROUP_NAME);// 删除任务
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        System.out.println("删除定时任务[jobName] -  " + jobName);
    }

    /**
     * @Description: 解析VTaskConfig,获取定时器设置时间
     */
    public static String getCronExpression(VTaskConfig v){
        StringBuilder cron  = new StringBuilder("0 0 0 ");//0秒0分0时
        String day = v.getTriggerDay();                         //日
        String week = v.getTriggerWeek();                       //周
        String month = v.getTriggerMonth();                     //月
        switch(v.getTriggerType()){
            case 0://按日
                cron.append(day);  //日
                cron.append(" * ?");  //每月
                break;
            case 1://按周
                cron.append("? * ");
                int i = 0;
                if(week.charAt(0)=='1'){
                    System.out.println();
                    cron.append("2");
                    i++;
                }
                if(week.charAt(1)=='1'){
                    if(i==1){
                        cron.append(",");
                        i--;//归零
                    }
                    cron.append("3");
                    i++;
                }
                if(week.charAt(2)=='1'){
                    if(i==1){
                        cron.append(",");
                        i--;//归零
                    }
                    cron.append("4");
                    i++;
                }
                if(week.charAt(3)=='1'){
                    if(i==1){
                        cron.append(",");
                        i--;//归零
                    }
                    cron.append("5");
                    i++;
                }
                if(week.charAt(4)=='1'){
                    if(i==1){
                        cron.append(",");
                        i--;//归零
                    }
                    cron.append("6");
                    i++;
                }
                if(week.charAt(5)=='1'){
                    if(i==1){
                        cron.append(",");
                        i--;//归零
                    }
                    cron.append("7");
                    i++;
                }
                if(week.charAt(6)=='1'){
                    if(i==1){
                        cron.append(",");
                        i--;//归零
                    }
                    cron.append("1");
                    i++;
                }
                break;
            case 2://按月
                cron.append(day);//日
                cron.append(" * ?");
                break;
            case 3://按季
                Integer mon1 = Integer.valueOf(month);
                cron.append(day);//日
                cron.append(" ");
                cron.append(mon1);
                cron.append(",");
                cron.append(mon1+3);
                cron.append(",");
                cron.append(mon1+6);
                cron.append(" ?");
                break;
            case 4://按半年
                Integer mon2 = Integer.valueOf(month);
                cron.append(day);//日
                cron.append(" ");
                cron.append(mon2);
                cron.append(",");
                cron.append(mon2+6);
                cron.append(" ?");
                break;
            case 5://按年
                cron.append(day);//日
                cron.append(" ");
                cron.append(month);
                cron.append(" ?");
                break;
        }
        return cron.toString();
    }
}

VTaskConfig任务属性实体类,任务的属性,时间等参数

 

package dmp.platform.model;

import dmp.framework.model.BaseModel;

import java.sql.Date;


public class VTaskConfig extends BaseModel {

   /**
    * serialVersionUID. 
    */
   private static final long serialVersionUID = -1L;
   
   private Integer triggerType; //触发方式 0：按日   1：按周  2：按月 3:按季  4按半年   5：按年
   private String triggerMonth; //触发周期_月份
   private String triggerDay; //周期_日期
   private String triggerWeek; //触发周期_周：从周一开始，周日结束格式0000000，0：不触发 1：触发
   private Integer ifStart; //启动标志 0:停止 1:启动
   private String taskId; //任务编号
   private String taskProgram; //对应程序
   private String taskIdRely; //依赖任务编号
   private String taskType; //任务大类 0：业务任务  1：初始化任务
   private Date tcCreatedate; //创建日期
   private Date tcChangedate; //修改日期
   private String tcCreateuser; //创建人
   private String tcChangeuser; //修改人
   
   /**
    * 取得"触发方式 0：按日   1：按周  2：按月 3:按季  4按半年   5：按年"
    * @return 返回"触发方式 0：按日   1：按周  2：按月 3:按季  4按半年   5：按年"
    */
   public Integer getTriggerType(){
      return this.triggerType;
   }
   /**
    * 设置"触发方式 0：按日   1：按周  2：按月 3:按季  4按半年   5：按年"的值
    * @param triggerType 触发方式 0：按日   1：按周  2：按月 3:按季  4按半年   5：按年
    */
   public void setTriggerType(Integer triggerType){
      this.triggerType = triggerType;
   }
   /**
    * 取得"触发周期_月份"
    * @return 返回"触发周期_月份"
    */
   public String getTriggerMonth(){
      return this.triggerMonth;
   }
   /**
    * 设置"触发周期_月份"的值
    * @param triggerMonth 触发周期_月份
    */
   public void setTriggerMonth(String triggerMonth){
      this.triggerMonth = triggerMonth;
   }
   /**
    * 取得"周期_日期"
    * @return 返回"周期_日期"
    */
   public String getTriggerDay(){
      return this.triggerDay;
   }
   /**
    * 设置"周期_日期"的值
    * @param triggerDay 周期_日期
    */
   public void setTriggerDay(String triggerDay){
      this.triggerDay = triggerDay;
   }
   /**
    * 取得"触发周期_周：从周一开始，周日结束格式0000000，0：不触发 1：触发"
    * @return 返回"触发周期_周：从周一开始，周日结束格式0000000，0：不触发 1：触发"
    */
   public String getTriggerWeek(){
      return this.triggerWeek;
   }
   /**
    * 设置"触发周期_周：从周一开始，周日结束格式0000000，0：不触发 1：触发"的值
    * @param triggerWeek 触发周期_周：从周一开始，周日结束格式0000000，0：不触发 1：触发
    */
   public void setTriggerWeek(String triggerWeek){
      this.triggerWeek = triggerWeek;
   }
   /**
    * 取得"启动标志 0:停止 1:启动"
    * @return 返回"启动标志 0:停止 1:启动"
    */
   public Integer getIfStart(){
      return this.ifStart;
   }
   /**
    * 设置"启动标志 0:停止 1:启动"的值
    * @param ifStart 启动标志 0:停止 1:启动
    */
   public void setIfStart(Integer ifStart){
      this.ifStart = ifStart;
   }
   /**
    * 取得"任务编号"
    * @return 返回"任务编号"
    */
   public String getTaskId(){
      return this.taskId;
   }
   /**
    * 设置"任务编号"的值
    * @param taskId 任务编号
    */
   public void setTaskId(String taskId){
      this.taskId = taskId;
   }
   /**
    * 取得"对应程序"
    * @return 返回"对应程序"
    */
   public String getTaskProgram(){
      return this.taskProgram;
   }
   /**
    * 设置"对应程序"的值
    * @param taskProgram 对应程序
    */
   public void setTaskProgram(String taskProgram){
      this.taskProgram = taskProgram;
   }
   /**
    * 取得"依赖任务编号"
    * @return 返回"依赖任务编号"
    */
   public String getTaskIdRely(){
      return this.taskIdRely;
   }
   /**
    * 设置"依赖任务编号"的值
    * @param taskIdRely 依赖任务编号
    */
   public void setTaskIdRely(String taskIdRely){
      this.taskIdRely = taskIdRely;
   }
   /**
    * 取得"任务大类 0：业务任务  1：初始化任务"
    * @return 返回"任务大类 0：业务任务  1：初始化任务"
    */
   public String getTaskType(){
      return this.taskType;
   }
   /**
    * 设置"任务大类 0：业务任务  1：初始化任务"的值
    * @param taskType 任务大类 0：业务任务  1：初始化任务
    */
   public void setTaskType(String taskType){
      this.taskType = taskType;
   }
   /**
    * 取得"创建日期"
    * @return 返回"创建日期"
    */
   public Date getTcCreatedate(){
      return this.tcCreatedate;
   }
   /**
    * 设置"创建日期"的值
    * @param tcCreatedate 创建日期
    */
   public void setTcCreatedate(Date tcCreatedate){
      this.tcCreatedate = tcCreatedate;
   }
   /**
    * 取得"修改日期"
    * @return 返回"修改日期"
    */
   public Date getTcChangedate(){
      return this.tcChangedate;
   }
   /**
    * 设置"修改日期"的值
    * @param tcChangedate 修改日期
    */
   public void setTcChangedate(Date tcChangedate){
      this.tcChangedate = tcChangedate;
   }
   /**
    * 取得"创建人"
    * @return 返回"创建人"
    */
   public String getTcCreateuser(){
      return this.tcCreateuser;
   }
   /**
    * 设置"创建人"的值
    * @param tcCreateuser 创建人
    */
   public void setTcCreateuser(String tcCreateuser){
      this.tcCreateuser = tcCreateuser;
   }
   /**
    * 取得"修改人"
    * @return 返回"修改人"
    */
   public String getTcChangeuser(){
      return this.tcChangeuser;
   }
   /**
    * 设置"修改人"的值
    * @param tcChangeuser 修改人
    */
   public void setTcChangeuser(String tcChangeuser){
      this.tcChangeuser = tcChangeuser;
   }

}

3.  创建定时任务详细表（即用来存储的所有的定时任务信息,与VTaskConfig实体类关联），这里用的是Oracle

create table V_TASK_CONFIG
(
  trigger_type  NUMBER(1),
  trigger_month VARCHAR2(7),
  trigger_day   VARCHAR2(4),
  trigger_week  VARCHAR2(7),
  if_start      NUMBER(1),
  task_id       VARCHAR2(10) not null,
  task_program  VARCHAR2(100),
  task_id_rely  VARCHAR2(10),
  task_type     VARCHAR2(4),
  tc_createdate DATE,
  tc_changedate DATE,
  tc_createuser VARCHAR2(12),
  tc_changeuser VARCHAR2(12)
)

输入数据如下图

4. service层VTaskConfigService中对任务进行增删改

package dmp.platform.service;

import dmp.framework.db.IEntityDao;
import dmp.framework.service.BaseService;
import dmp.platform.dao.VTaskConfigDao;
import dmp.platform.model.VTaskConfig;
import dmp.platform.util.QuartzUtil;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.sql.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

@Service
public class VTaskConfigService extends BaseService<VTaskConfig> {

    @Resource
    private VTaskConfigDao vTaskConfigDao;
    @Resource
    private QuartzUtil quartzUtil;

    @Override
    protected IEntityDao<VTaskConfig, Long> getEntityDao() {
        // TODO Auto-generated method stub
        return vTaskConfigDao;
    }

    /**
     * @Author: xzh
     * @Date: Created in 16:28 2019/1/28 0028
     * @Description: 添加任务
     */
    public String addTaskConfig(VTaskConfig taskConfig) {
        //校验录入的"对应程序",是否已存在
        Map map = new HashMap();
        int count = vTaskConfigDao.queryTaskProgram(taskConfig);
        if (count != 0) {
            return "系统已经存在重复的'对应程序'信息，请重新选择";
        }
        taskConfig.setTcCreatedate(new Date(System.currentTimeMillis()));
        taskConfig.setTcChangedate(new Date(System.currentTimeMillis()));

        //获取任务唯一主键Id,亦是任务的jobName,通过此唯一任务名对任务进行增删改
        String taskId = vTaskConfigDao.getTaskId();
        taskConfig.setTaskId(taskId);

        int n = vTaskConfigDao.insert(taskConfig);
        if (n == 1) {
            if(taskConfig.getIfStart()==1){
                quartzUtil.addJob(taskConfig);//添加定时任务
            }
            return "任务设置成功";
        } else {
            return "任务设置失败,请联系管理员!";
        }
    }

    /**
     * @Author: xzh
     * @Date: Created in 10:47 2019/1/30 0030
     * @Description: 修改任务
     */
    public String updateTaskConfig(VTaskConfig taskConfig) {
        //校验录入的"对应程序",是否已存在
        Map map = new HashMap();
        int count = vTaskConfigDao.queryTaskProgram(taskConfig);
        if (count != 0) {
            return "系统已经存在重复的'对应程序'信息，请重新选择";
        }
        taskConfig.setTcChangedate(new Date(System.currentTimeMillis()));

        int n = vTaskConfigDao.update(taskConfig);
        if (n == 1) {
            if(taskConfig.getIfStart()==1){
                quartzUtil.modifyJob(taskConfig);//修改定时任务
            }
            return "任务修改成功";
        } else {
            return "任务修改失败,请联系管理员!";
        }
    } 
}

 

 

学无止境@#$%^
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring整合Quartz实现动态定时器
2401_83412087的博客
03-31 977
** 方式二 ：先删除，然后在创建一个新的Job *//** 方式二：先删除，然后在创建一个新的Job */
Spring整合Quartz实现动态定时器，顺利通过阿里Java岗面试
m0_61072747的博客
03-18 568
对于面试还是要好好准备的，尤其是有些问题还是很容易挖坑的，例如你为什么离开现在的公司（你当然不应该抱怨现在的公司有哪些不好的地方，更多的应该表明自己想要寻找更好的发展机会，自己的一些现实因素，比如对于我而言是现在应聘的公司离自己的家更近，又或者是自己工作到达了迷茫期，想跳出迷茫期等等）Java面试精选题、架构实战文档你的支持，我的动力；祝各位前程似锦，offer不断！的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
SpringBoot 实现定时任务动态管理，太爽了
欧菲丽的博客
06-19 598
SpringBoot的定时任务的加强工具，实现对SpringBoot原生的定时任务进行动态管理,完全兼容原生@Scheduled注解,无需对原本的定时任务进行修改。
【Spring】@Scheduled 定时器注解使用
最新发布
杜小舟的博客
04-19 946
@Scheduled注解用于在Spring框架中为方法配置定时任务。这允许在一定的时间间隔或在特定的时间点运行方法。@Scheduled注解可以应用于任何方法中，但这些方法通常位于服务类中。
Springboot 设置动态定时任务，千万别写死了
Pollias的博客
12-12 802
spring boot动态定时任务，CronTrigger ，PeriodicTrigger
spring动态定时器
xlin
06-14 113
0 0/5 * * * ? 4 package com.util.task; import ...
spring动态定时器封装
03-28
本文将深入探讨如何在Spring框架中进行动态定时器的封装，结合标签"源码"和"工具"，我们将探讨Spring与Quartz库的整合，以及如何通过源码理解其实现机制。 首先，让我们了解一下Spring的定时任务支持。Spring提供了...
Spring中的Quartz配置-Spring-定时器-java定时器.doc
06-27
Spring 中的 Quartz 配置-Spring 定时器-java 定时器 在 Spring 框架中，Quartz 是一个非常流行的开源作业调度器，可以实现任务的定时执行。在本篇文章中，我们将讨论如何在 Spring 中配置 Quartz，以实现 Java ...
Spring Boot定时器创建及使用解析
08-18
Spring Boot 定时器创建及使用解析 Spring Boot 是一个基于 Java 语言的框架，提供了一个灵活的方式来创建 Web 应用程序。在实际开发中，我们经常需要在后端执行一些定时任务，以便实现自动刷新数据、发送邮件、...
spring设置动态定时任务
11-28
spring设置动态定时任务，spring 定时器
Spring的定时器动态修改参数cron的值
03-20
动态修改参数cron的值来实现Spring自带定时器动态的执行任务
spring 动态定时器
a1b19pm的博客
08-09 98
Quartz在Spring中动态设置cronExpression （spring设置动态定时任务） 什么是动态定时任务：是由客户制定生成的，服务端只知道该去执行什么任务，但任务的定时是不确定的（是由客户制定）。 这样总不能修改配置文件每定制个定时任务就增加一个trigger吧，即便允许客户修改配置文件，但总需要重新启动web服务啊，研究了下Quartz在Spring中的动态定时，发现...
springtask定时任务执行时间动态配置。
xiaoWangZi89的博客
12-21 1683
说明：这里的动态配置是指，执行时间配置不在工程文件下，即修改执行时间不需要重新打包，只需要修改外部配置，重新启动就可以了， 1、准备工作： 先写一个定时任务，可以正常运行，再考虑动态配置。 2、文件位置 再pom文件的同级别目录下新建文件夹config,新建文件task.yml（也可以不引入文件夹，注意引入的时候路径正确就行） task-expire-cron: 0/2 * * * * ? ##每两秒执行一次。 3，在任务类上加注解， 引入配置的文件。 @PropertySource(value =
Cron表达式
cychai的专栏
09-07 1707
Cron表达式Quartz使用类似于Linux下的Cron表达式定义时间规则，Cron表达式由6或7个由空格分隔的时间字段组成，如表1所示：表1 Cron表达式时间字段 位置时间域名允许值允许的特殊字符1秒0-59, - * /2分钟
springboot 动态配置定时器
热门推荐
做对一件事很重要
01-02 3万+
写在前面：本文采取的环境 1.docker下的mysql（便于读者测试，本人将开放该mysql服务连接（jdbc: mysql://47.99.200.71:3306/test?allowMultiQueries=true&amp;useUnicode=true&amp;characterEncoding=utf8&amp;autoReconnect=true&amp;useSSL=true），便...
Spring 实现动态定时任务
For-的博客
06-12 3780
平时我们使用 Spring 去实现一个单体项目的定时任务，用得比较多的是 注解，但是该注解的局限性是不能动态的更改定时任务的时间；这时就需要使用其他方式去实现动态的定时任务了，Spring 给我们提供了 接口，使用它就能够实现动态的定时任务。直接实现 接口即能做到动态的修改定时任务的时间，下面先写一个配置类 。注：别忘了添加 注解 需要重写 方法，该方法会在应用启动完成后自动调用，其中参数为 类型，从下图看来添加任务有几种类型，分别是固定 corn 表达式的任务（与 一样）、固定延时与固定速率任
spring boot动态设置定时任务
六六的小帅的博客
04-28 555
spring boot定时任务进阶
Spring内置定时器实现
07-14
以下是Spring内置的定时器实现方式： 1. 使用`@Scheduled`注解：在需要执行定时任务的方法上添加`@Scheduled`注解，并配置相应的定时任务表达式。例如： ```java import org.springframework.scheduling....

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值