精华内容
下载资源
问答
  • 关于cron描述符 主页: : 软件包许可证:麻省理工学院 原料许可证: 简介:一个将cron表达式转换为人类可读字符串的Python库。 当前构建状态 所有平台: 当前发行信息 姓名 资料下载 版本 平台类 安装cron描述符 ...
  • cron 表达式描述

    2013-03-28 11:41:40
    Cron表达式是一个字符串,字符串以5或6个空格隔开,分开工6或7个域,每一个域代表一个含义,Cron有如下两种语法  格式:  Seconds Minutes Hours DayofMonth Month DayofWeek Year 或  Seconds Minutes Hours ...
    Cron表达式是一个字符串,字符串以5或6个空格隔开,分开工6或7个域,每一个域代表一个含义,Cron有如下两种语法 
    格式: 
    Seconds Minutes Hours DayofMonth Month DayofWeek Year 或 
    Seconds Minutes Hours DayofMonth Month DayofWeek 
    每一个域可出现的字符如下:
    代码
    Seconds:可出现,-  *  / 四个字符,有效范围为0-59的整数    
    Minutes:可出现,-  *  / 四个字符,有效范围为0-59的整数    
    Hours:可出现,-  *  / 四个字符,有效范围为0-23的整数    
    DayofMonth:可出现,-  *  / ? L W C八个字符,有效范围为0-31的整数     
    Month:可出现,-  *  / 四个字符,有效范围为1-12的整数或JAN-DEc    
    DayofWeek:可出现,-  *  / ? L C #四个字符,有效范围为1-7的整数或SUN-SAT两个范围。1表示星期天,2表示星期一, 依次类推    
    Year:可出现,-  *  / 四个字符,有效范围为1970-2099年   
     
    每一个域都使用数字,但还可以出现如下特殊字符,它们的含义是:

    代码
    (1)*:表示匹配该域的任意值,假如在Minutes域使用*,即表示每分钟都会触发事件。    
       
    (2)?:只能用在DayofMonth和DayofWeek两个域。它也匹配域的任意值,但实际不会。因为DayofMonth和DayofWeek会相互影响。例如想在每月的20日触发调度,不管20日到底是星期几,则只能使用如下写法: 13  13 15 20 * ?,其中最后一位只能用?,而不能使用*,如果使用*表示不管星期几都会触发,实际上并不是这样。    
    (3)-:表示范围,例如在Minutes域使用5-20,表示从5分到20分钟每分钟触发一次    
       
    (4)/:表示起始时间开始触发,然后每隔固定时间触发一次,例如在Minutes域使用5/20,则意味着5分钟触发一次,而25,45等分别触发一次.    
       
    (5),:表示列出枚举值值。例如:在Minutes域使用5,20,则意味着在5和20分每分钟触发一次。    
       
    (6)L:表示最后,只能出现在DayofWeek和DayofMonth域,如果在DayofWeek域使用5L,意味着在最后的一个星期四触发。    
       
    (7)W:表示有效工作日(周一到周五),只能出现在DayofMonth域,系统将在离指定日期的最近的有效工作日触发事件。例如:在DayofMonth使用5W,如果5日是星期六,则将在最近的工作日:星期五,即4日触发。如果5日是星期天,则在6日触发;如果5日在星期一到星期五中的一天,则就在5日触发。另外一点,W的最近寻找不会跨过月份    
       
    (8)LW:这两个字符可以连用,表示在某个月最后一个工作日,即最后一个星期五。    
       
    (9)#:用于确定每个月第几个星期几,只能出现在DayofMonth域。例如在4#2,表示某月的第二个星期三。
    展开全文
  • Cron表达式转中文描述

    千次阅读 2018-12-20 15:05:45
    介于Cron表达式的繁琐,示例代码并未完全转换 public static String translateToChinese(String cronExp) { if (cronExp == null || cronExp.length() < 1) { return "cron表达式为空"; } ...

    介于Cron表达式的繁琐,示例代码并未完全转换

    public static String translateToChinese(String cronExp) {
            if (cronExp == null || cronExp.length() < 1) {
                return "cron表达式为空";
            }
    
            String[] tmpCorns = cronExp.split(" ");
            StringBuffer sBuffer = new StringBuffer();
            if (tmpCorns.length == 6) {
                //解析月
                if (!tmpCorns[4].equals("*") && !tmpCorns[4].equals("?")) {
                    if (tmpCorns[4].contains("/")) {
                        sBuffer.append("从").append(tmpCorns[4].split("/")[0]).append("号开始").append(",每").append
                                (tmpCorns[4].split("/")[1]).append("月");
                    } else {
                        sBuffer.append("每年").append(tmpCorns[4]).append("月");
                    }
                }
    
                //解析周
                if (!tmpCorns[5].equals("*") && !tmpCorns[5].equals("?")) {
                    if (tmpCorns[5].contains(",")) {
                        sBuffer.append("每周的第").append(tmpCorns[5]).append("天");
                    } else {
                        sBuffer.append("每周");
                        char[] tmpArray = tmpCorns[5].toCharArray();
                        for (char tmp : tmpArray) {
                            switch (tmp) {
                                case '1':
                                    sBuffer.append("日");
                                    break;
                                case '2':
                                    sBuffer.append("一");
                                    break;
                                case '3':
                                    sBuffer.append("二");
                                    break;
                                case '4':
                                    sBuffer.append("三");
                                    break;
                                case '5':
                                    sBuffer.append("四");
                                    break;
                                case '6':
                                    sBuffer.append("五");
                                    break;
                                case '7':
                                    sBuffer.append("六");
                                    break;
                                default:
                                    sBuffer.append(tmp);
                                    break;
                            }
                        }
                    }
                }
    
                //解析日
                if (!tmpCorns[3].equals("?")) {
                    if (sBuffer.toString().contains("一") && sBuffer.toString().contains("二") && sBuffer.toString()
                            .contains("三")
                            && sBuffer.toString().contains("四") && sBuffer.toString().contains("五") && sBuffer.toString()
                            .contains("六")
                            && sBuffer.toString().contains("日")) {
                    }
    
                    if (!tmpCorns[3].equals("*")) {
                        if (tmpCorns[3].contains("/")) {
                            sBuffer.append("每周从第").append(tmpCorns[3].split("/")[0]).append("天开始").append(",每").append
                                    (tmpCorns[3].split("/")[1]).append("天");
                        } else {
                            sBuffer.append("每月第").append(tmpCorns[3]).append("天");
                        }
                    }
                }
    
                //解析时
                if (!tmpCorns[2].equals("*")) {
                    if (tmpCorns[2].contains("/")) {
                        sBuffer.append("从").append(tmpCorns[2].split("/")[0]).append("点开始").append(",每").append
                                (tmpCorns[2].split("/")[1]).append("小时");
                    } else {
                        if (!(sBuffer.toString().length() > 0)) {
                            sBuffer.append("每天").append(tmpCorns[2]).append("点");
                        }
                    }
                }
    
                //解析分
                if (!tmpCorns[1].equals("*")) {
                    if (tmpCorns[1].contains("/")) {
                        sBuffer.append("从第").append(tmpCorns[1].split("/")[0]).append("分开始").append(",每").append
                                (tmpCorns[1].split("/")[1]).append("分");
                    } else if (tmpCorns[1].equals("0")) {
    
                    } else {
                        sBuffer.append(tmpCorns[1]).append("分");
                    }
                }
                if (sBuffer.toString().length() > 0) {
                    sBuffer.append("执行一次");
                } else {
                    sBuffer.append("表达式中文转换异常");
                }
            }
            return sBuffer.toString();
        }

     

    展开全文
  • cron是一个Go库,它解析cron表达式并输出cron时间表的可读描述。 例如,给定表达式*/5 * * * * ,它将Every 5 minutes输出Every 5 minutes 。 通过 (Javascript)从 (C#)转换为Go。 原始作者和信誉:Brady ...
  • Cron表达描述符 将 cron 表达式转换为人类可读描述的 .NET 库。 作者:Brady Holt ( )许可证: 特征 支持所有 cron 表达式特殊字符,包括 * / , - ? 体重,# 支持5、6(w /秒或年)或7(w /秒和年)部分cron表达式...
  • CRON表达式翻译为中文描述

    千次阅读 2020-11-18 11:20:58
    CRON表达式翻译为中文描述,复杂的CRON表达式会有问题,直接用的话,请自行调整。 package com.example.util; import lombok.experimental.UtilityClass; import org.apache.commons.lang.StringUtils; /** * ...

    将CRON表达式翻译为中文描述,复杂的CRON表达式会有问题,直接用的话,请自行调整。

    package com.example.util;
    
    import lombok.experimental.UtilityClass;
    import org.apache.commons.lang.StringUtils;
    
    /**
     * CRON处理工具类
     *
     * @author azhuzhu 2020/11/18 10:16
     */
    @UtilityClass
    public class CronUtil {
    
        /**
         * CRON表达式翻译为中文描述
         * <p>复杂表达式和部分通配符不支持,不处理年(第七段)</p>
         *
         * @param cronStr cron表达式
         * @return 中文描述
         */
        public static String translateToChinese(String cronStr) {
            if (StringUtils.isBlank(cronStr)) {
                throw new IllegalArgumentException("cron表达式为空");
            }
    
            String[] cronArray = cronStr.split(" ");
            // 表达式到年会有7段, 至少6段
            if (cronArray.length != 6 && cronArray.length != 7) {
                throw new IllegalArgumentException("cron表达式格式错误");
            }
    
            String secondCron = cronArray[0];
            String minuteCron = cronArray[1];
            String hourCron = cronArray[2];
            String dayCron = cronArray[3];
            String monthCron = cronArray[4];
            String weekCron = cronArray[5];
            
            StringBuilder result = new StringBuilder();
            // 解析月
            if (!monthCron.equals("*") && !monthCron.equals("?")) {
                if (monthCron.contains("/")) {
                    result.append("从")
                            .append(monthCron.split("/")[0])
                            .append("号开始")
                            .append(",每")
                            .append(monthCron.split("/")[1])
                            .append("月");
                } else {
                    result.append("每年").append(monthCron).append("月");
                }
            }
    
            // 解析周
            boolean hasWeekCron = false;
            if (!weekCron.equals("*") && !weekCron.equals("?")) {
                hasWeekCron = true;
                if (weekCron.contains(",")) {
                    result.append("每周的第").append(weekCron).append("天");
                } else {
                    result.append("每周");
                    char[] tmpArray = weekCron.toCharArray();
                    for (char tmp : tmpArray) {
                        switch (tmp) {
                            case '1':
                                result.append("日");
                                break;
                            case '2':
                                result.append("一");
                                break;
                            case '3':
                                result.append("二");
                                break;
                            case '4':
                                result.append("三");
                                break;
                            case '5':
                                result.append("四");
                                break;
                            case '6':
                                result.append("五");
                                break;
                            case '7':
                                result.append("六");
                                break;
                            default:
                                result.append(tmp);
                                break;
                        }
                    }
                }
            }
    
            // 解析日
            if (!dayCron.equals("?") && !"*".equals(dayCron)) {
                if (hasWeekCron) {
                    throw new IllegalArgumentException("表达式错误,不允许同时存在指定日和指定星期");
                }
                if (dayCron.contains("/")) {
                    result.append("每月从第")
                            .append(dayCron.split("/")[0])
                            .append("天开始")
                            .append(",每")
                            .append(dayCron.split("/")[1])
                            .append("天");
                } else {
                    result.append("每月第").append(dayCron).append("天");
                }
            }
    
            // 解析时
            if (!hourCron.equals("*")) {
                if (hourCron.contains("/")) {
                    result.append("从")
                            .append(hourCron.split("/")[0])
                            .append("点开始")
                            .append(",每")
                            .append(hourCron.split("/")[1])
                            .append("小时");
                } else {
                    if (!(result.toString().length() > 0)) {
                        result.append("每天").append(hourCron).append("点");
                    }
                }
            }
    
            // 解析分
            if (!minuteCron.equals("*") && !minuteCron.equals("0")) {
                if (minuteCron.contains("/")) {
                    result.append("从第")
                            .append(minuteCron.split("/")[0])
                            .append("分开始").append(",每")
                            .append(minuteCron.split("/")[1])
                            .append("分");
                } else {
                    result.append(minuteCron).append("分");
                }
            }
    
            // 解析秒
            if (!secondCron.equals("*") && !secondCron.equals("0")) {
                if (secondCron.contains("/")) {
                    result.append("从第")
                            .append(secondCron.split("/")[0])
                            .append("秒开始")
                            .append(",每")
                            .append(secondCron.split("/")[1])
                            .append("秒");
                } else {
                    result.append(secondCron).append("分");
                }
            }
    
            if (StringUtils.isNotBlank(result.toString())) {
                result.append("执行一次");
            }
            return result.toString();
        }
    
    }
    
    
    展开全文
  • Cron描述符 掌握: 全部: 一个将cron表达式转换为人类可读字符串的Python库。 从移植到Python。 作者:亚当·舒伯特(Adam Schubert)( ) 原始作者和信誉:Brady Holt( ) 执照: 特征 支持所有cron表达式...
  • cron

    2014-04-25 14:25:16
    每个子表达式都描述了一个单独的日程细节。这些子表达式用空格分隔,分别表示:  1. Seconds 秒  2. Minutes 分钟  3. Hours 小时  4. Day-of-Month 月中的天  5. Month 月  6. Day-of-Week 周中的天

     

    Cron表达式被用来配置CronTrigger实例。 Cron表达式是一个由 7个子表达式组成的字符串。每个子表达式都描述了一个单独的日程细节。这些子表达式用空格分隔,分别表示:

      1. Seconds 秒

      2. Minutes 分钟

      3. Hours 小时

      4. Day-of-Month 月中的天

      5. Month 月

      6. Day-of-Week 周中的天

      7. Year (optional field) 年(可选的域)

      s m h dom M dow Y

      顺序:右至左路,[年]周月日时分秒

      符号:* 任意

      / 增量 a/b 从a开始每次增加b

      ? 没有值

      L 最后一个值

      W

      # 月中的第几个周几 6#3 第三个周五

      - 连续区间至

      , 多个值

      一个cron表达式的例子字符串为"0 0 12 ? * WED",这表示"每周三的中午 12: 00".单个子表达式可以包含范围或者列表。例如:前面例子中的周中的天这个域(这里是"WED")可以被替换为"MON-FRI", "MON, WED, FRI"或者甚至"MON-WED,SAT".通配符('*')可以被用来表示域中"每个"可能的值。因此在"Month"域中的*表示每个月,而在 Day-Of-Week域中的*则表示"周中的每一天".

      所有的域中的值都有特定的合法范围,这些值的合法范围相当明显,例如:秒和分域的合法值为 0到 59,小时的合法范围是 0到 23,Day-of-Month中值得合法凡范围是0到 31,但是需要注意不同的月份中的天数不同。月份的合法值是0到 11.或者用字符串JAN,FEB MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV 及 DEC 来表示。

      Days-of-Week可以用1到7来表示 (1=星期日)或者用字符串SUN, MON, TUE, WED,THU, FRI 和SAT来表示。

      '/'字符用来表示值的增量,例如, 如果分钟域中放入'0/15',它表示"每隔 15 分钟,从 0开始",如果在份中域中使用'3/20',则表示"小时中每隔 20分钟,从第 3分钟开始"或者另外相同的形式就是'3,23,43'.'?'字符可以用在day-of-month及 day-of-week域中,它用来表示"没有指定值".

      这对于需要指定一个或者两个域的值而不需要对其他域进行设置来说相当有用。看下面例子(以及 CronTrigger JavaDOC)会更清楚。

     

    'L'字符可以在 day-of-month及day-of-week中使用,这个字符是"last"的简写,但是在两个域中的意义不同。例如,在 day-of-month域中的"L"表示这个月的最后一天,即,一月的 31日,非闰年的二月的 28日。如果它用在 day-of-week中,则表示"7"或者"SAT".但是如果在 day-of-week域中,这个字符跟在别的值后面,则表示"当月的最后的周 XXX".例如:"6L" 或者 "FRIL"都表示本月的最后一个周五。当使用'L'选项时,最重要的是不要指定列表或者值范围,否则会导致混乱。

      'W' 字符用来指定距离给定日最接近的周几(在 day-of-week域中指定)。例如:

      如果你为 day-of-month 域指定为"15W",则表示"距离月中 15号最近的周几".

      '#'表示表示月中的第几个周几。例如:day-of-week 域中的"6#3" 或者 "FRI#3"

      表示"月中第三个周五". 下面是一些表达式以及它们的含义,你可以在CronTrigger的JavaDOC 中找大更多

      例子。

      Example Cron Expressions --Cron 表达式的例子

      CronTrigger 例 1 – 一个简单的每隔 5分钟触发一次的表达式

      "0 0/5 * * * ?"

      CronTrigger 例2 – 在每分钟的10秒后每隔5分钟触发一次的表达式(例如。 10:00:10

      am, 10:05:10等。)。

      "10 0/5 * * * ?"

      CronTrigger 例 3 – 在每个周三和周五的 10:30,11:30,12:30触发的表达式。

      "0 30 10-13 ? * WED,FRI"

      CronTrigger 例 4 – 在每个月的 5号, 20号的 8点和 10点之间每隔半个小时触发一次且不包括 10点,只是 8:30,9:00和 9:30的表达式。 www.2cto.com

      "0 0/30 8-9 5,20 * ?"

      注意,对于单独触发器来说,有些日程需求可能过于复杂而不能用表达式表述,例如:

      9:00到10:00之间每隔 5分钟触发一次,下午1:00到 10点每隔 20分钟触发一次。

      这个解决方案就是创建两个触发器,两个触发器都运行相同的任务。

     

     

    展开全文
  • Cron表达式解释

    千次阅读 2017-02-24 11:49:14
    本篇文章主要的重点是cron描述定时任务的时间表达式该如何书写。2. 格式一个cron表达式具体表现就是一个字符串,这个字符串中包含6~7个字段,字段之间是由空格分割的,每个字段可以由任何允许的值以及允许的特殊字符...
  • Cron

    2016-08-08 10:24:55
    cron表达式生成器:http://cron.qqe2.com/ CronTrigger CronTriggers往往比SimpleTrigger更有用,如果您需要基于日历的概念,而非SimpleTrigger完全指定的时间间隔,复发的发射工作的时间表。 CronTrigger,你可以...
  • package ... import lombok.experimental.UtilityClass; import org.apache.commons.lang.StringUtils; /** * CRON处理工具类 ... * @author evan 2020/11/23 12:12 ... * CRON表达式翻译为中文描述
  • cron-utils是一个Java库,用于定义,解析,验证,迁移cron以及获取其可读的描述。 该项目遵循,提供OSGi元数据并使用Apache 2.0许可证。 下载 cron-utils在存储库中可用。 <groupId>com.cronutils</groupId> ...
  • Cron表达式

    2021-06-01 14:28:07
    是有7个子表达式组成的字符串,描述了时间表的详细信息 格式为[秒][分][小时][日][月][周][年] 解释一下特殊字符: 可以使用在线生成cron表达式的方式生成 相关网址:https://cron.qqe2.com/ ...
  • cron表达式

    2019-11-11 11:26:01
    cron原来是UNIX的工具之一,主要用于进行任务调度,cron核心使用的就是cron表达式来处理任务调度,一个cron表达是由6~7个域组成并且以空格分隔的字段串,以下为一个简单的cron表达式:10 * * * * ?,表示每分钟的第...
  • 描述 易于使用的Cron与Molecularr! 安装 $ npm install moleculer-cron --save 用法 创建Cron服务 在插件的构造函数中指定所有cron任务。 const Cron = require ( "moleculer-cron" ) ; broker . createService ( ...
  • Cron 表达式

    2017-07-14 11:16:39
     cron的表达式是字符串,实际上是由七子表达式,描述个别细节的时间表。  1、 Seconds  2、 Minutes  3、 Hours  4、 Day_of_Month  5、 Month  6、 Day_of_Week  7、 Year(可选字段) 例
  • 描述 Cron Expression UI :输入组件,可轻松直观地生成cron表达式,如 例子 使用说明 NPM 从安装软件包 npm install cron-expression-input@1.2.7 在你的代码中 import "cron-expression-input/lib/cron-...
  • cron表达式详解

    千次阅读 2016-06-29 18:57:57
    Cron表达式是一个字符串,字符串以5或6个空格隔开,分为6或7个域,每一个域代表一个含义,Cron有如下两种语法格式: Seconds Minutes Hours DayofMonth Month DayofWeek Year或 Seconds Minutes Hours DayofMonth ...
  • Cron Expressions——Cron 表达式

    千次阅读 2012-01-10 15:16:10
    Cron表达式被用来配置CronTrigger实例。 Cron表达式是一个字符串,字符串以5或6个空格隔开,分开为6或7个域,每一个域代表一个含义。 记忆方式:秒分时 日月周 年 Cron有如下两种语法格式: Seconds Minutes ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,691
精华内容 10,276
关键字:

cron描述