首页 > 其他分享 >CRON表达式转换成中文

CRON表达式转换成中文

时间：2023-02-20 15:35:37浏览次数：45  
标签：转换成 触发 15 String 10 CRON cronExpression 表达式 append

目录

1，cron表达式生成器

2，cron表达式

一，结构

二、各字段的含义

三、常用表达式例子

3，转换成中文：

1，CronExpParserUtil

2，WeekEnum

3，测试：

4，测试输出：

总结：

 

1，cron表达式生成器

在线cron表达式生成器： https://www.bejson.com/othertools/cron/

 使用生成器，即时测试，便于理解和解析cron表达式

 

2，cron表达式

一，结构

Cron表达式是一个表示时间周期的字符串。分为6或7个域，每一个域代表一个含义。 corn从左到右（用空格隔开）

格式：{秒} {分} {时} {日} {月} {周} {年（可选）}

 

（1） Seconds Minutes Hours DayofMonth Month DayofWeek Year

（2）Seconds Minutes Hours DayofMonth Month DayofWeek

 

  DayofMonth 就是day 每天

  DayofWeek 周几

 

二、各字段的含义

字段

允许值

允许的特殊字符

秒（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

 

  
  1. protected final static String[] CRON_TIME_CN = new String[]{"秒", "分钟", "小时", "天", "月","周", "年"};
  2.  
  3.  
  4.  
  5.     private final static Integer HOURS = 24;
  6.  
  7.     private final static Integer TIMESCALE = 60;
  8.  
  9.  
  10.  
  11.  
  12.  
  13.     /**
  14.  
  15.      *  主要解析 斜杆  /：表示起始时间开始触发，然后每隔固定时间触发一次。
  16.  
  17.      *      范围值+开始值 - 间隔值 = 范围内最后执行的值；
  18.  
  19.      *      例如在Hourss域使用3/4,则意味着从第3小时到24+3-4：23小时范围内，第3小时开始触发第一次，然后每隔4小时，即7，11，15，19，23小时等分别触发一次。
  20.  
  21.      *      例如在Minutes域使用5/20,则意味着从第5分钟到60+5-20：45分范围内，第5分钟开始触发第一次，然后每隔20分钟，即25，45分钟等分别触发一次。
  22.  
  23.      *      例如在Seconds域使用8/10,则意味着从第8秒到60+8-10：58秒范围内，第8秒开始触发第一次，然后每隔10秒，即18，28，38，48，58秒等分别触发一次。
  24.  
  25.      *      *
  26.  
  27.      *   对于 *：表示匹配该域的任意值。例如在Minutes域使用*, 即表示每分钟都会触发事件。
  28.  
  29.      *   对于问号  ?：只能用在DayofMonth和DayofWeek两个域，其作用为不指定
  30.  
  31.      *   对于 -：表示范围。例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次。直接进行拼接
  32.  
  33.      *   对于逗号 ,：表示列出枚举值。例如在Minutes域使用5,20 ， 则意味着在5和20分每分钟触发一次。
  34.  
  35.      *   对于L：表示最后，只能出现在DayofWeek和DayofMonth域。
  36.  
  37.      *      如果出现在DayofMonth域，只能使用L，表示当月最后一天
  38.  
  39.      *      如果在DayofWeek域
  40.  
  41.      *          使用数字（1-7）或L（和7的作用一样表示每周的最后一天周六），比如数字"5"表示每周4， "7"或"L"表示每周六
  42.  
  43.      *          使用数字（1-7）结合L，表示当月最后一周的周几，比如"5L" 表示在最后的一周的周四； "3L" 表示最后一周的周二
  44.  
  45.      *   对于#: 用于确定每个月第几个星期几，只能出现在DayofMonth域。
  46.  
  47.      *      例如 "4#2" 表示某月的第二个星期三（4表示星期三，2表示第二周）;
  48.  
  49.      *       “6#3”表示本月第三周的星期五（6表示星期五，3表示第三周）;
  50.  
  51.      *       “2#1”表示本月第一周的星期一;
  52.  
  53.      *       “4#5”表示第五周的星期三。
  54.  
  55.      *
  56.  
  57.      * @param cronExp
  58.  
  59.      * @param cronTimeArr
  60.  
  61.      * @return
  62.  
  63.      */
  64.  
  65.     public static String translateToChinese(String cronExp, String[] cronTimeArr) {
  66.  
  67.         if (cronExp == null || cronExp.length() < 1) {
  68.  
  69.             return "cron表达式为空";
  70.  
  71.         }
  72.  
  73.  
  74.  
  75.         String[] tmpCorns = cronExp.split(" ");
  76.  
  77.         StringBuffer sBuffer = new StringBuffer();
  78.  
  79.         if (tmpCorns.length == 6 || tmpCorns.length == 7) {
  80.  
  81.  
  82.  
  83.             if (tmpCorns.length == 7) {
  84.  
  85.                 //解析年 Year
  86.  
  87.                 String year = tmpCorns[6];
  88.  
  89.                 if((!year.equals("*") && !year.equals("?"))){
  90.  
  91.                     sBuffer.append(year).append(cronTimeArr[6]);
  92.  
  93.                 }
  94.  
  95.  
  96.  
  97.             }
  98.  
  99.  
  100.  
  101.             //解析月 Month 主要解析 /
  102.  
  103.             String months = tmpCorns[4];
  104.  
  105.             if (!months.equals("*") && !months.equals("?")) {
  106.  
  107.                 if (months.contains("/")) {
  108.  
  109.                     sBuffer.append("从").append(months.split("/")[0]).append("号开始").append(",每")
  110.  
  111.                             .append(months.split("/")[1]).append(cronTimeArr[4]);
  112.  
  113.                 } else {
  114.  
  115.                     sBuffer.append("每年").append(months).append(cronTimeArr[4]);
  116.  
  117.                 }
  118.  
  119.             }
  120.  
  121.  
  122.  
  123.             //解析周 DayofWeek  主要解析 , -  1~7/L   1L~7L
  124.  
  125.             String dayofWeek = tmpCorns[5];
  126.  
  127.             if (!dayofWeek.equals("*") && !dayofWeek.equals("?")) {
  128.  
  129.                 if (dayofWeek.contains(",")) {// 多个数字，逗号隔开
  130.  
  131.                     sBuffer.append("每周的第").append(dayofWeek).append(cronTimeArr[3]);
  132.  
  133.                 } else if (dayofWeek.contains("L") && dayofWeek.length() > NumberUtils.INTEGER_ONE) {// 1L-7L
  134.  
  135.                     String weekNum = dayofWeek.split("L")[0];
  136.  
  137.                     String weekName = judgeWeek(weekNum);
  138.  
  139.                     sBuffer.append("每月的最后一周的");
  140.  
  141.                     sBuffer.append(weekName);
  142.  
  143.                 } else if(dayofWeek.contains("-")) {
  144.  
  145.                     String[] splitWeek = dayofWeek.split("-");
  146.  
  147.                     String weekOne = judgeWeek(splitWeek[0]);
  148.  
  149.                     String weekTwo = judgeWeek(splitWeek[1]);
  150.  
  151.                     sBuffer.append("每周的").append(weekOne).append("到").append(weekTwo);
  152.  
  153.                 } else { // 1-7/L
  154.  
  155.                     if("L".equals(dayofWeek)){ // L 转换为7，便于识别
  156.  
  157.                         dayofWeek = "7";
  158.  
  159.                     }
  160.  
  161.                     int weekNums = Integer.parseInt(dayofWeek);
  162.  
  163.                     if(weekNums < 0 || weekNums > 7 ){
  164.  
  165.                         return "cron表达式有误，dayofWeek数字应为1-7";
  166.  
  167.                     }
  168.  
  169.                     sBuffer.append("每周的");
  170.  
  171.                     String weekName = judgeWeek(dayofWeek);
  172.  
  173.                     sBuffer.append(weekName);
  174.  
  175.                 }
  176.  
  177.             }
  178.  
  179.  
  180.  
  181.             //解析日 days -- DayofMonth  需要解析的 / # L W
  182.  
  183. //                 *       “6#3”表示本月第三周的星期五（6表示星期五，3表示第三周）;
  184.  
  185. //     *       “2#1”表示本月第一周的星期一;
  186.  
  187. //     *       “4#5”表示第五周的星期三。
  188.  
  189.             String days = tmpCorns[3];
  190.  
  191.             if (!days.equals("?")&& !days.equals("*")) {
  192.  
  193.  
  194.  
  195.                 if (days.contains("/")) {
  196.  
  197.                     sBuffer.append("每周从第").append(days.split("/")[0]).append("天开始").append(",每")
  198.  
  199.                             .append(days.split("/")[1]).append(cronTimeArr[3]);
  200.  
  201.                 } else if ("L".equals(days)) { // 处理L 每月的最后一天
  202.  
  203.                     sBuffer.append("每月最后一天");
  204.  
  205.                 }  else if ("W".equals(days)) { // 处理W 暂时不懂怎么处理
  206.  
  207.                     sBuffer.append(days);
  208.  
  209.                 }  else if (days.contains("#")) {
  210.  
  211.                     String[] splitDays = days.split("#");
  212.  
  213.                     String weekNum = splitDays[0]; // 前面数字表示周几
  214.  
  215.                     String weekOfMonth = splitDays[1]; // 后面的数字表示第几周 范围1-4 一个月最多4周
  216.  
  217.                     String weekName = judgeWeek(weekNum);
  218.  
  219.                     sBuffer.append("每月第").append(weekOfMonth).append(cronTimeArr[5]).append(weekName);
  220.  
  221.                 } else {
  222.  
  223.                     sBuffer.append("每月第").append(days).append(cronTimeArr[3]);
  224.  
  225.                 }
  226.  
  227.  
  228.  
  229.             } else {
  230.  
  231.                 if (sBuffer.toString().length() == 0 || tmpCorns.length == 7) { // 前面没有内容的话，拼接下
  232.  
  233.                     sBuffer.append("每").append(cronTimeArr[3]);
  234.  
  235.                 }
  236.  
  237.             }
  238.  
  239.  
  240.  
  241.             //解析时 Hours 主要解析 /
  242.  
  243.  
  244.  
  245.             String hours = tmpCorns[2];
  246.  
  247.             if (!hours.equals("*")) {
  248.  
  249.                 if (hours.contains("/")) {
  250.  
  251. //                   sBuffer.append("内，从").append(hours.split("/")[0]).append("时开始").append(",每")
  252.  
  253. //                            .append(hours.split("/")[1]).append(cronTimeArr[2]);
  254.  
  255.                     sBuffer.append(appendGapInfo(hours, HOURS, 2));
  256.  
  257.                 } else {
  258.  
  259.                     if (!(sBuffer.toString().length() > 0)) { // 对于 , 的情况，直接拼接
  260.  
  261.                         sBuffer.append("每天").append(hours).append(cronTimeArr[2]);
  262.  
  263.                     } else {
  264.  
  265.                         sBuffer.append(hours).append(cronTimeArr[2]);
  266.  
  267.                     }
  268.  
  269.                 }
  270.  
  271.             }
  272.  
  273.  
  274.  
  275.             //解析分 Minutes 主要解析 /
  276.  
  277.             String minutes = tmpCorns[1];
  278.  
  279.             if (!minutes.equals("*")) {
  280.  
  281.                 if (minutes.contains("/")) {
  282.  
  283. //                    sBuffer.append("内，从第").append(minutes.split("/")[0]).append("分开始").append(",每")
  284.  
  285. //                            .append(minutes.split("/")[1]).append(cronTimeArr[1]);
  286.  
  287.                     sBuffer.append(appendGapInfo(minutes, TIMESCALE, 1));
  288.  
  289.                 } else if (minutes.equals("0")) {
  290.  
  291.  
  292.  
  293.                 } else if (minutes.contains("-")) {
  294.  
  295.                     String[] splitMinute = minutes.split("-");
  296.  
  297.                     sBuffer.append(splitMinute[0]).append(cronTimeArr[1]).append("到").append(splitMinute[1])
  298.  
  299.                             .append(cronTimeArr[1]).append("每分钟");
  300.  
  301.                 } else {
  302.  
  303.                     sBuffer.append(minutes).append(cronTimeArr[1]);
  304.  
  305.                 }
  306.  
  307.             }
  308.  
  309.  
  310.  
  311.             //解析秒 Seconds 主要解析 /
  312.  
  313.             String seconds = tmpCorns[0];
  314.  
  315.             if (!seconds.equals("*")) {
  316.  
  317.                 if (seconds.contains("/")) {
  318.  
  319. //                    sBuffer.append("内，从第").append(seconds.split("/")[0]).append("秒开始").append(",每")
  320.  
  321. //                            .append(seconds.split("/")[0]).append(cronTimeArr[0]);
  322.  
  323.                     sBuffer.append(appendGapInfo(seconds, TIMESCALE, 0));
  324.  
  325.                 } else if (!seconds.equals("0")) {
  326.  
  327.                     sBuffer.append(seconds).append(cronTimeArr[0]);
  328.  
  329.                 }
  330.  
  331.             }
  332.  
  333.  
  334.  
  335.             if (sBuffer.toString().length() > 0) {
  336.  
  337.                 sBuffer.append("执行一次");
  338.  
  339.             } else {
  340.  
  341.                 sBuffer.append("表达式中文转换异常");
  342.  
  343.             }
  344.  
  345.         }
  346.  
  347.         return sBuffer.toString();
  348.  
  349.     }
  350.  
  351.  
  352.  
  353.  
  354.  
  355.     public static String judgeWeek(String weekNum){
  356.  
  357.         String weekName = WeekEnum.matchNameCn(String.valueOf(weekNum));
  358.  
  359.         int weekNums = Integer.parseInt(weekNum);
  360.  
  361.         if(weekNums < 0 || weekNums > 7 ){
  362.  
  363.             return "cron表达式有误，dayofWeek 数字应为1-7";
  364.  
  365.         }
  366.  
  367.         return StringUtils.isNotEmpty(weekName) ? weekName : String.valueOf(weekNum);
  368.  
  369.     }
  370.  
  371.  
  372.  
  373.     private static String appendGapInfo(String time, int rangeNum, int index){
  374.  
  375.         StringBuffer sBufferTemp = new StringBuffer();
  376.  
  377.         String[] splitTime = time.split("/");
  378.  
  379.         String startNum = splitTime[0];
  380.  
  381.         String gapNum = splitTime[1];
  382.  
  383.         int endNum = rangeNum + Integer.parseInt(startNum) - Integer.parseInt(gapNum);
  384.  
  385.         String endStr = String.valueOf(endNum);
  386.  
  387.         String timeUnit = CRON_TIME_CN[index];
  388.  
  389.         sBufferTemp.append("从").append(startNum).append(timeUnit).append("开始")
  390.  
  391.                 .append("到").append(endStr).append(timeUnit).append("范围内")
  392.  
  393.                 .append(",每隔").append(gapNum).append(timeUnit);
  394.  
  395.         return sBufferTemp.toString();
  396.  
  397.  
  398.  
  399.     }

 

 

2，WeekEnum

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

 

  1.  
  2.  
  3. public enum WeekEnum {
  4.  
  5.     SECONDS("1", "星期天", "Sunday "), MONDAY("2", "星期一", "Monday "), TUESDAY("3", "星期二", "Tuesday "), WEDNESDAY("4",
  6.  
  7.             "星期三", "Wednesday "), THURSDAY("5", "星期四",
  8.  
  9.                     "Thursday "), FRIDAY("6", "星期五", "Friday "), SATURDAY("7", "星期六", "Saturday ");
  10.  
  11.  
  12.  
  13.     private String key;
  14.  
  15.     private String nameCn;
  16.  
  17.     private String nameEn;
  18.  
  19.  
  20.  
  21.     WeekEnum(String key, String nameCn, String nameEn) {
  22.  
  23.         this.key = key;
  24.  
  25.         this.nameCn = nameCn;
  26.  
  27.         this.nameEn = nameEn;
  28.  
  29.     }
  30.  
  31.  
  32.  
  33.     public static String matchNameCn(String code) {
  34.  
  35.         for (WeekEnum m : WeekEnum.values()) {
  36.  
  37.             if (m.getKey().equals(code)) {
  38.  
  39.                 return m.getNameCn();
  40.  
  41.             }
  42.  
  43.         }
  44.  
  45.         return "";
  46.  
  47.     }
  48.  
  49.  
  50.  
  51.     public static String matchNameEn(String code) {
  52.  
  53.         for (WeekEnum m : WeekEnum.values()) {
  54.  
  55.             if (m.getKey().equals(code)) {
  56.  
  57.                 return m.getNameEn();
  58.  
  59.             }
  60.  
  61.         }
  62.  
  63.         return "";
  64.  
  65.     }
  66.  
  67.  
  68.  
  69.  
  70.  
  71.     public String getKey() {
  72.  
  73.         return key;
  74.  
  75.     }
  76.  
  77.  
  78.  
  79.     public void setKey(String key) {
  80.  
  81.         this.key = key;
  82.  
  83.     }
  84.  
  85.  
  86.  
  87.     public String getNameCn() {
  88.  
  89.         return nameCn;
  90.  
  91.     }
  92.  
  93.  
  94.  
  95.     public void setNameCn(String nameCn) {
  96.  
  97.         this.nameCn = nameCn;
  98.  
  99.     }
  100.  
  101.  
  102.  
  103.     public String getNameEn() {
  104.  
  105.         return nameEn;
  106.  
  107.     }
  108.  
  109.  
  110.  
  111.     public void setNameEn(String nameEn) {
  112.  
  113.         this.nameEn = nameEn;
  114.  
  115.     }
  116.  
  117. }

 

 

3，测试：

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

  1.  
  2. //测试方法
  3.  
  4.     public static void main(String[] args) {
  5.  
  6.         testCronExpression();
  7.  
  8.     }
  9.  
  10.     private static void testCronExpression() {
  11.  
  12.         String cronExpression = "";
  13.  
  14.  
  15.  
  16. //        0 0 2 1 * ? *   表示在每月的1日的凌晨2点
  17.  
  18.         cronExpression = "0 0 2 1 * ? *";
  19.  
  20.         System.out.println(cronExpression);
  21.  
  22.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  23.  
  24.  
  25.  
  26. //       0 15 10 ? * 2-6   表示周一到周五每天上午10:15执行作业
  27.  
  28.         cronExpression = "0 15 10 ? * 2-6";
  29.  
  30.         System.out.println(cronExpression);
  31.  
  32.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  33.  
  34.  
  35.  
  36.         // 每天上午10点，下午2点，4点
  37.  
  38.         cronExpression = "0 0 10,14,16 * * ?";
  39.  
  40.         System.out.println(cronExpression);
  41.  
  42.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  43.  
  44.  
  45.  
  46.         //            在每天下午2点到下午2:05期间的每1分钟触发
  47.  
  48.         cronExpression = "0 5 14-16 * * ?";
  49.  
  50.         System.out.println(cronExpression);
  51.  
  52.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  53.  
  54.  
  55.  
  56.         //        每月最后一日的上午10:15触发
  57.  
  58.         cronExpression = "0 15 10 L * ? ";
  59.  
  60.         System.out.println(cronExpression);
  61.  
  62.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  63.  
  64.  
  65.  
  66.         //           每月的第三个星期五上午10:15触发
  67.  
  68.         cronExpression = "0 15 10 ? * 6";
  69.  
  70.         System.out.println(cronExpression);
  71.  
  72.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  73.  
  74.  
  75.  
  76.         // 2002 每天中午12点触发
  77.  
  78.         cronExpression = "0 0 12 * * ? 2002";
  79.  
  80.         System.out.println(cronExpression);
  81.  
  82.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  83.  
  84.  
  85.  
  86.         // 2002-2005年 每天中午12点触发
  87.  
  88.         cronExpression = "0 15 10 ? * ? 2002-2005";
  89.  
  90.         System.out.println(cronExpression);
  91.  
  92.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  93.  
  94.  
  95.  
  96.         //        0 15 10 ? * 6L    每月的最后一个星期五上午10:15触发
  97.  
  98.         cronExpression = "0 15 10 ? * 6L";
  99.  
  100.         System.out.println(cronExpression);
  101.  
  102.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  103.  
  104.  
  105.  
  106.         cronExpression = "0 15 10 6#4 * ?";
  107.  
  108.         System.out.println(cronExpression);
  109.  
  110.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  111.  
  112.  
  113.  
  114. //        0 15 10 * * ? *    每天上午10:15触发
  115.  
  116.          cronExpression = "0 15 10 * * ? *";
  117.  
  118.         System.out.println(cronExpression);
  119.  
  120.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  121.  
  122.  
  123.  
  124. //        0 15 10 * * ? 2005    2005年的每天上午10:15触发
  125.  
  126.                 cronExpression = " 0 15 10 * * ? 2005";
  127.  
  128.         System.out.println(cronExpression);
  129.  
  130.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  131.  
  132.  
  133.  
  134. //      0 * 14 * * ?     在每天下午2点到下午2:59期间的每1分钟触发
  135.  
  136.         cronExpression = "0 * 14 * * ?";
  137.  
  138.         System.out.println(cronExpression);
  139.  
  140.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  141.  
  142.  
  143.  
  144.         // 0 0/5 14 * * ?    在每天下午2点到下午2:55期间的每5分钟触发
  145.  
  146.         cronExpression = "0 0/5 14 * * ?";
  147.  
  148.         System.out.println(cronExpression);
  149.  
  150.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  151.  
  152. //        "0 0/5 14,18 * * ?" 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
  153.  
  154.         cronExpression = "0 0/5 14,18 * * ?";
  155.  
  156.         System.out.println(cronExpression);
  157.  
  158.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  159.  
  160.  
  161.  
  162.         cronExpression = "8/10 0/5 3/4 * * ?";
  163.  
  164.         System.out.println(cronExpression);
  165.  
  166.         System.out.println(translateToChinese(cronExpression, CRON_TIME_CN));
  167.  
  168.  
  169.  
  170.     }

 

4，测试输出：

 

  1. 0 0 2 1 * ? *
  2.  
  3. 每月第1天2小时执行一次
  4.  
  5. 0 15 10 ? * 2-6
  6.  
  7. 每周的星期一到星期五10小时15分钟执行一次
  8.  
  9. 0 0 10,14,16 * * ?
  10.  
  11. 每天10,14,16小时执行一次
  12.  
  13. 0 5 14-16 * * ?
  14.  
  15. 每天14-16小时5分钟执行一次
  16.  
  17. 0 15 10 L * ?
  18.  
  19. 每月最后一天10小时15分钟执行一次
  20.  
  21. 0 15 10 ? * 6
  22.  
  23. 每周的星期五10小时15分钟执行一次
  24.  
  25. 0 0 12 * * ? 2002
  26.  
  27. 2002年每天12小时执行一次
  28.  
  29. 0 15 10 ? * ? 2002-2005
  30.  
  31. 2002-2005年每天10小时15分钟执行一次
  32.  
  33. 0 15 10 ? * 6L
  34.  
  35. 每月的最后一周的星期五10小时15分钟执行一次
  36.  
  37. 0 15 10 6#4 * ?
  38.  
  39. 每月第4周星期五10小时15分钟执行一次
  40.  
  41. 0 15 10 * * ? *
  42.  
  43. 每天10小时15分钟执行一次
  44.  
  45.  0 15 10 * * ? 2005
  46.  
  47.  
  48.  
  49. 0 * 14 * * ?
  51. 每天14小时执行一次
  52.  
  53. 0 0/5 14 * * ?
  54.  
  55. 每天14小时从0分钟开始到55分钟范围内,每隔5分钟执行一次
  56.  
  57. 8/10 0/5 3/4 * * ?
  58.  
  59. 每天从3小时开始到23小时范围内,每隔4小时从0分钟开始到55分钟范围内,每隔5分钟从8秒开始到58秒范围内,每隔10秒执行一次

 

总结：

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

 

 

 

 

 

 

 

 

 

 

 

 

 


 

标签：转换成,触发,15,String,10,CRON,cronExpression,表达式,append
From： https://www.cnblogs.com/DeveloperPan/p/cron-exp-to-chinese.html

相关文章

  • lambda表达式用法
    (参数列表)->{代码块};(inta,intb)->{returna+b;};本质为匿名函数参数的类型可以省略:(a,b)->{returna+b;}当参数只有一个的时候，可以省略():a->{returna*a;};......
  • java正则表达式校验密码必须是包含大小写字母、数字、特殊符号的8位以上组合 或其中至
    一、语法字符 说明\ 将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，n匹配字符n。\n匹配换行符。序列\\\\匹配\\，\\(匹配(。^ 匹配输入字符串开始......
  • Cron 表达式
    0010,14,16**?每天上午10点，下午2点、4点00/309-17**?朝九晚五工作时间内，每半小时0012?*WED表示每个星期三中午12点0012**?每天中午12......
  • 第四章 表达式
    第四章表达式表达式基础运算对象转换：小整数类型会被提升为较大的整数类型重载运算符：当运算符作用在类类型的运算对象时，用户可以自行定义其含义。左值和右值：C......
  • 正则表达式
    \将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，n匹配字符n。\n匹配一个换行符。序列\\匹配\而\(则匹配(。^匹配输入字......
  • XXL-JOB 分布式任务调度框架（Cron表达式、环境搭建、整合SpringBoot、广播任务与动态分
    (目录)xxl-Job分布式任务调度1.概述1.1什么是任务调度我们可以先思考一下业务场景的解决方案：某电商系统需要在每天上午10点，下午3点，晚上8点发放一批优惠券。某银行......
  • python正则表达式
    正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。python中提供了re模块用于正则表达式的匹配1、re.findall：在字符串中找到正则表达式所......
  • shell正则表达式和awk
    一、正则表达式注意事项：使用正则表达式必须加引号。正则表达式主要用来匹配字符串（命令结果，文本内容） 通配符匹配文件（而且是已存在的文件）基本正则表达式扩展正则......
  • quartz Cron 表达式包括以
    转的： Cron表达式包括以下7个字段：秒分小时月内日期月周内日期年（可选字段）特殊字符Cron触发器利用一系列特殊字符，如下所示：反斜线（/）字符表示增量值。例如，在秒字段中......
  • 正则表达式
    正则表达式：匹配字符串能做什么：1.检测输入的字符串是否合法用户输入一个内容时，我们要提前做检测能够提高程序的效率且减轻服务器压力2.从一个大文......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99