CRON表达式转换成中文

字段	允许值	允许的特殊字符
秒（Seconds）	0~59的整数	, - * / 四个字符
分（Minutes）	0~59的整数	, - * / 四个字符
小时（Hours）	0~23的整数	, - * / 四个字符
日期（DayofMonth）	1~31的整数（但是你需要考虑你月的天数）	,- * ? / L W C 八个字符
月份（Month）	1~12的整数或者 JAN-DEC	, - * / 四个字符
星期（DayofWeek）	1~7的整数或者 SUN-SAT （1=SUN）	, - * ? / L C # 八个字符
年(可选，留空)（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域。如果在DayofMonth，L就是月份的最后一天。如果在DayofWeek域使用5L,意味着在最后的一个星期四触发。

　　（7）W:表示有效工作日(周一到周五),只能出现在DayofMonth域，系统将在离指定日期的最近的有效工作日触发事件。例如：在 DayofMonth使用5W，如果5日是星期六，则将在最近的工作日：星期五，即4日触发。如果5日是星期天，则在6日(周一)触发；如果5日在星期一到星期五中的一天，则就在5日触发。另外一点，W的最近寻找不会跨过月份。（PS：这个理解不过来，在线上cron表达式生成器中输入，0 0 12 3W * ? ， 0 0 12 4W * ? 等）

　　（8）LW:这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。

　　（9）#:用于确定每个月第几个星期几，只能出现在DayofMonth域。例如在4#2，表示某月的第二个星期三。

　　（10）C：只在日期和星期字段中使用，代表“Calendar”的意思。它的意思是计划所关联的日期，如果日期没有被关联，则相当于日历中所有日期。例如 5C 在日期字段中就相当于日历 5 日以后的第一天。1C 在星期字段中相当于星期日后的第一天;

三、常用表达式例子

　　（1）0 0 2 1 * ? * 表示在每月的1日的凌晨2点调整任务

　　（2）0 15 10 ? * MON-FRI 表示周一到周五每天上午10:15执行作业

　　（3）0 15 10 ? 6L 2002-2006 表示2002-2006年的每个月的最后一个星期五上午10:15执行作

　　（4）0 0 10,14,16 * * ? 每天上午10点，下午2点，4点

　　（5）0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时

　　（6）0 0 12 ? * WED 表示每个星期三中午12点

　　（7）0 0 12 * * ? 每天中午12点触发

　　（8）0 15 10 ? * * 每天上午10:15触发

　　（9）0 15 10 * * ? 每天上午10:15触发

　　（10）0 15 10 * * ? * 每天上午10:15触发

　　（11）0 15 10 * * ? 2005 2005年的每天上午10:15触发

　　（12）0 * 14 * * ? 在每天下午2点到下午2:59期间的每1分钟触发

　　（13）0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发

　　（14）0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发

　　（15）0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发

　　（16）0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44触发

　　（17）0 15 10 ? * MON-FRI 周一至周五的上午10:15触发

　　（18）0 15 10 15 * ? 每月15日上午10:15触发

　　（19）0 15 10 L * ? 每月最后一日的上午10:15触发

　　（20）0 15 10 ? * 6L 每月的最后一个星期五上午10:15触发

　　（21）0 15 10 ? * 6L 2002-2005 2002年至2005年的每月的最后一个星期五上午10:15触发

　　（22）0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发

　　注：

　　（1）有些子表达式能包含一些范围或列表

　　例如：子表达式（天（星期））可以为 “MON-FRI”，“MON，WED，FRI”，“MON-WED,SAT”，“*”字符代表所有可能的值

　　因此，“*”在子表达式（月）里表示每个月的含义，“*”在子表达式（天（星期））表示星期的每一天

　　“/”字符用来指定数值的增量。　　例如：在子表达式（分钟）里的“0/15”表示从第0分钟开始，每15分钟
在子表达式（分钟）里的“3/20”表示从第3分钟开始，每20分钟（它和“3，23，43”）的含义一样

　　“？”字符仅被用于天（月）和天（星期）两个子表达式，表示不指定值

　　当2个子表达式其中之一被指定了值以后，为了避免冲突，需要将另一个子表达式的值设为“？”

　　“L” 字符仅被用于天（月）和天（星期）两个子表达式，它是单词“last”的缩写

　　但是它在两个子表达式里的含义是不同的。

　　在天（DayofMonth）子表达式中，“L”表示一个月的最后一天

　　在天（DayofWeek）自表达式中，“L”表示一个星期的最后一天，也就是SAT，等同于于数字7

　　如果在“L”前有具体的内容，它就具有其他的含义了

　　例如：“6L”表示这个月的倒数第６天，“FRIL”表示这个月的最一个星期五

　　注意：在使用“L”参数时，不要指定列表或范围，因为这会导致问题

3，转换成中文：

了解到cron表达式后，开始把cron表达式转换成中文，便于理解

处理思路：

主要解析字符“/”，“L”，“#”，

对于 “*”，“?” 就太多可以解析的；对于“,”,“-”，这个直接沿用，也好理解

对于“W”，“LW”，“C” 这个要真的理解，才好处理，用cron表达式在线编译器，0 0 12 3W * ? ， 0 0 12 4W * ? 等，也没搞明白C和W的含义，就先搁置。如果后面真的遇到了，再完善

还有周带英文的 “0 15 10 ? * MON-FRI 周一至周五的上午10:15触发”，英文的解析起来比较麻烦，数字的好解析，英文的没有处理。

1，CronExpParserUtil






protected final static String[] CRON_TIME_CN = new String[]{"秒", "分钟", "小时", "天", "月","周", "年"};





 





 





 





    private final static Integer HOURS = 24;





 





    private final static Integer TIMESCALE = 60;





 





 





 





 





 





    /**





 





     *  主要解析 斜杆  /：表示起始时间开始触发，然后每隔固定时间触发一次。





 





     *      范围值+开始值 - 间隔值 = 范围内最后执行的值；





 





     *      例如在Hourss域使用3/4,则意味着从第3小时到24+3-4：23小时范围内，第3小时开始触发第一次，然后每隔4小时，即7，11，15，19，23小时等分别触发一次。





 





     *      例如在Minutes域使用5/20,则意味着从第5分钟到60+5-20：45分范围内，第5分钟开始触发第一次，然后每隔20分钟，即25，45分钟等分别触发一次。





 





     *      例如在Seconds域使用8/10,则意味着从第8秒到60+8-10：58秒范围内，第8秒开始触发第一次，然后每隔10秒，即18，28，38，48，58秒等分别触发一次。





 





     *      *





 





     *   对于 *：表示匹配该域的任意值。例如在Minutes域使用*, 即表示每分钟都会触发事件。





 





     *   对于问号  ?：只能用在DayofMonth和DayofWeek两个域，其作用为不指定





 





     *   对于 -：表示范围。例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次。直接进行拼接





 





     *   对于逗号 ,：表示列出枚举值。例如在Minutes域使用5,20 ， 则意味着在5和20分每分钟触发一次。





 





     *   对于L：表示最后，只能出现在DayofWeek和DayofMonth域。





 





     *      如果出现在DayofMonth域，只能使用L，表示当月最后一天





 





     *      如果在DayofWeek域





 





     *          使用数字（1-7）或L（和7的作用一样表示每周的最后一天周六），比如数字"5"表示每周4， "7"或"L"表示每周六





 





     *          使用数字（1-7）结合L，表示当月最后一周的周几，比如"5L" 表示在最后的一周的周四； "3L" 表示最后一周的周二





 





     *   对于#: 用于确定每个月第几个星期几，只能出现在DayofMonth域。





 





     *      例如 "4#2" 表示某月的第二个星期三（4表示星期三，2表示第二周）;





 





     *       “6#3”表示本月第三周的星期五（6表示星期五，3表示第三周）;





 





     *       “2#1”表示本月第一周的星期一;





 





     *       “4#5”表示第五周的星期三。





 





     *





 





     * @param cronExp





 





     * @param cronTimeArr





 





     * @return





 





     */





 





    public static String translateToChinese(String cronExp, String[] cronTimeArr) {





 





        if (cronExp == null || cronExp.length() < 1) {





 





            return "cron表达式为空";





 





        }





 





 





 





        String[] tmpCorns = cronExp.split(" ");





 





        StringBuffer sBuffer = new StringBuffer();





 





        if (tmpCorns.length == 6 || tmpCorns.length == 7) {





 





 





 





            if (tmpCorns.length == 7) {





 





                //解析年 Year





 





                String year = tmpCorns[6];





 





                if((!year.equals("*") && !year.equals("?"))){





 





                    sBuffer.append(year).append(cronTimeArr[6]);





 





                }





 





 





 





            }





 





 





 





            //解析月 Month 主要解析 /





 





            String months = tmpCorns[4];





 





            if (!months.equals("*") && !months.equals("?")) {





 





                if (months.contains("/")) {





 





                    sBuffer.append("从").append(months.split("/")[0]).append("号开始").append(",每")





 





                            .append(months.split("/")[1]).append(cronTimeArr[4]);





 





                } else {





 





                    sBuffer.append("每年").append(months).append(cronTimeArr[4]);





 





                }





 





            }





 





 





 





            //解析周 DayofWeek  主要解析 , -  1~7/L   1L~7L





 





            String dayofWeek = tmpCorns[5];





 





            if (!dayofWeek.equals("*") && !dayofWeek.equals("?")) {





 





                if (dayofWeek.contains(",")) {// 多个数字，逗号隔开





 





                    sBuffer.append("每周的第").append(dayofWeek).append(cronTimeArr[3]);





 





                } else if (dayofWeek.contains("L") && dayofWeek.length() > NumberUtils.INTEGER_ONE) {// 1L-7L





 





                    String weekNum = dayofWeek.split("L")[0];





 





                    String weekName = judgeWeek(weekNum);





 





                    sBuffer.append("每月的最后一周的");





 





                    sBuffer.append(weekName);





 





                } else if(dayofWeek.contains("-")) {





 





                    String[] splitWeek = dayofWeek.split("-");





 





                    String weekOne = judgeWeek(splitWeek[0]);





 





                    String weekTwo = judgeWeek(splitWeek[1]);





 





                    sBuffer.append("每周的").append(weekOne).append("到").append(weekTwo);





 





                } else { // 1-7/L





 





                    if("L".equals(dayofWeek)){ // L 转换为7，便于识别





 





                        dayofWeek = "7";





 





                    }





 





                    int weekNums = Integer.parseInt(dayofWeek);





 





                    if(weekNums < 0 || weekNums > 7 ){





 





                        return "cron表达式有误，dayofWeek数字应为1-7";





 





                    }





 





                    sBuffer.append("每周的");





 





                    String weekName = judgeWeek(dayofWeek);





 





                    sBuffer.append(weekName);





 





                }





 





            }





 





 





 





            //解析日 days -- DayofMonth  需要解析的 / # L W





 





//                 *       “6#3”表示本月第三周的星期五（6表示星期五，3表示第三周）;





 





//     *       “2#1”表示本月第一周的星期一;





 





//     *       “4#5”表示第五周的星期三。





 





            String days = tmpCorns[3];





 





            if (!days.equals("?")&& !days.equals("*")) {





 





 





 





                if (days.contains("/")) {





 





                    sBuffer.append("每周从第").append(days.split("/")[0]).append("天开始").append(",每")





 





                            .append(days.split("/")[1]).append(cronTimeArr[3]);





 





                } else if ("L".equals(days)) { // 处理L 每月的最后一天





 





                    sBuffer.append("每月最后一天");





 





                }  else if ("W".equals(days)) { // 处理W 暂时不懂怎么处理





 





                    sBuffer.append(days);





 





                }  else if (days.contains("#")) {





 





                    String[] splitDays = days.split("#");





 





                    String weekNum = splitDays[0]; // 前面数字表示周几





 





                    String weekOfMonth = splitDays[1]; // 后面的数字表示第几周 范围1-4 一个月最多4周





 





                    String weekName = judgeWeek(weekNum);





 





                    sBuffer.append("每月第").append(weekOfMonth).append(cronTimeArr[5]).append(weekName);





 





                } else {





 





                    sBuffer.append("每月第").append(days).append(cronTimeArr[3]);





 





                }





 





 





 





            } else {





 





                if (sBuffer.toString().length() == 0 || tmpCorns.length == 7) { // 前面没有内容的话，拼接下





 





                    sBuffer.append("每").append(cronTimeArr[3]);





 





                }





 





            }





 





 





 





            //解析时 Hours 主要解析 /





 





 





 





            String hours = tmpCorns[2];





 





            if (!hours.equals("*")) {





 





                if (hours.contains("/")) {





 





//                   sBuffer.append("内，从").append(hours.split("/")[0]).append("时开始").append(",每")





 





//                            .append(hours.split("/")[1]).append(cronTimeArr[2]);





 





                    sBuffer.append(appendGapInfo(hours, HOURS, 2));





 





                } else {





 





                    if (!(sBuffer.toString().length() > 0)) { // 对于 , 的情况，直接拼接





 





                        sBuffer.append("每天").append(hours).append(cronTimeArr[2]);





 





                    } else {





 





                        sBuffer.append(hours).append(cronTimeArr[2]);





 





                    }





 





                }





 





            }





 





 





 





            //解析分 Minutes 主要解析 /





 





            String minutes = tmpCorns[1];





 





            if (!minutes.equals("*")) {





 





                if (minutes.contains("/")) {





 





//                    sBuffer.append("内，从第").append(minutes.split("/")[0]).append("分开始").append(",每")





 





//                            .append(minutes.split("/")[1]).append(cronTimeArr[1]);





 





                    sBuffer.append(appendGapInfo(minutes, TIMESCALE, 1));





 





                } else if (minutes.equals("0")) {





 





 





 





                } else if (minutes.contains("-")) {





 





                    String[] splitMinute = minutes.split("-");





 





                    sBuffer.append(splitMinute[0]).append(cronTimeArr[1]).append("到").append(splitMinute[1])





 





                            .append(cronTimeArr[1]).append("每分钟");





 





                } else {





 





                    sBuffer.append(minutes).append(cronTimeArr[1]);





 





                }





 





            }





 





 





 





            //解析秒 Seconds 主要解析 /





 





            String seconds = tmpCorns[0];





 





            if (!seconds.equals("*")) {





 





                if (seconds.contains("/")) {





 





//                    sBuffer.append("内，从第").append(seconds.split("/")[0]).append("秒开始").append(",每")





 





//                            .append(seconds.split("/")[0]).append(cronTimeArr[0]);





 





                    sBuffer.append(appendGapInfo(seconds, TIMESCALE, 0));





 





                } else if (!seconds.equals("0")) {





 





                    sBuffer.append(seconds).append(cronTimeArr[0]);





 





                }





 





            }





 





 





 





            if (sBuffer.toString().length() > 0) {





 





                sBuffer.append("执行一次");





 





            } else {





 





                sBuffer.append("表达式中文转换异常");





 





            }





 





        }





 





        return sBuffer.toString();





 





    }





 





 





 





 





 





    public static String judgeWeek(String weekNum){





 





        String weekName = WeekEnum.matchNameCn(String.valueOf(weekNum));





 





        int weekNums = Integer.parseInt(weekNum);





 





        if(weekNums < 0 || weekNums > 7 ){





 





            return "cron表达式有误，dayofWeek 数字应为1-7";





 





        }





 





        return StringUtils.isNotEmpty(weekName) ? weekName : String.valueOf(weekNum);





 





    }





 





 





 





    private static String appendGapInfo(String time, int rangeNum, int index){





 





        StringBuffer sBufferTemp = new StringBuffer();





 





        String[] splitTime = time.split("/");





 





        String startNum = splitTime[0];





 





        String gapNum = splitTime[1];





 





        int endNum = rangeNum + Integer.parseInt(startNum) - Integer.parseInt(gapNum);





 





        String endStr = String.valueOf(endNum);





 





        String timeUnit = CRON_TIME_CN[index];





 





        sBufferTemp.append("从").append(startNum).append(timeUnit).append("开始")





 





                .append("到").append(endStr).append(timeUnit).append("范围内")





 





                .append(",每隔").append(gapNum).append(timeUnit);





 





        return sBufferTemp.toString();





 





 





 





    }

2，WeekEnum

日期按英文的，星期天是开始的第一天。






 





 





public enum WeekEnum {





 





    SECONDS("1", "星期天", "Sunday "), MONDAY("2", "星期一", "Monday "), TUESDAY("3", "星期二", "Tuesday "), WEDNESDAY("4",





 





            "星期三", "Wednesday "), THURSDAY("5", "星期四",





 





                    "Thursday "), FRIDAY("6", "星期五", "Friday "), SATURDAY("7", "星期六", "Saturday ");





 





 





 





    private String key;





 





    private String nameCn;





 





    private String nameEn;





 





 





 





    WeekEnum(String key, String nameCn, String nameEn) {





 





        this.key = key;





 





        this.nameCn = nameCn;





 





        this.nameEn = nameEn;





 





    }





 





 





 





    public static String matchNameCn(String code) {





 





        for (WeekEnum m : WeekEnum.values()) {





 





            if (m.getKey().equals(code)) {





 





                return m.getNameCn();





 





            }





 





        }





 





        return "";





 





    }





 





 





 





    public static String matchNameEn(String code) {





 





        for (WeekEnum m : WeekEnum.values()) {





 





            if (m.getKey().equals(code)) {





 





                return m.getNameEn();





 





            }





 





        }





 





        return "";





 





    }





 





 





 





 





 





    public String getKey() {





 





        return key;





 





    }





 





 





 





    public void setKey(String key) {





 





        this.key = key;





 





    }





 





 





 





    public String getNameCn() {





 





        return nameCn;





 





    }





 





 





 





    public void setNameCn(String nameCn) {





 





        this.nameCn = nameCn;





 





    }





 





 





 





    public String getNameEn() {





 





        return nameEn;





 





    }





 





 





 





    public void setNameEn(String nameEn) {





 





        this.nameEn = nameEn;





 





    }





 





}

3，测试：

把上面的cron表达式的例子拿来测试：






 





//测试方法





 





    public static void main(String[] args) {





 





        testCronExpression();





 





    }





 





    private static void testCronExpression() {





 





        String cronExpression = "";





 





 





 





//        0 0 2 1 * ? *   表示在每月的1日的凌晨2点





 





        cronExpression = "0 0 2 1 * ? *";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





//       0 15 10 ? * 2-6   表示周一到周五每天上午10:15执行作业





 





        cronExpression = "0 15 10 ? * 2-6";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        // 每天上午10点，下午2点，4点





 





        cronExpression = "0 0 10,14,16 * * ?";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        //            在每天下午2点到下午2:05期间的每1分钟触发





 





        cronExpression = "0 5 14-16 * * ?";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        //        每月最后一日的上午10:15触发





 





        cronExpression = "0 15 10 L * ? ";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        //           每月的第三个星期五上午10:15触发





 





        cronExpression = "0 15 10 ? * 6";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        // 2002 每天中午12点触发





 





        cronExpression = "0 0 12 * * ? 2002";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        // 2002-2005年 每天中午12点触发





 





        cronExpression = "0 15 10 ? * ? 2002-2005";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        //        0 15 10 ? * 6L    每月的最后一个星期五上午10:15触发





 





        cronExpression = "0 15 10 ? * 6L";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        cronExpression = "0 15 10 6#4 * ?";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





//        0 15 10 * * ? *    每天上午10:15触发





 





         cronExpression = "0 15 10 * * ? *";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





//        0 15 10 * * ? 2005    2005年的每天上午10:15触发





 





                cronExpression = " 0 15 10 * * ? 2005";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





//      0 * 14 * * ?     在每天下午2点到下午2:59期间的每1分钟触发





 





        cronExpression = "0 * 14 * * ?";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        // 0 0/5 14 * * ?    在每天下午2点到下午2:55期间的每5分钟触发





 





        cronExpression = "0 0/5 14 * * ?";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





//        "0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发





 





        cronExpression = "0 0/5 14,18 * * ?";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





        cronExpression = "8/10 0/5 3/4 * * ?";





 





        System.out.println(cronExpression);





 





        System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));





 





 





 





    }

4，测试输出：






0 0 2 1 * ? *





 





每月第1天2小时执行一次





 





0 15 10 ? * 2-6





 





每周的星期一到星期五10小时15分钟执行一次





 





0 0 10,14,16 * * ?





 





每天10,14,16小时执行一次





 





0 5 14-16 * * ?





 





每天14-16小时5分钟执行一次





 





0 15 10 L * ?





 





每月最后一天10小时15分钟执行一次





 





0 15 10 ? * 6





 





每周的星期五10小时15分钟执行一次





 





0 0 12 * * ? 2002





 





2002年每天12小时执行一次





 





0 15 10 ? * ? 2002-2005





 





2002-2005年每天10小时15分钟执行一次





 





0 15 10 ? * 6L





 





每月的最后一周的星期五10小时15分钟执行一次





 





0 15 10 6#4 * ?





 





每月第4周星期五10小时15分钟执行一次





 





0 15 10 * * ? *





 





每天10小时15分钟执行一次





 





 0 15 10 * * ? 2005





 





 





 





0 * 14 * * ?











每天14小时执行一次





 





0 0/5 14 * * ?





 





每天14小时从0分钟开始到55分钟范围内,每隔5分钟执行一次





 





8/10 0/5 3/4 * * ?





 





每天从3小时开始到23小时范围内,每隔4小时从0分钟开始到55分钟范围内,每隔5分钟从8秒开始到58秒范围内,每隔10秒执行一次

总结：

cron表达式的规则并不简单，对于常见常用的进行解析基本就够了，不然解析起来也是很麻烦的。先理解表达式的含义，再进行解析，使用在线工具去测试，即时获得反馈，再修改，再调整。