精华内容
下载资源
问答
  • 定时器—有时也称为动态定时器或内核定时器—是管理内核时间的基础。定时器是一种软件功能,即允许在将来的某个时刻,函数在给定的时间间隔用完时被调用。注意的是定时器并不会周期运行,它在超时后自行销毁,这也是...
  • 动态定时器quartz,可以用来动态跑批等执行任务!放在别的框架里面也能使用,主要看代码!
  • 主要介绍了SpringBoot 动态定时器的使用方法,非常不错,具有一定的参考借鉴借鉴价值,需要的朋友可以参考下
  • spring动态定时器

    2019-08-13 01:21:11
    NULL 博文链接:https://xianlincai.iteye.com/blog/2304856
  • 动态定时器

    2019-10-19 02:23:05
    * 动态定时器 ,表达式网址 http://cron.qqe2.com/ */ @Component public class DynamicScheduledTask implements SchedulingConfigurer { @Autowired private MenuMapper menuMapper; @Override public ...
    package com.springboot.demo.controller;
    
    import com.springboot.demo.entity.Menu;
    import com.springboot.demo.mapper.MenuMapper;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.stereotype.Component;
    
    import java.util.Date;
    import java.util.HashMap;
    import java.util.Map;
    
    /**
     * 动态定时器   ,表达式网址 http://cron.qqe2.com/
     */
    @Component
    public class DynamicScheduledTask implements SchedulingConfigurer {
    
        @Autowired
        private MenuMapper menuMapper;
    
        @Override
        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
            taskRegistrar.addTriggerTask(() -> {
                // 定时任务的业务逻辑
                aa();
    
    
            }, triggerContext -> {//设置下次定时器
                Map<String, Object> map = new HashMap<>();
                map.put("id", 9);
                Menu menu = menuMapper.findSingle(map);
    //                String cron = "0 " + minute + " " + hour + " * * " + day + "";
                String cron = "0/" + menu.getPid() + " * *  * * ? ";   // menu.getPid()秒执行1次
                System.out.println(cron);
    
                CronTrigger trigger = new CronTrigger(cron); // 定时任务触发,可修改定时任务的执行周期
    
                Date nextExecDate = trigger.nextExecutionTime(triggerContext);
                return nextExecDate;
            });
        }
    
    
        /**
         * desc:
         * param:
         * author: CDN
         * date: 2019/10/19
         */
        public void aa() {
            System.out.println("提醒打卡");
        }
    }
    
    
    

     

    展开全文
  • Java 动态定时器

    2017-08-30 18:31:59
    java 动态定时器,可以动态管理定时任务。 本Java 动态定时器基于Java的定时器线程池,阻塞队列实现,定时调度时间采用cron表达式配置的方式,其中cron表达式解析工具类提取自spring。 用法极其简单,只需要将...
  • 实用结合C#反射实现动态定时器定时任务工具,可结合XML配置文档,实现独立动态的定时配置;用于定时任务执行、消息推送、WebService任务等;附件为程序源码。工具历经多项目验证,不足之处;欢迎交流指正!
  • 本篇文章主要介绍了Spring整合Quartz实现动态定时器的示例代码,具有一定的参考价值,感兴趣的小伙伴们可以参考一下。
  • 关于在项目中的定时任务,我了解的不够深入,如果有兴趣可以去看下xxl-job,本篇仅仅介绍写在项目中的代码来...静态的定时器任务执行完全依赖注解,动态的则需要与数据库一起进行执行 静态定时器 在config包下添...

    关于在项目中的定时任务,我了解的不够深入,如果有兴趣可以去看下xxl-job,本篇仅仅介绍写在项目中的代码来实现定时任务的功能,分为两个方面,一个是静态,一个是动态。

    实现定时器依赖的是spring封装好的@Schedule注解,通过这个注解我们来实现了定时任务的执行,所以我们不需要依赖的引入。

    静态的定时器任务执行完全依赖注解,动态的则需要与数据库一起进行执行

    静态定时器


    在config包下添加配置类SimpleScheduleConfig

    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.Scheduled;
    
    import java.time.LocalDateTime;
    
    @Configuration //1.主要用于标记配置类,兼备Component的效果。
    @EnableScheduling // 2.开启定时任务
    public class SimpleScheduleConfig {
        //3.添加定时任务
        @Scheduled(cron = "0/5 * * * * ?")
        private void configureTasks() {
            System.err.println("执行静态定时任务: " + LocalDateTime.now());
        }
    }
    

    直接启动项目,运行结果如下:

    执行静态定时任务: 2019-11-30T16:21:40.011
    执行静态定时任务: 2019-11-30T16:21:45.002
    执行静态定时任务: 2019-11-30T16:21:50.001

    动态定时器


    在config包下添加配置类CompleteScheduleConfig

    import org.apache.ibatis.annotations.Mapper;
    import org.apache.ibatis.annotations.Select;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.util.StringUtils;
    
    import java.time.LocalDateTime;
    
    @Configuration
    @EnableScheduling
    public class CompleteScheduleConfig implements SchedulingConfigurer {
    
        @Mapper
        public interface CronMapper {
            @Select("select cron from cron limit 1")
            String getCron();
        }
    
        @Autowired
        @SuppressWarnings("all")
        CronMapper cronMapper;
    
        /**
         * 执行定时任务.
         */
        @Override
        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
            taskRegistrar.addTriggerTask(
                    //1.添加任务内容(Runnable)
                    () -> System.out.println("执行定时任务2: " + LocalDateTime.now().toLocalTime()),
                    //2.设置执行周期(Trigger)
                    triggerContext -> {
                        //2.1 从数据库获取执行周期
                        String cron = cronMapper.getCron();
                        //2.2 合法性校验.
                        if (StringUtils.isEmpty(cron)) {
                            // Omitted Code ..
                        }
                        //2.3 返回执行周期(Date)
                        return new CronTrigger(cron).nextExecutionTime(triggerContext);
                    }
            );
        }
    }
    

    在数据库中添加数据表,并且添加数据

    CREATE TABLE `cron`  (
      `cron_id` varchar(30),
      `cron` varchar(30) 
    );
    INSERT INTO `cron` VALUES ('1', '0/5 * * * * ?');
    

    在这里插入图片描述
    配置好数据库和配置类,就可以启动查看效果了

    执行动态定时任务: 16:25:50.004
    执行动态定时任务: 16:25:55.001
    执行动态定时任务: 16:26:00.001

    我们可以修改数据库的值来改变定时任务的执行频率为2s一次
    在这里插入图片描述
    代码运行会获得如下结果:

    执行定时任务2: 16:28:28.002
    执行定时任务2: 16:28:30.001
    执行定时任务2: 16:28:32.002

    cron定时表达式表达说明

    cron一共有7位,但是最后一位是年,可以留空,所以我们可以写6位:

    * 第一位,表示秒,取值0-59
    * 第二位,表示分,取值0-59
    * 第三位,表示小时,取值0-23
    * 第四位,日期天/日,取值1-31
    * 第五位,日期月份,取值1-12
    * 第六位,星期,取值1-7,星期一,星期二...,注:不是第1周,第二周的意思
              另外:1表示星期天,2表示星期一。
    * 第7为,年份,可以留空,取值1970-2099
    

    一些特殊符号的含义:

    (*)星号:可以理解为每的意思,每秒,每分,每天,每月,每年...
    (?)问号:问号只能出现在日期和星期这两个位置,表示这个位置的值不确定,每天3点执行,所以第六位星期的位置,我们是不需要关注的,就是不确定的值。同时:日期和星期是两个相互排斥的元素,通过问号来表明不指定值。比如,1月10日,比如是星期1,如果在星期的位置是另指定星期二,就前后冲突矛盾了。
    (-)减号:表达一个范围,如在小时字段中使用“10-12”,则表示从10到12点,即10,11,12
    (,)逗号:表达一个列表值,如在星期字段中使用“1,2,4”,则表示星期一,星期二,星期四
    (/)斜杠:如:x/y,x是开始值,y是步长,比如在第一位(秒) 0/15就是,从0秒开始,每15秒,最后就是0,15,30,45,60    另:*/y,等同于0/y
    

    附表:

    "0 0 12 * * ?" 每天中午12点触发 
    "0 15 10 ? * *" 每天上午10:15触发 
    "0 15 10 * * ?" 每天上午10:15触发 
    "0 15 10 * * ? *" 每天上午10:15触发 
    "0 15 10 * * ? 2005" 2005年的每天上午10:15触发 
    "0 * 14 * * ?" 在每天下午2点到下午2:59期间的每1分钟触发 
    "0 0/5 14 * * ?" 在每天下午2点到下午2:55期间的每5分钟触发 
    "0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发 
    "0 0-5 14 * * ?" 在每天下午2点到下午2:05期间的每1分钟触发 
    "0 10,44 14 ? 3 WED" 每年三月的星期三的下午2:10和2:44触发 
    "0 15 10 ? * MON-FRI" 周一至周五的上午10:15触发 
    "0 15 10 15 * ?" 每月15日上午10:15触发 
    "0 15 10 L * ?" 每月最后一日的上午10:15触发 
    "0 15 10 ? * 6L" 每月的最后一个星期五上午10:15触发 
    "0 15 10 ? * 6L 2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
    "0 15 10 ? * 6#3" 每月的第三个星期五上午10:15触发 
    每隔5秒执行一次:*/5 * * * * ?
    每隔1分钟执行一次:0 */1 * * * ?
    每天23点执行一次:0 0 23 * * ?
    每天凌晨1点执行一次:0 0 1 * * ?
    每月1号凌晨1点执行一次:0 0 1 1 * ?
    每月最后一天23点执行一次:0 0 23 L * ?
    每周星期天凌晨1点实行一次:0 0 1 ? * L
    

    crontab 表达式在线生成 http://cron.qqe2.com/

    参考文章


    springboot干货——(十五)整合定时任务schedule

    SpringBoot 创建定时任务(配合数据库动态执行)

    本系列文章


    Banana的SpringBoot系列博客

    (一) SpringBoot 项目初始化 + 配置swagger页面

    (二) SpringBoot 整合 MyBatis-plus

    (三) SpringBoot之使用Swagger配置详解

    (四) spring boot 多环境配置

    (五) spring boot 配置使用 redis

    (六) spring boot 整合rabbitmq 与 rabbitmq使用教程

    (七) spring boot 接口返回结果封装&&对象json的转换

    (八) spring boot 整合异常封装

    展开全文
  • Spring动态定时器

    千次阅读 2019-02-23 10:53:51
    为此出了一种关联数据库动态设置定时任务技术,并可通过业务逻辑修改定时任务。   1. 我们需要在父项目的pom.xml文件中加入jar依赖: &lt;dependency&gt;&lt;!--定时器--&gt; &lt;...

    大多数定时任务还是写在.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 "任务修改失败,请联系管理员!";
            }
        } 
    }

     

     

    展开全文
  • SpringBoot使用定时器使用方法添加@Scheduled注解 设计cron参数即可package com.clsystem.Comm; import org.springframework.scheduling.annotation.Scheduled; /** * Created by pudding on 2017-11-10.(打卡...

    SpringBoot使用定时器使用方法添加@Scheduled注解 设计cron参数即可

    package com.clsystem.Comm;
    
    import org.springframework.scheduling.annotation.Scheduled;
    
    /**
     * Created by pudding on 2017-11-10.(打卡记录定时任务)
     */
    @Component
    public class ClockTiming {
    
        /**
         * 定时器
         */
        @Scheduled(cron="0 0 0 * * ?")//每天0点开始
        public void insertClock(){
            //业务逻辑
    
        }
    
    
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    动态定时器的实现也非常简单继承SchedulingConfigurer 类实现方法即可

    package com.clsystem.Comm;
    
    
    import com.clsystem.Util.DateUtil;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.scheduling.Trigger;
    import org.springframework.scheduling.TriggerContext;
    import org.springframework.scheduling.annotation.SchedulingConfigurer;
    import org.springframework.scheduling.config.ScheduledTaskRegistrar;
    import org.springframework.scheduling.support.CronTrigger;
    import org.springframework.stereotype.Component;
    
    import java.util.Calendar;
    import java.util.Date;
    
    /**
     * Created by pudding on 2017-11-15.(动态定时器  用于打卡前10分钟推送消息)(!闹钟)
     */
    @Component
    public class DynamicScheduledTask implements SchedulingConfigurer {
    
        @Autowired
        private CheckSystemMapper checkSystemMapper;
    
        @Override
        public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
            taskRegistrar.addTriggerTask(new Runnable() {
                @Override
                public void run() {
                    // 定时任务的业务逻辑
                    System.out.println("提醒打卡");
    
                }
            }, new Trigger() {
                @Override
                public Date nextExecutionTime(TriggerContext triggerContext) {//设置下次定时器
    
                    Integer day= DateUtil.getDay();//获取今天周几
    
                    day+=1;//得到明天周几
                    if (day==8){//排除周日
                        day=1;
                    }
    
                    String MornTime=checkSystemMapper.getCheckSystem(day).getBeforeMornTime();//获取明天上班时间
    
                    int j = MornTime.indexOf(":");
                    Integer BeforeMornTimeHour=Integer.parseInt(MornTime.substring(0,j));//取早上上班时
                    Integer BeforeMornTimeMinute=Integer.parseInt(MornTime.substring(j+1,MornTime.length()));//取早上上班分
    
                    Date date=new Date();
                    date.setHours(BeforeMornTimeHour);
                    date.setMinutes(BeforeMornTimeMinute);
                    date.setSeconds(0);
    
                    Calendar cal = Calendar.getInstance();
                    cal.setTime(date);
                    cal.add(Calendar.MINUTE,-10);//减去10分钟
                    int hour=cal.get(Calendar.HOUR_OF_DAY);//24小时制
                    int minute=cal.get(Calendar.MINUTE);//分
    
                    String cron="0 "+minute+" "+hour+" * * "+day+"";
    
                    System.out.println(cron);
    
                    CronTrigger trigger = new CronTrigger(cron); // 定时任务触发,可修改定时任务的执行周期
    
                    Date nextExecDate = trigger.nextExecutionTime(triggerContext);
                    return nextExecDate;
                }
            });
        }
    
    }
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74

    cron参数基本用法:

    ●星号():可用在所有字段中,表示对应时间域的每一个时刻,例如,在分钟字段时,表示“每分钟”; 
    ●问号(?):该字符只在日期和星期字段中使用,它通常指定为“无意义的值”,相当于点位符; 
    ●减号(-):表达一个范围,如在小时字段中使用“10-12”,则表示从10到12点,即10,11,12; 
    ●逗号(,):表达一个列表值,如在星期字段中使用“MON,WED,FRI”,则表示星期一,星期三和星期五; 
    ●斜杠(/):x/y表达一个等步长序列,x为起始值,y为增量步长值。如在分钟字段中使用0/15,则表示为0,15,30和45秒,而5/15在分钟字段中表示5,20,35,50,你也可以使用*/y,它等同于0/y; 
    ●L:该字符只在日期和星期字段中使用,代表“Last”的意思,但它在两个字段中意思不同。L在日期字段中,表示这个月份的最后一天,如一月的31号,非闰年二月的28号;如果L用在星期中,则表示星期六,等同于7。但是,如果L出现在星期字段里,而且在前面有一个数值X,则表示“这个月的最后X天”,例如,6L表示该月的最后星期五; 
    ●W:该字符只能出现在日期字段里,是对前导日期的修饰,表示离该日期最近的工作日。例如15W表示离该月15号最近的工作日,如果该月15号是星期六,则匹配14号星期五;如果15日是星期日,则匹配16号星期一;如果15号是星期二,那结果就是15号星期二。但必须注意关联的匹配日期不能够跨月,如你指定1W,如果1号是星期六,结果匹配的是3号星期一,而非上个月最后的那天。W字符串只能指定单一日期,而不能指定日期范围; 
    ●LW组合:在日期字段可以组合使用LW,它的意思是当月的最后一个工作日; 
    ●井号(#):该字符只能在星期字段中使用,表示当月某个工作日。如6#3表示当月的第三个星期五(6表示星期五,#3表示当前的第三个),而4#5表示当月的第五个星期三,假设当月没有第五个星期三,忽略不触发; 
    ● C:该字符只在日期和星期字段中使用,代表“Calendar”的意思。它的意思是计划所关联的日期,如果日期没有被关联,则相当于日历中所有日期。例如5C在日期字段中就相当于日历5日以后的第一天。1C在星期字段中相当于星期日后的第一天。 
    Cron表达式对特殊字符的大小写不敏感,对代表星期的缩写英文大小写也不敏感。 
    表2下面给出一些完整的Cron表示式的实例: 
    CRON表达式 含义 
    “0 0 12 * * ?” 每天中午十二点触发 
    “0 15 10 ? * *” 每天早上10:15触发 
    “0 15 10 * * ?” 每天早上10:15触发 
    “0 15 10 * * ? *” 每天早上10:15触发 
    “0 15 10 * * ? 2005” 2005年的每天早上10:15触发 
    “0 * 14 * * ?” 每天从下午2点开始到2点59分每分钟一次触发 
    “0 0/5 14 * * ?” 每天从下午2点开始到2:55分结束每5分钟一次触发 
    “0 0/5 14,18 * * ?” 每天的下午2点至2:55和6点至6点55分两个时间段内每5分钟一次触发 
    “0 0-5 14 * * ?” 每天14:00至14:05每分钟一次触发 
    “0 10,44 14 ? 3 WED” 三月的每周三的14:10和14:44触发 
    “0 15 10 ? * MON-FRI” 每个周一、周二、周三、周四、周五的10:15触发

    展开全文
  • java 动态定时器

    2018-10-22 09:45:34
    private ThreadPoolTaskScheduler ...// 加载时创建定时器 { threadPoolTaskScheduler = new ThreadPoolTaskScheduler(); 初始化, threadPoolTaskScheduler.initialize(); } private ScheduledFuture...
  • quartz之动态定时器实现

    千次阅读 2019-02-25 11:50:38
    2、动态定时任务实现 重点分析: 1、基础环境配置 注意: a、quartz调度框架是有内置表的 进入quartz的官网http://www.quartz-scheduler.org/,点击Downloads, 下载后在目录\docs\dbTables下有常用数据库...
  • 简单业务场景:项目启动的时候 启动多个定时器。(走高速) 实现CommandLineRunner接口 并标记为spring组件(@Component) @Component public class ScheduleConfig implements CommandLineRunner { private ...
  • NULL 博文链接:https://beisicao.iteye.com/blog/1222365
  • spring动态定时器封装

    2019-03-28 01:05:14
    NULL 博文链接:https://liyaojin.iteye.com/blog/1197191
  • springboot 动态定时器

    2019-11-06 13:38:41
    定时表达式 ...springboot使用注解实现定时器 https://blog.csdn.net/u010096717/article/details/85160758 任务动态修改cron表达式改变执行周期 https://www.cnblogs.com/gtblogs/p/10224937.htm...
  • springboot 自定义配置Quartz动态定时器

    千次阅读 2018-09-30 11:19:34
    所以,定时器的设计就必须要灵活,能随时的增,删,改定时任务。 1. 数据库设计 CREATE TABLE `sys_task` ( `id` int(11) NOT NULL AUTO_INCREMENT, `created_at` datetime NOT NULL COMMENT ...
  • C#动态定时器+传参定时器

    千次阅读 2013-11-23 22:26:20
    //动态定时器 int num=10; TaskTimer[] t=new TaskTimer[num]; t[0]=new TaskTimer(); t[0].Interval=1000; t[0].ID=0; t[0].Tick+= new EventHandler(theout); t[0].Start(); t[1]=...
  • 动态修改参数cron的值来实现Spring自带定时器动态的执行任务
  • spring boot 动态定时器实现

    千次阅读 2019-05-23 14:42:07
  • drools动态定时器解决方案 讲解本系统规则引擎定时任务模块之前,我先讲解一下drools的定时器。 语法如下:相比于drools的普通语法,定时器新增了一个timer字段,用于定时器的 规定,timer后面接cron表达式。 import...
  • spring 动态定时器

    千次阅读 热门讨论 2012-12-19 20:09:24
    真是好久没有学习了呀,学习的方法都快不会了,还好,学习的精神还在,伟东说:不怕慢,就怕站.呵呵.我确实慢了点,但是好歹...期间,结合项目需求,有个需要做的事情就是动态定时器。于是扩展了一个知识。  spring静态定时
  • netty实现动态定时器

    2018-11-01 14:08:00
    2.需要动态添加定时任务 3.需要动态修改定时任务时间。 网上找到两种方式:quartz服务 和HashedWheelTimer这两种方式 ,项目中用的是HashedWheelTimer ,相关API可以自行百度或者看源码。 创建HashedWheelTimer ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 66,817
精华内容 26,726
关键字:

动态定时器