精华内容
下载资源
问答
  • 动态读取cron表达式

    2018-09-18 10:18:00
    项目中在使用任务调度时往往会...解决方案:我们可以将cron表达式写入配置文件,然后读取。 以下是两种实现方式: 可以把Scheduled写到xml文件中进行配置。 @Scheduled(cron="0/5 * * * * ? ") 改为 @Scheduled(cro...

    项目中在使用任务调度时往往会用到cron表达式,比如每五分钟执行一次,每天12点执行一次,每周四凌晨1点执行一次等。但是如果将cron表达式写死,往往不利于测试。解决方案:我们可以将cron表达式写入配置文件,然后读取。

    以下是两种实现方式:

    • 可以把Scheduled写到xml文件中进行配置。
    • @Scheduled(cron="0/5 * * * * ? ") 改为 @Scheduled(cron="${"${jobs.schedule}") }") ,然后在配置文件中读取jobs.schedule=0/5 * * * * ?

    转载于:https://www.cnblogs.com/yanfei1819/p/9667419.html

    展开全文
  • Cron表达式

    千次阅读 2018-08-22 09:35:55
    表达式遵循一定的规则、约定,然后框架读取的时候,按照这种约定去读取解析Cron表达式,从而达到定时的效果 2.语法格式 一个Cron表达式由6/7个时间域组成,每个域代表着不同的时间范围,这6/7个域组合使用,...
    Cron表达式
    1.场景说明
    最近在组内做任务计划时,遇到了Cron表达式,周期性地做某件事,在特定的时间提醒,可以用Cron表达式,还有在Spring定时器中,也会要用到Cron表达式
    表达式遵循一定的规则、约定,然后框架读取的时候,按照这种约定去读取解析Cron表达式,从而达到定时的效果
    2.语法格式
    一个Cron表达式由6/7个时间域组成,每个域代表着不同的时间范围,这6/7个域组合使用,基本上可以表示任何的周期性时间。
    Seconds Minutes Hours DayofMonth Month DayofWeek Year或 
    Seconds Minutes Hours DayofMonth Month DayofWeek
    3.域的范围
        1)	Seconds
        , - * /   0-59
        2)	Minute
        , - * /   0-59
        3)	Hours
        , - * /   0-23
        4)	DayofMonth
        , - * / ? L W C   0-31
        5)	Month
        , - * /    1-12或者JAN-Dec
        6)	DayofWeek
        , - * / ? L C #"四个字符,有效范围为1-7的整数或SUN-SAT两个范围。1表示星期天,2表示星期一…                                                    (西方以周日为一周的起始)
        7)	Year
        , - * /     1970-2099
    4.字符解释
        1)	/
        用法:起始量/增量,例如,在hours域,9/1,表示,从9点来时,每1小时提醒一次
        2)	?、L
        这两个字符只有在DayofWeek和DayofMonth中可用
        ?表示与其无关紧要
        L表示最后的,DayofWeek域如果是5L,则表示最后一周的周日
        3)	–
        表示范围,例如在Minutes域使用5-20,表示从5分到20分钟每分钟触发一次
        4)	*
        表示匹配该域的任意值,假如在Minutes域使用*, 即表示每分钟都会触发事件
        5)	#
        用于确定每个月第几个星期几,只能出现在DayofMonth域。例如在4#2,表示某月的第二个星期三
        6)	W
        表示有效工作日(周一到周五),只能出现在DayofMonth域,系统将在离指定日期的最近的有效工作日触发事件。例如:在 DayofMonth使用5W,如果5日是星期六,则将在最近的工作日:星期五,即4日触发。如果5日是星期天,则在6日(周一)触发;如果5日在星期一 到星期五中的一天,则就在5日触发。另外一点,W的最近寻找不会跨过月份
        7)	LW
        这两个字符可以连用,表示在某个月最后一个工作日,即最后一个星期五。
        8)	C
        C指和calendar联系后计算过的值。例:在day-of-month 字段用“5C”指在这个月第5天或之后包括calendar的第一天;在day-of-week字段用“1C”指在这周日或之后包括calendar的第一天。
    5.简单举例
        */5 * * * * ? 每隔5秒执行一次
        0 */1 * * * ? 每隔1分钟执行一次
        0 0 5-15 * * ? 每天5-15点整点触发
        0 0/3 * * * ? 每三分钟触发一次
        0 0-5 14 * * ? 在每天下午2点到下午2:05期间的每1分钟触发 
        0 0/5 14 * * ? 在每天下午2点到下午2:55期间的每5分钟触发
        0 0/5 14,18 * * ? 在每天下午2点到2:55期间和下午6点到6:55期间的每5分钟触发
        0 0/30 9-17 * * ? 朝九晚五工作时间内每半小时
        0 0 10,14,16 * * ? 每天上午10点,下午2点,4点 
        
        0 0 12 ? * WED 表示每个星期三中午12点
        0 0 17 ? * TUES,THUR,SAT 每周二、四、六下午五点
        0 10,44 14 ? 3 WED 每年三月的星期三的下午2:10和2:44触发 
        0 15 10 ? * MON-FRI 周一至周五的上午10:15触发
        0 0 23 L * ? 每月最后一天23点执行一次
        0 15 10 L * ? 每月最后一日的上午10:15触发 
        0 15 10 ? * 6L 每月的最后一个星期五上午10:15触发 
        0 15 10 * * ? 2005 2005年的每天上午10:15触发 
        0 15 10 ? * 6L 2002-2005 2002年至2005年的每月的最后一个星期五上午10:15触发 
        0 15 10 ? * 6#3 每月的第三个星期五上午10:15触发
        
        "30 * * * * ?" 每半分钟触发任务
        "30 10 * * * ?" 每小时的10分30秒触发任务
        "30 10 1 * * ?" 每天1点10分30秒触发任务
        "30 10 1 20 * ?" 每月20号1点10分30秒触发任务
        "30 10 1 20 10 ? *" 每年10月20号1点10分30秒触发任务
        "30 10 1 20 10 ? 2011" 2011年10月20号1点10分30秒触发任务
        "30 10 1 ? 10 * 2011" 2011年10月每天1点10分30秒触发任务
        "30 10 1 ? 10 SUN 2011" 2011年10月每周日1点10分30秒触发任务
        "15,30,45 * * * * ?" 每15秒,30秒,45秒时触发任务    
        "15-45 * * * * ?" 15到45秒内,每秒都触发任务
        "15/5 * * * * ?" 每分钟的每15秒开始触发,每隔5秒触发一次
        "15-30/5 * * * * ?" 每分钟的15秒到30秒之间开始触发,每隔5秒触发一次
        "0 0/3 * * * ?" 每小时的第0分0秒开始,每三分钟触发一次
        "0 15 10 ? * MON-FRI" 星期一到星期五的10点15分0秒触发任务
        "0 15 10 L * ?" 每个月最后一天的10点15分0秒触发任务
        "0 15 10 LW * ?" 每个月最后一个工作日的10点15分0秒触发任务
        "0 15 10 ? * 5L" 每个月最后一个星期四的10点15分0秒触发任务
        "0 15 10 ? * 5#3" 每个月第三周的星期四的10点15分0秒触发任务
    6.傻瓜方式
        实在不会,就在线生成吧http://cron.qqe2.com/
    
    
    

     

    展开全文
  • Cron表达式定义及详情 请参考https://blog.csdn.net/HybridTheory_/article/details/88382442 使用C#解析Cron表达式,得到执行时间 class Cron { private int[] seconds = new int[60]; private int[] minutes = ...

    Cron表达式定义及详情

    请参考https://blog.csdn.net/HybridTheory_/article/details/88382442

    使用C#解析Cron表达式,得到执行时间

    class Cron
    {
        private int[] seconds = new int[60];
        private int[] minutes = new int[60];
        private int[] hours = new int[24];
        private int[] days = new int[31];
        private int[] month = new int[12];
        private int[] weeks = new int[7];
        //2019-2099年
        private int[] year = new int[80];
    
        public int[] Seconds { get => seconds; set => seconds = value; }
        public int[] Minutes { get => minutes; set => minutes = value; }
        public int[] Hours { get => hours; set => hours = value; }
        public int[] Days { get => days; set => days = value; }
        public int[] Month { get => month; set => month = value; }
        public int[] Weeks { get => weeks; set => weeks = value; }
        public int[] Year { get => year; set => year = value; }
    
        public Cron()
        {
            for (int i = 0; i < 60; i++)
            {
                seconds[i] = 0;
                minutes[i] = 0;
            }
            for (int i = 0; i < 24; i++)
            {
                hours[i] = 0;
            }
            for (int i = 0; i < 31; i++)
            {
                days[i] = 0;
            }
            for (int i = 0; i < 12; i++)
            {
                month[i] = 0;
            }
            for (int i = 0; i < 7; i++)
            {
                weeks[i] = 0;
            }
            for (int i = 0; i < 80; i++)
            {
                year[i] = 0;
            }
        }
    
        public void Init()
        {
            for (int i = 0; i < 7; i++)
            {
                weeks[i] = 0;
            }
            for (int i = 0; i < 31; i++)
            {
                days[i] = 0;
            }
        }
    }
    
    /// <summary>
    /// 在week上使用  5L表示本月最后一个星期五
    ///               7L表示本月最后一个星期天
    ///               
    /// 在week上使用  7#3表示每月的第三个星期天
    ///               2#4表示每月的第四个星期二
    /// </summary>
    public class CronHelp
    {
        /// <summary>
        /// Cron表达式转换(默认开始时间为当前)
        /// </summary>
        /// <param name="cron">表达式</param>
        /// <returns>最近5次要执行的时间</returns>
        private static List<DateTime> CronToDateTime(string cron)
        {
            try
            {
                List<DateTime> lits = new List<DateTime>();
                Cron c = new Cron();
                string[] arr = cron.Split(' ');
                Seconds(c, arr[0]);
                Minutes(c, arr[1]);
                Hours(c, arr[2]);
                Month(c, arr[4]);
                if (arr.Length < 7)
                {
                    Year(c, null);
                }
                else
                {
                    Year(c, arr[6]);
                }
                DateTime now = DateTime.Now;
                int addtime = 1;
                while (true)
                {
                    if (c.Seconds[now.Second] == 1 && c.Minutes[now.Minute] == 1 && c.Hours[now.Hour] == 1 && c.Month[now.Month - 1] == 1 && c.Year[now.Year - 2019] == 1)
                    {
                        if (arr[3] != "?")
                        {
                            Days(c, arr[3], DateTime.DaysInMonth(now.Year, now.Month), now);
                            int DayOfWeek = (((int)now.DayOfWeek) + 6) % 7;
                            if (c.Days[now.Day - 1] == 1 && c.Weeks[DayOfWeek] == 1)
                            {
                                lits.Add(now);
                            }
                        }
                        else
                        {
                            Weeks(c, arr[5], DateTime.DaysInMonth(now.Year, now.Month), now);
                            int DayOfWeek = (((int)now.DayOfWeek) + 6) % 7;
                            if (c.Days[now.Day - 1] == 1 && c.Weeks[DayOfWeek] == 1)
                            {
                                lits.Add(now);
                            }
                        }
                    }
                    if (lits.Count >= 5)
                    {
                        break;
                    }
                    c.Init();
                    if (!arr[1].Contains('-') && !arr[1].Contains(',') && !arr[1].Contains('*') && !arr[1].Contains('/'))
                    {
                        if (now.Minute == int.Parse(arr[1]))
                        {
                            addtime = 3600;
                        }
                    }
                    else if (arr[0] == "0" && now.Second == 0)
                    {
                        addtime = 60;
                    }
                    now = now.AddSeconds(addtime);
                }
                return lits;
            }
            catch
            {
                return null;
            }
        }
    
        /// <summary>
        /// Cron表达式转换(自定义开始时间)
        /// </summary>
        /// <param name="cron">表达式</param>
        /// <param name="now">开始时间</param>
        /// <returns>最近5次要执行的时间</returns>
        private static List<DateTime> CronToDateTime(string cron, DateTime now)
        {
            try
            {
                List<DateTime> lits = new List<DateTime>();
                Cron c = new Cron();
                string[] arr = cron.Split(' ');
                Seconds(c, arr[0]);
                Minutes(c, arr[1]);
                Hours(c, arr[2]);
                Month(c, arr[4]);
                if (arr.Length < 7)
                {
                    Year(c, null);
                }
                else
                {
                    Year(c, arr[6]);
                }
                int addtime = 1;
                while (true)
                {
                    if (c.Seconds[now.Second] == 1 && c.Minutes[now.Minute] == 1 && c.Hours[now.Hour] == 1 && c.Month[now.Month - 1] == 1 && c.Year[now.Year - 2019] == 1)
                    {
                        if (arr[3] != "?")
                        {
                            Days(c, arr[3], DateTime.DaysInMonth(now.Year, now.Month), now);
                            int DayOfWeek = (((int)now.DayOfWeek) + 6) % 7;
                            if (c.Days[now.Day - 1] == 1 && c.Weeks[DayOfWeek] == 1)
                            {
                                lits.Add(now);
                            }
                        }
                        else
                        {
                            Weeks(c, arr[5], DateTime.DaysInMonth(now.Year, now.Month), now);
                            int DayOfWeek = (((int)now.DayOfWeek) + 6) % 7;
                            if (c.Days[now.Day - 1] == 1 && c.Weeks[DayOfWeek] == 1)
                            {
                                lits.Add(now);
                            }
                        }
                    }
                    if (lits.Count >= 5)
                    {
                        break;
                    }
                    c.Init();
                    if (!arr[1].Contains('-') && !arr[1].Contains(',') && !arr[1].Contains('*') && !arr[1].Contains('/'))
                    {
                        if (now.Minute == int.Parse(arr[1]))
                        {
                            addtime = 3600;
                        }
                    }
                    else if (arr[0] == "0" && now.Second == 0)
                    {
                        addtime = 60;
                    }
                    now = now.AddSeconds(addtime);
                }
                return lits;
            }
            catch
            {
                return null;
            }
        }
    
        /// <summary>
        /// Cron表达式转换(默认开始时间为当前)
        /// </summary>
        /// <param name="cron">表达式</param>
        /// <returns>最近要执行的时间字符串</returns>
        public static string GetNextDateTime(string cron)
        {
            try
            {
                DateTime now = DateTime.Now;
                string[] arr = cron.Split(' ');
                if (IsOrNoOne(cron))
                {
                    string date = arr[6] + "/" + arr[4] + "/" + arr[3] + " " + arr[2] + ":" + arr[1] + ":" + arr[0];
                    if (DateTime.Compare(Convert.ToDateTime(date), now) >= 0)
                    {
                        return date;
                    }
                    else
                    {
                        return null;
                    }
                }
                Cron c = new Cron();
                Seconds(c, arr[0]);
                Minutes(c, arr[1]);
                Hours(c, arr[2]);
                Month(c, arr[4]);
                if (arr.Length < 7)
                {
                    Year(c, null);
                }
                else
                {
                    Year(c, arr[6]);
                }
                int addtime = 1;
                while (true)
                {
                    if (c.Seconds[now.Second] == 1 && c.Minutes[now.Minute] == 1 && c.Hours[now.Hour] == 1 && c.Month[now.Month - 1] == 1 && c.Year[now.Year - 2019] == 1)
                    {
                        if (arr[3] != "?")
                        {
                            Days(c, arr[3], DateTime.DaysInMonth(now.Year, now.Month), now);
                            int DayOfWeek = (((int)now.DayOfWeek) + 6) % 7;
                            if (c.Days[now.Day - 1] == 1 && c.Weeks[DayOfWeek] == 1)
                            {
                                return now.ToString("yyyy/MM/dd HH:mm:ss");
                            }
                        }
                        else
                        {
                            Weeks(c, arr[5], DateTime.DaysInMonth(now.Year, now.Month), now);
                            int DayOfWeek = (((int)now.DayOfWeek) + 6) % 7;
                            if (c.Days[now.Day - 1] == 1 && c.Weeks[DayOfWeek] == 1)
                            {
                                return now.ToString("yyyy/MM/dd HH:mm:ss");
                            }
                        }
                    }
                    c.Init();
                    if (!arr[1].Contains('-') && !arr[1].Contains(',') && !arr[1].Contains('*') && !arr[1].Contains('/'))
                    {
                        if (now.Minute == int.Parse(arr[1]))
                        {
                            addtime = 3600;
                        }
                    }
                    else if (arr[0] == "0" && now.Second == 0)
                    {
                        addtime = 60;
                    }
                    now = now.AddSeconds(addtime);
                }
            }
            catch
            {
                return null;
            }
        }
    
        /// <summary>
        /// Cron表达式转换(自定义开始时间)
        /// </summary>
        /// <param name="cron">表达式</param>
        /// <param name="now">开始时间</param>
        /// <returns>最近要执行的时间字符串</returns>
        public static string GetNextDateTime(string cron, DateTime now)
        {
            try
            {
                string[] arr = cron.Split(' ');
                if (IsOrNoOne(cron))
                {
                    string date = arr[6] + "/" + arr[4] + "/" + arr[3] + " " + arr[2] + ":" + arr[1] + ":" + arr[0];
                    if(DateTime.Compare(Convert.ToDateTime(date),now)>0)
                    {
                        return date;
                    }
                    else
                    {
                        return null;
                    }
                }
                Cron c = new Cron();
                Seconds(c, arr[0]);
                Minutes(c, arr[1]);
                Hours(c, arr[2]);
                Month(c, arr[4]);
                if (arr.Length < 7)
                {
                    Year(c, null);
                }
                else
                {
                    Year(c, arr[6]);
                }
                int addtime = 1;
                while (true)
                {
                    if (c.Seconds[now.Second] == 1 && c.Minutes[now.Minute] == 1 && c.Hours[now.Hour] == 1 && c.Month[now.Month - 1] == 1 && c.Year[now.Year - 2019] == 1)
                    {
                        if (arr[3] != "?")
                        {
                            Days(c, arr[3], DateTime.DaysInMonth(now.Year, now.Month), now);
                            int DayOfWeek = (((int)now.DayOfWeek) + 6) % 7;
                            if (c.Days[now.Day - 1] == 1 && c.Weeks[DayOfWeek] == 1)
                            {
                                return now.ToString("yyyy/MM/dd HH:mm:ss");
                            }
                        }
                        else
                        {
                            Weeks(c, arr[5], DateTime.DaysInMonth(now.Year, now.Month), now);
                            int DayOfWeek = (((int)now.DayOfWeek) + 6) % 7;
                            if (c.Days[now.Day - 1] == 1 && c.Weeks[DayOfWeek] == 1)
                            {
                                return now.ToString("yyyy/MM/dd HH:mm:ss");
                            }
                        }
                    }
                    c.Init();
                    if (!arr[1].Contains('-') && !arr[1].Contains(',') && !arr[1].Contains('*') && !arr[1].Contains('/'))
                    {
                        if (now.Minute == int.Parse(arr[1]))
                        {
                            addtime = 3600;
                        }
                    }
                    else if (arr[0] == "0" && now.Second == 0)
                    {
                        addtime = 60;
                    }
                    now = now.AddSeconds(addtime);
                }
            }
            catch
            {
                return null;
            }
        }
    
        /// <summary>
        /// Cron表达式转换成中文描述
        /// </summary>
        /// <param name="cronExp"></param>
        /// <returns></returns>
        public static string TranslateToChinese(string cronExp)
        {
            if (cronExp == null || cronExp.Length < 1)
            {
                return "cron表达式为空";
            }
            string[] tmpCorns = cronExp.Split(" ");
            StringBuilder sBuffer = new StringBuilder();
            if (tmpCorns.Length == 6)
            {
                //解析月
                if (!tmpCorns[4].Equals("*"))
                {
                    sBuffer.Append(tmpCorns[4]).Append("月");
                }
                else
                {
                    sBuffer.Append("每月");
                }
                //解析周
                if (!tmpCorns[5].Equals("*") && !tmpCorns[5].Equals("?"))
                {
                    char[] tmpArray = tmpCorns[5].ToCharArray();
                    foreach (char tmp in 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;
                            case '-':
                                sBuffer.Append("至");
                                break;
                            default:
                                sBuffer.Append(tmp);
                                break;
                        }
                    }
                }
    
                //解析日
                if (!tmpCorns[3].Equals("?"))
                {
                    if (!tmpCorns[3].Equals("*"))
                    {
                        sBuffer.Append(tmpCorns[3]).Append("日");
                    }
                    else
                    {
                        sBuffer.Append("每日");
                    }
                }
    
                //解析时
                if (!tmpCorns[2].Equals("*"))
                {
                    sBuffer.Append(tmpCorns[2]).Append("时");
                }
                else
                {
                    sBuffer.Append("每时");
                }
    
                //解析分
                if (!tmpCorns[1].Equals("*"))
                {
                    sBuffer.Append(tmpCorns[1]).Append("分");
                }
                else
                {
                    sBuffer.Append("每分");
                }
    
                //解析秒
                if (!tmpCorns[0].Equals("*"))
                {
                    sBuffer.Append(tmpCorns[0]).Append("秒");
                }
                else
                {
                    sBuffer.Append("每秒");
                }
            }
            return sBuffer.ToString();
        }
    
        #region 初始化Cron对象
        private static void Seconds(Cron c, string str)
        {
            if (str == "*")
            {
                for (int i = 0; i < 60; i++)
                {
                    c.Seconds[i] = 1;
                }
            }
            else if (str.Contains('-'))
            {
                int begin = int.Parse(str.Split('-')[0]);
                int end = int.Parse(str.Split('-')[1]);
                for (int i = begin; i <= end; i++)
                {
                    c.Seconds[i] = 1;
                }
            }
            else if (str.Contains('/'))
            {
                int begin = int.Parse(str.Split('/')[0]);
                int interval = int.Parse(str.Split('/')[1]);
                while (true)
                {
                    c.Seconds[begin] = 1;
                    if ((begin + interval) >= 60)
                        break;
                    begin += interval;
                }
            }
            else if (str.Contains(','))
            {
    
                for (int i = 0; i < str.Split(',').Length; i++)
                {
                    c.Seconds[int.Parse(str.Split(',')[i])] = 1;
                }
            }
            else
            {
                c.Seconds[int.Parse(str)] = 1;
            }
        }
        private static void Minutes(Cron c, string str)
        {
            if (str == "*")
            {
                for (int i = 0; i < 60; i++)
                {
                    c.Minutes[i] = 1;
                }
            }
            else if (str.Contains('-'))
            {
                int begin = int.Parse(str.Split('-')[0]);
                int end = int.Parse(str.Split('-')[1]);
                for (int i = begin; i <= end; i++)
                {
                    c.Minutes[i] = 1;
                }
            }
            else if (str.Contains('/'))
            {
                int begin = int.Parse(str.Split('/')[0]);
                int interval = int.Parse(str.Split('/')[1]);
                while (true)
                {
                    c.Minutes[begin] = 1;
                    if ((begin + interval) >= 60)
                        break;
                    begin += interval;
                }
            }
            else if (str.Contains(','))
            {
    
                for (int i = 0; i < str.Split(',').Length; i++)
                {
                    c.Minutes[int.Parse(str.Split(',')[i])] = 1;
                }
            }
            else
            {
                c.Minutes[int.Parse(str)] = 1;
            }
        }
        private static void Hours(Cron c, string str)
        {
            if (str == "*")
            {
                for (int i = 0; i < 24; i++)
                {
                    c.Hours[i] = 1;
                }
            }
            else if (str.Contains('-'))
            {
                int begin = int.Parse(str.Split('-')[0]);
                int end = int.Parse(str.Split('-')[1]);
                for (int i = begin; i <= end; i++)
                {
                    c.Hours[i] = 1;
                }
            }
            else if (str.Contains('/'))
            {
                int begin = int.Parse(str.Split('/')[0]);
                int interval = int.Parse(str.Split('/')[1]);
                while (true)
                {
                    c.Hours[begin] = 1;
                    if ((begin + interval) >= 24)
                        break;
                    begin += interval;
                }
            }
            else if (str.Contains(','))
            {
    
                for (int i = 0; i < str.Split(',').Length; i++)
                {
                    c.Hours[int.Parse(str.Split(',')[i])] = 1;
                }
            }
            else
            {
                c.Hours[int.Parse(str)] = 1;
            }
        }
        private static void Month(Cron c, string str)
        {
            if (str == "*")
            {
                for (int i = 0; i < 12; i++)
                {
                    c.Month[i] = 1;
                }
            }
            else if (str.Contains('-'))
            {
                int begin = int.Parse(str.Split('-')[0]);
                int end = int.Parse(str.Split('-')[1]);
                for (int i = begin; i <= end; i++)
                {
                    c.Month[i - 1] = 1;
                }
            }
            else if (str.Contains('/'))
            {
                int begin = int.Parse(str.Split('/')[0]);
                int interval = int.Parse(str.Split('/')[1]);
                while (true)
                {
                    c.Month[begin - 1] = 1;
                    if ((begin + interval) >= 12)
                        break;
                    begin += interval;
                }
            }
            else if (str.Contains(','))
            {
    
                for (int i = 0; i < str.Split(',').Length; i++)
                {
                    c.Month[int.Parse(str.Split(',')[i]) - 1] = 1;
                }
            }
            else
            {
                c.Month[int.Parse(str) - 1] = 1;
            }
        }
        private static void Year(Cron c, string str)
        {
            if (str == null || str == "*")
            {
                for (int i = 0; i < 80; i++)
                {
                    c.Year[i] = 1;
                }
            }
            else if (str.Contains('-'))
            {
                int begin = int.Parse(str.Split('-')[0]);
                int end = int.Parse(str.Split('-')[1]);
                for (int i = begin - 2019; i <= end - 2019; i++)
                {
                    c.Year[i] = 1;
                }
            }
            else
            {
                c.Year[int.Parse(str) - 2019] = 1;
            }
        }
        private static void Days(Cron c, string str, int len, DateTime now)
        {
            for (int i = 0; i < 7; i++)
            {
                c.Weeks[i] = 1;
            }
            if (str == "*" || str == "?")
            {
                for (int i = 0; i < len; i++)
                {
                    c.Days[i] = 1;
                }
            }
            else if (str.Contains('-'))
            {
                int begin = int.Parse(str.Split('-')[0]);
                int end = int.Parse(str.Split('-')[1]);
                for (int i = begin; i <= end; i++)
                {
                    c.Days[i - 1] = 1;
                }
            }
            else if (str.Contains('/'))
            {
                int begin = int.Parse(str.Split('/')[0]);
                int interval = int.Parse(str.Split('/')[1]);
                while (true)
                {
                    c.Days[begin - 1] = 1;
                    if ((begin + interval) >= len)
                        break;
                    begin += interval;
                }
            }
            else if (str.Contains(','))
            {
                for (int i = 0; i < str.Split(',').Length; i++)
                {
                    c.Days[int.Parse(str.Split(',')[i]) - 1] = 1;
                }
            }
            else if (str.Contains('L'))
            {
                int i = str.Replace("L", "") == "" ? 0 : int.Parse(str.Replace("L", ""));
                c.Days[len - 1 - i] = 1;
            }
            else if (str.Contains('W'))
            {
                c.Days[len - 1] = 1;
            }
            else
            {
                c.Days[int.Parse(str) - 1] = 1;
            }
        }
        private static void Weeks(Cron c, string str, int len, DateTime now)
        {
            if (str == "*" || str == "?")
            {
                for (int i = 0; i < 7; i++)
                {
                    c.Weeks[i] = 1;
                }
            }
            else if (str.Contains('-'))
            {
                int begin = int.Parse(str.Split('-')[0]);
                int end = int.Parse(str.Split('-')[1]);
                for (int i = begin; i <= end; i++)
                {
                    c.Weeks[i - 1] = 1;
                }
            }
            else if (str.Contains(','))
            {
                for (int i = 0; i < str.Split(',').Length; i++)
                {
                    c.Weeks[int.Parse(str.Split(',')[i]) - 1] = 1;
                }
            }
            else if (str.Contains('L'))
            {
                int i = str.Replace("L", "") == "" ? 0 : int.Parse(str.Replace("L", ""));
                if (i == 0)
                {
                    c.Weeks[6] = 1;
                }
                else
                {
                    c.Weeks[i - 1] = 1;
                    c.Days[GetLastWeek(i, now) - 1] = 1;
                    return;
                }
            }
            else if (str.Contains('#'))
            {
                int i = int.Parse(str.Split('#')[0]);
                int j = int.Parse(str.Split('#')[1]);
                c.Weeks[i - 1] = 1;
                c.Days[GetWeek(i - 1, j, now)] = 1;
                return;
            }
            else
            {
                c.Weeks[int.Parse(str) - 1] = 1;
            }
            //week中初始化day,则说明day没要求
            for (int i = 0; i < len; i++)
            {
                c.Days[i] = 1;
            }
        }
        #endregion
    
        #region 方法
    
        public static bool IsOrNoOne(string cron)
        {
            if (cron.Contains('-') || cron.Contains(',') || cron.Contains('/') || cron.Contains('*'))
            {
                return false;
            }
            else
            {
                return true;
            }
        }
    
        /// <summary>
        /// 获取最后一个星期几的day
        /// </summary>
        /// <param name="i">星期几</param>
        /// <param name="now"></param>
        /// <returns></returns>
        private static int GetLastWeek(int i, DateTime now)
        {
            DateTime d = now.AddDays(1 - now.Day).Date.AddMonths(1).AddSeconds(-1);
            int DayOfWeek = ((((int)d.DayOfWeek) + 6) % 7) + 1;
            int a = DayOfWeek >= i ? DayOfWeek - i : 7 + DayOfWeek - i;
            return DateTime.DaysInMonth(now.Year, now.Month) - a;
        }
        /// <summary>
        /// 获取当月第几个星期几的day
        /// </summary>
        /// <param name="i">星期几</param>
        /// <param name="j">第几周</param>
        /// <param name="now"></param>
        /// <returns></returns>
        public static int GetWeek(int i, int j, DateTime now)
        {
            int day = 0;
            DateTime d = new DateTime(now.Year, now.Month, 1);
            int DayOfWeek = ((((int)d.DayOfWeek) + 6) % 7) + 1;
            if (i >= DayOfWeek)
            {
                day = (7 - DayOfWeek + 1) + 7 * (j - 2) + i;
            }
            else
            {
                day = (7 - DayOfWeek + 1) + 7 * (j - 1) + i;
            }
            return day;
        }
        #endregion
    
    }
    

    调用方法示例

    string cron="0 15 10 * * ?";
    CronHelp.GetNextDateTime(cron, DateTime.Now);
    CronHelp.CronToDateTime(cron, DateTime.Now);
    CronHelp.CronToDateTime(cron);
    
    展开全文
  • spring定时任务 Cron表达式配置详解

    万次阅读 2015-07-16 10:47:30
    Cron表达式是一个字符串,字符串以5或6个空格隔开,分开工6或7个域,每一个域代表一个含义,Cron有如下两种语法  格式:  Seconds Minutes Hours DayofMonth Month DayofWeek Year 或  Seconds Minutes...

    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,表示某月的第二个星期三。    
    举几个例子:


    代码
    0 0  2  1 *  ? *  表示在每月的1日的凌晨2点调度任务     
    0 15 10 ? *  MON-FRI 表示周一到周五每天上午10:15执行作业             
    0 15 10 ? 6L 2002-2006 表示200-2006年的每个月的最后一个星期五上午10:15执行作业   
    91linux


    一个cron表达式有至少6个(也可能7个)有空格分隔的时间元素。

    按顺序依次为 
    秒(0~59) 
    分钟(0~59)

    小时(0~23)

    天(月)(0~31,但是你需要考虑你月的天数)

    月(0~11)

    天(星期)(1~7 1=SUN 或 SUN,MON,TUE,WED,THU,FRI,SAT)

    7.年份(1970-2099)

    其中每个元素可以是一个值(如6),一个连续区间(9-12),一个间隔时间(8-18/4)(/表示每隔4小时),一个列表(1,3,5),通配符。由于"月份中的日期"和"星期中的日期"这两个元素互斥的,必须要对其中一个设置?.

    0 0 10,14,16 * * ? 每天上午10点,下午2点,4点
    0 0/30 9-17 * * ?   朝九晚五工作时间内每半小时
    0 0 12 ? * WED 表示每个星期三中午12点 
    "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触发


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

    例如:子表达式(天(星期))可以为 “MON-FRI”,“MON,WED,FRI”,“MON-WED,SAT”

    “*”字符代表所有可能的值

    因此,“*”在子表达式(月)里表示每个月的含义,“*”在子表达式(天(星期))表示星期的每一天

    展开全文
  • 一、Cron表达式是一个字符串,字符串以空格隔开,分为5或6个域,每一个域代表一个含义,系统支持的表达式格式如下(DayofWeek 为可选域。): Seconds Minutes Hours DayofMonth Month [DayofWeek] 1 二、字段含义...
  • Cron 表达式教程

    2019-07-20 09:56:28
    Cron 表达式教程 cron是类unix系统的一款实用工具。可以利用其实现周期性在特定日期/...随着时间推移,cron表达式被广泛采用,所以经常会在很多其他程序或库中使用。 使用Crontab cron计划是简单文本文件,lin...
  • Cron官网入口 在后台经常需要一些定时处理的任务,比如微信相关应用所需的access_token,就要定时刷新,官方返回的有效性是7200s,也就是2小时,但是为了保险起见,除了在发现access_token失效后要主动发起请求更新...
  • 在yml文件中配置cron表达式的值: blog: sche: cron: 0 0/1 * * * ? 在@Scheduled注解中引用: @Scheduled(cron = "${blog.sche.cron}") 可以直接读取yml文件中的值,不需要配置config类 ...
  • cron表达式从数据库读取So there I was, stuck with a handful of problems. I had to find a way to use the platform I had available (Windows XP), keep sensitive passwords hidden from users, and enable ...
  • Cron 表达式转换 时间 许多小伙伴初次开发可能遇到 cron 表达式...-- cron 读取工具 --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactI
  • Cron表达式解析

    千次阅读 2017-04-13 13:43:11
    Cron表达式是一个字符串,字符串以5或6个空格隔开,分为6或7个域,每一个域代表一个含义,Cron有如下两种语法格式: Seconds Minutes Hours DayofMonth Month DayofWeek Year 或: Seconds Minutes Hours ...
  • 如果我们想定时任务动态的从数据库或者配置文件读取cron表达式,可以实现Spring提供了一个接口:SchedulingConfigurer,实现接口重写方法就可以动态配置cron。 2.示例 通过读取application.properties文件配置cron...
  • 1. Spring Boot中使用@Scheduled创建定时任务 http://blog.didispace.com/springbootscheduled/ 2.cron表达式 http://blog.didispace.com/springbootscheduled/
  • Spring Boot定时器动态cron表达式,可自定义时间 ..."),其中的cron表达式就不多说明了,而普通的这种方式,注解中的cron是没办法改变的,不能自定义动态的,或者是数据库中去读取,不可配置;但Spring提...
  • cron表达式

    2012-06-01 11:17:00
    cron表达式 1.格式 【秒】【分】【小时】【日】【月】【周】【年】 秒是0-59 ,-*/ 分是0-59 , -*/ 小时是0-23 , -*/ 日:1-31 ,-*/LW 月:1-12 or JAN-DEC ,-*/ 周:1-7 or SUN-SAT ,-*/L# 年 否empty 或...
  • Spring 的 Scheduled 注解 cron表达式cron表达式Spring 的 Scheduled 注解插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建...
  • cron时间转格式--- 读取配置文件中cron时间表达式--- cron时间转格式 — 读取配置文件中cron时间表达式 application.yml room: opencron: 0 30 9 * * ? RoomServiceImpl.java //获取yml配置文件参数值 @Value(${...
  • cron 表达式详解

    千次阅读 2018-12-06 08:48:21
    该命令从标准输入设备读取指令,并将其存放于“crontab”文件中,以供之后读取和执行。该词来源于希腊语 chronos(χρνο),原意是时间。常,crontab储存的指令被守护进程激活, crond常常在后台运行,每一分钟检查...
  • 很简单,三步: 1.在启动类上加入 @EnableScheduling 注解 ...3.配置cron规则 (cron="0 0 0 ? * SUN") 实例: 1.启动类加入注解 @Confiquration @EnableBatchProcessing @EnableSchedul...
  • .netcore 实现基于 cron 表达式的任务调度 原文:.netcore 实现基于 cron 表达式的任务调度.netcore 实现基于 cron 表达式的任务调度 Intro 上次我们实现了一个简单的基于 Timer 的定时任务,详细...
  • cron表达式详解

    2019-05-14 19:24:00
    Crontab Crontab简介 crontab命令常见于Unix和类Unix的...该命令从标准输入设备读取指令,并将其存放于“crontab”文件中,以供之后读取和执行。该词来源于希腊语 chronos(χρνο),原意是时间。通常,crontab储存...
  • 这是一种练习阅读和编写cron表达式的微材料 我们miiiiiight在某些时候也扩大使用AWS风格的语法(与滑稽的“?”的东西无处不在),但简单的MVP仅仅是普通的OLE crons。 读取cron的示例: 15 14 1 * * 用户需要“以...
  • 配置文件application.yml示例: schedules: 3600000 //or schedules: 0/15 * * * * ? 代码示例: @Scheduled(fixedDelayString="${schedules}") //schedules: 3600000 //or @Scheduled(cron="${schedules...
  • yml文件中加配置时间 corn表达式中取配置文件信息
  • 目录 一、前言 二、引入maven依赖 ...在开发中,需要检验cron表达式的合法性以及获取执行时间。在CronUtil中实现了这些功能。 二、引入maven依赖 <dependency> <groupId>com.cronuti
  • @Schedule()注解以及cron表达式详解 @Schedule注解:任务自动化调度。 1. @Scheduled(fixedDelay = 5000) 延迟执行。任务在上个任务完成后达到设置的延时时间就执行。 此处,任务会在上个任务完成后经过5s再执行。 2...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,055
精华内容 2,822
关键字:

cron表达式读取配置