记不住Spring中Scheduled中的Cron语法？让我们看看源码吧-低调大师

记不住Spring中Scheduled中的Cron语法？让我们看看源码吧

2020-11-05 452

在Spring源码中，解析cron的源码位于CronExpression中，在创建定时任务的时候，调用了CornExpression.parse方法做解析

public CronTrigger(String expression, ZoneId zoneId) {
    Assert.hasLength(expression, "Expression must not be empty");
    Assert.notNull(zoneId, "ZoneId must not be null");

    this.expression = CronExpression.parse(expression);
    this.zoneId = zoneId;
}

那现在就让我们揭开解析cron表达式的神秘面纱

public static CronExpression parse(String expression) {
    Assert.hasLength(expression, "Expression string must not be empty");
    // 如果 expression 是注解形式，就将注解替换为下面的形式（见尾部）
    expression = resolveMacros(expression);

    // StringUtils.tokenizeToStringArray 与 split方法功能差不多
    String[] fields = StringUtils.tokenizeToStringArray(expression, " ");
    if (fields.length != 6) {
        // cron表达式必须由六项组成
        throw new IllegalArgumentException(String.format(
            "Cron expression must consist of 6 fields (found %d in \"%s\")", fields.length, expression));
    }
    try {
        CronField seconds = CronField.parseSeconds(fields[0]); // 第一项是秒
        CronField minutes = CronField.parseMinutes(fields[1]); // 第二项是分
        CronField hours = CronField.parseHours(fields[2]); // 第三项是时
        CronField daysOfMonth = CronField.parseDaysOfMonth(fields[3]); // 第四项是日
        CronField months = CronField.parseMonth(fields[4]); // 第五项是月
        CronField daysOfWeek = CronField.parseDaysOfWeek(fields[5]); // 第六项是年

        return new CronExpression(seconds, minutes, hours, daysOfMonth, months, daysOfWeek, expression);
    }
    catch (IllegalArgumentException ex) {
        String msg = ex.getMessage() + " in cron expression \"" + expression + "\"";
        throw new IllegalArgumentException(msg, ex);
    }
}

// resolveMacros 函数
private static String resolveMacros(String expression) {
    expression = expression.trim();
    for (int i = 0; i < MACROS.length; i = i + 2) {
        if (MACROS[i].equalsIgnoreCase(expression)) {
            return MACROS[i + 1];
        }
    }
    return expression;
}

private static final String[] MACROS = new String[] {
    "@yearly", "0 0 0 1 1 *",
    "@annually", "0 0 0 1 1 *",
    "@monthly", "0 0 0 1 * *",
    "@weekly", "0 0 0 * * 0",
    "@daily", "0 0 0 * * *",
    "@midnight", "0 0 0 * * *",
    "@hourly", "0 0 * * * *"
};

现在，cron表达式的顺序我们就记住，必须是六项，顺序是秒，分，时，日，月，年或者用系统中定义的MACROS来代替，六项中间用空格隔开。那么究竟每一项是怎么解析和表达的呢？来看看CronField中的相关定义。

// 秒
public static CronField parseSeconds(String value) {
    return BitsCronField.parseSeconds(value);
}

// 这调用栈就跟套娃一样
public static BitsCronField parseSeconds(String value) {
    return parseField(value, Type.SECOND);
}

private static BitsCronField parseField(String value, Type type) {
    Assert.hasLength(value, "Value must not be empty");
    Assert.notNull(type, "Type must not be null");
    try {
        BitsCronField result = new BitsCronField(type);
        // 将字符串按照逗号分隔，也就是，我们在每一项里面都可以用逗号来隔断，代表不同的时间
        String[] fields = StringUtils.delimitedListToStringArray(value, ",");
        for (String field : fields) {
            int slashPos = field.indexOf('/');
            // 判断时间中有没有斜杠
            if (slashPos == -1) {
                // 如果没有，就解析并设置时间范围
                ValueRange range = parseRange(field, type);
                result.setBits(range);
            }
            else {
                String rangeStr = value.substring(0, slashPos);
                String deltaStr = value.substring(slashPos + 1);
                // 根据斜杠前的内容解析并创建时间范围
                ValueRange range = parseRange(rangeStr, type);
                if (rangeStr.indexOf('-') == -1) {
                	// 如果斜杠前的表达式不包含横杠，则将当前range的结束时间设置为当前类型的最大值
                    range = ValueRange.of(range.getMinimum(), type.range().getMaximum());
                }
                int delta = Integer.parseInt(deltaStr);
                if (delta <= 0) {
                    throw new IllegalArgumentException("Incrementer delta must be 1 or higher");
                }
                // 将delta带入进去设置时间范围
                result.setBits(range, delta);
            }
        }
        return result;
    }
    catch (DateTimeException | IllegalArgumentException ex) {
        String msg = ex.getMessage() + " '" + value + "'";
        throw new IllegalArgumentException(msg, ex);
    }
}

// parseRange

private static ValueRange parseRange(String value, Type type) {
    if (value.equals("*")) {
        // 如果是*号，则直接返回该类型的range()
        return type.range();
    }
    else {
        int hyphenPos = value.indexOf('-');
        if (hyphenPos == -1) {
            int result = type.checkValidValue(Integer.parseInt(value));
            // 如果没有横杠，那么时间段的开始和结束都是当前事件点
            return ValueRange.of(result, result);
        }
        else {
            // 如果有横杠，那么时间段的开始为横杠前数字，结束就是横杠后的数字
            int min = Integer.parseInt(value.substring(0, hyphenPos));
            int max = Integer.parseInt(value.substring(hyphenPos + 1));
            min = type.checkValidValue(min); // 校验
            max = type.checkValidValue(max); // 校验
            return ValueRange.of(min, max);
        }
    }
}

// setBits 方法，BitsCronField 在实现的时候用一个长整型的bits来存储一个时间位
private void setBits(ValueRange range) {
    // 如果没有delta
    if (range.getMinimum() == range.getMaximum()) {
        // 如果是一个时间点，由于我们的bits的默认值是0，所以这里的语义就是直接将bits的第range.getMinimum()位，置为1
        setBit((int) range.getMinimum());
    }
    else {
        // 如果是一个时间段，则将Mask左移range.getMinimum()位的值设置为minMask
        // 将Mask无符号右移 - (range.getMaximum() + 1) 位
        // private static final long MASK = 0xFFFFFFFFFFFFFFFFL;
        // 这里整得很复杂是为了避免右移溢出的问题，但是本质上也是在bits的 range.getMinimum() 和 range.getMaximum() 位，置为1
        long minMask = MASK << range.getMinimum();
        long maxMask = MASK >>> - (range.getMaximum() + 1);
        this.bits |= (minMask & maxMask);
    }
}

// 有斜杠的情况调用这个方法
private void setBits(ValueRange range, int delta) {
    if (delta == 1) {
        // 如果有delta，且为1，则跟没有没区别
        setBits(range);
    }
    else {
        // 如果delta不为1，则按照delta为公差设置位置1
        for (int i = (int) range.getMinimum(); i <= range.getMaximum(); i += delta) {
            setBit(i);
        }
    }
}

// 获取当前bits与(1L << index) 按位或的结果，按位或就是 有一则一
// 我们知道，基本类型都是有默认值的，long型的默认值是0
// 例如，如果是一个时间点，由于我们的bits的默认值是0，所以这里的语义就是直接将bits的第range.getMinimum()位置为1
private void setBit(int index) {
    this.bits |= (1L << index);
}

刚刚里面调用了type.range方法，根据调用栈，最终会来到ChronoField枚举中，也就是说，如果是星号，返回的就是当前解析类型的整个事件范围。从这里我们可以看出，星号代表所有当前解析类型的所有时间，如果表达式中有横杠，那么就代表一个时间段，如果是一个纯数字，那么就代表那个时间点。

public enum ChronoField implements TemporalField {
    NANO_OF_SECOND("NanoOfSecond", NANOS, SECONDS, ValueRange.of(0, 999_999_999)),
    NANO_OF_DAY("NanoOfDay", NANOS, DAYS, ValueRange.of(0, 86400L * 1000_000_000L - 1)),
    MICRO_OF_SECOND("MicroOfSecond", MICROS, SECONDS, ValueRange.of(0, 999_999)),
    MICRO_OF_DAY("MicroOfDay", MICROS, DAYS, ValueRange.of(0, 86400L * 1000_000L - 1)),
    MILLI_OF_SECOND("MilliOfSecond", MILLIS, SECONDS, ValueRange.of(0, 999)),
    MILLI_OF_DAY("MilliOfDay", MILLIS, DAYS, ValueRange.of(0, 86400L * 1000L - 1)),
    SECOND_OF_MINUTE("SecondOfMinute", SECONDS, MINUTES, ValueRange.of(0, 59), "second"),
    SECOND_OF_DAY("SecondOfDay", SECONDS, DAYS, ValueRange.of(0, 86400L - 1)),
    MINUTE_OF_HOUR("MinuteOfHour", MINUTES, HOURS, ValueRange.of(0, 59), "minute"),
    MINUTE_OF_DAY("MinuteOfDay", MINUTES, DAYS, ValueRange.of(0, (24 * 60) - 1)),
    HOUR_OF_AMPM("HourOfAmPm", HOURS, HALF_DAYS, ValueRange.of(0, 11)),
    CLOCK_HOUR_OF_AMPM("ClockHourOfAmPm", HOURS, HALF_DAYS, ValueRange.of(1, 12)),
    HOUR_OF_DAY("HourOfDay", HOURS, DAYS, ValueRange.of(0, 23), "hour"),
    CLOCK_HOUR_OF_DAY("ClockHourOfDay", HOURS, DAYS, ValueRange.of(1, 24)),
    AMPM_OF_DAY("AmPmOfDay", HALF_DAYS, DAYS, ValueRange.of(0, 1), "dayperiod"),
    DAY_OF_WEEK("DayOfWeek", DAYS, WEEKS, ValueRange.of(1, 7), "weekday"),
    ALIGNED_DAY_OF_WEEK_IN_MONTH("AlignedDayOfWeekInMonth", DAYS, WEEKS, ValueRange.of(1, 7)),
    ALIGNED_DAY_OF_WEEK_IN_YEAR("AlignedDayOfWeekInYear", DAYS, WEEKS, ValueRange.of(1, 7)),
    DAY_OF_MONTH("DayOfMonth", DAYS, MONTHS, ValueRange.of(1, 28, 31), "day"),
    DAY_OF_YEAR("DayOfYear", DAYS, YEARS, ValueRange.of(1, 365, 366)),
    EPOCH_DAY("EpochDay", DAYS, FOREVER, ValueRange.of((long) (Year.MIN_VALUE * 365.25), (long) (Year.MAX_VALUE * 365.25))),
    ALIGNED_WEEK_OF_MONTH("AlignedWeekOfMonth", WEEKS, MONTHS, ValueRange.of(1, 4, 5)),
    ALIGNED_WEEK_OF_YEAR("AlignedWeekOfYear", WEEKS, YEARS, ValueRange.of(1, 53)),
    MONTH_OF_YEAR("MonthOfYear", MONTHS, YEARS, ValueRange.of(1, 12), "month"),
    PROLEPTIC_MONTH("ProlepticMonth", MONTHS, FOREVER, ValueRange.of(Year.MIN_VALUE * 12L, Year.MAX_VALUE * 12L + 11)),
    YEAR_OF_ERA("YearOfEra", YEARS, FOREVER, ValueRange.of(1, Year.MAX_VALUE, Year.MAX_VALUE + 1)),
    YEAR("Year", YEARS, FOREVER, ValueRange.of(Year.MIN_VALUE, Year.MAX_VALUE), "year"),
    ERA("Era", ERAS, FOREVER, ValueRange.of(0, 1), "era"),
    INSTANT_SECONDS("InstantSeconds", SECONDS, FOREVER, ValueRange.of(Long.MIN_VALUE, Long.MAX_VALUE)),
    OFFSET_SECONDS("OffsetSeconds", SECONDS, FOREVER, ValueRange.of(-18 * 3600, 18 * 3600));

    private final String name;
    private final TemporalUnit baseUnit;
    private final TemporalUnit rangeUnit;
    private final ValueRange range;
    private final String displayNameKey;

    private ChronoField(String name, TemporalUnit baseUnit, TemporalUnit rangeUnit, ValueRange range) {
        this.name = name;
        this.baseUnit = baseUnit;
        this.rangeUnit = rangeUnit;
        this.range = range;
        this.displayNameKey = null;
    }

    private ChronoField(String name, TemporalUnit baseUnit, TemporalUnit rangeUnit,
            ValueRange range, String displayNameKey) {
        this.name = name;
        this.baseUnit = baseUnit;
        this.rangeUnit = rangeUnit;
        this.range = range;
        this.displayNameKey = displayNameKey;
    }

   // ... ...

    @Override
    public ValueRange range() {
        return range;
    }
    // ... ...
}

得出规则

从上面的源码分析，我们可以总结出这样一套cron表达式解析规则

1、cron表达式可以由秒分时日月年六部分注册，每个部分由空格隔开。系统中定义了一组用@开头的字符串来替代标准Cron表达式，不过个数有限
private static final String[] MACROS = new String[] {
    "@yearly", "0 0 0 1 1 *",
    "@annually", "0 0 0 1 1 *",
    "@monthly", "0 0 0 1 * *",
    "@weekly", "0 0 0 * * 0",
    "@daily", "0 0 0 * * *",
    "@midnight", "0 0 0 * * *",
    "@hourly", "0 0 * * * *"
};
例如：
@Scheduled(cron = "@yearly")
public void test(){
    logger.info("123");
}
2、对于每一项，可以用逗号隔开，用来表示不同的时间点

例如：
@Scheduled(cron = "1,2,3 0 0 * * *")
public void test(){
    logger.info("123");
}
3、对于每一项，可以使用横杠隔开，用来表示时间段

例如：
@Scheduled(cron = "1,2-4,5 0 0 * * *")
public void test(){
    logger.info("123");
}
4、对于每一项，可以使用斜杠+横杠的组合，表示在这段时间内，以斜杠后的值为公差的时间点

例如：
@Scheduled(cron = "1,2-20/3,5 0 0 * * *")
public void test(){
    logger.info("123");
}
5、对于每一项，使用星号表示当前时间类型的整个范围

例如：
@Scheduled(cron = "1,2-20/3,5 * * * * *")
public void test(){
    logger.info("123");
}
炒鸡辣鸡原创文章，转载请注明来源

微信关注我们

原文链接：https://my.oschina.net/u/3773302/blog/4704472

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

调试鸿蒙（HarmonyOS）App源代码的两种方式

为了让更多的人看到本文，请各位读者动动小手，点击右上角【...】，将本文分享到朋友圈，thanks！调试是开发App的必备技能，毕竟任何一个比较复杂的App都不可能一次编码成功，如果App的预期与自己期望的不同，或由于某些原因异常中断，就需要查中断的原因，这些都需要调试程序。调试程序有多种方法，比较常用的有设置断点和输出日志两种方式，本文将详细介绍这两种调试App的方式。 1. 设置断点如果认为需要跟踪的代码或bug在某行代码的附近，可以单击该行代码前面的部分为该行设置断点，这时会在这行代码前面出现一个红点，如图1所示。图1 设置断点然后点击上方工具栏中如图2所示的调试运行按钮。图2 调试运行按钮如果未遇到断点，点击该按钮会正常运行程序，一旦遇到断点，程序执行就会在断点处停止执行。知道按F7或F8键才继续一行一行执行程序，以便监控程序中的相关变量的状态。F7表示Step Into，F8表示Step Over。其中Step Into表示会跟踪到方法内部，例如，当前正在执行一个方法，按F7键会继续跟踪到方法内部，然后继续一行一行代码执行。Step Over会将方法当做一行代码...

2020-11-05

527

今天呢，和大家聊一下ThreadLocal。 1. 是什么？ JDK1.2提供的的一个线程绑定变量的类。他的思想就是：给每一个使用到这个资源的线程都克隆一份，实现了不同线程使用不同的资源，且该资源之间相互独立 2. 为什么用？思考一个场景：数据库连接的时候，我们会创建一个Connection连接，让不同的线程使用。这个时候就会出现多个线程争抢同一个资源的情况。这种多个线程争抢同一个资源的情况，很常见，我们常用的解决办法也就两种：空间换时间，时间换空间没有办法，鱼与熊掌不可兼得也。就如我们的CAP理论，也是牺牲其中一项，保证其他两项。而针对上面的场景我们的解决办法如下：空间换时间：为每一个线程创建一个连接。直接在线程工作中，创建一个连接。(重复代码太多) 使用ThreadLocal，为每一个线程绑定一个连接。时间换空间：对当前资源加锁，每一次仅仅存在一个线程可以使用这个连接。通过ThreadLocal为每一个线程绑定一个指定类型的变量，相当于线程私有化 3. 怎么用？ ThreadLocal<Integer> threadLocal = new Thread...

2020-11-05

480

资源下载

更多资源

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。