spring Quartz 源码分析–触发器类CronTriggerBean源码剖析

spring Quartz 源码分析–触发器类CronTriggerBean源码剖析前面我们讲到了Quartz框架在项目中的实现,在Quartz中的重要API有两个重要的触发器类:CronTrigger和SimpleTrigger在Quartz框架中这两个触发器都继承了一个抽象基类Trigger,这个类有触发器共有的属性name,jobName,group,jobGroup以及description;但是在spring框架中使用的触发器类是org.spring…

    前面我们讲到了Quartz框架在项目中的实现,在Quartz中的重要API有两个重要的触发器类:CronTrigger 和SimpleTrigger 
在Quartz框架中这两个触发器都继承了一个抽象基类Trigger,这个类有触发器共有的属性name,jobName,group,jobGroup以及description;

但是在spring框架中使用的触发器类是org.springframework.scheduling.quartz.CronTriggerBean ,该类的源码如下:
package org.springframework.scheduling.quartz;

import java.text.ParseException;
import java.util.Date;
import java.util.Map;
import java.util.TimeZone;
import org.quartz.CronTrigger;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.core.Constants;

public class CronTriggerBean extends CronTrigger
  implements JobDetailAwareTrigger, BeanNameAware, InitializingBean
{
  private static final Constants constants = new Constants(CronTrigger.class);
  private JobDetail jobDetail;
  private String beanName;

  public void setJobDataAsMap(Map jobDataAsMap)
  {
    getJobDataMap().putAll(jobDataAsMap);
  }

  public void setMisfireInstructionName(String constantName)
  {
    setMisfireInstruction(constants.asNumber(constantName).intValue());
  }

  public void setTriggerListenerNames(String[] names)
  {
    for (int i = 0; i < names.length; i++)
      addTriggerListener(names[i]);
  }

  public void setJobDetail(JobDetail jobDetail)
  {
    this.jobDetail = jobDetail;
  }

  public JobDetail getJobDetail() {
    return this.jobDetail;
  }

  public void setBeanName(String beanName) {
    this.beanName = beanName;
  }

  public void afterPropertiesSet() throws ParseException
  {
    if (getName() == null) {
      setName(this.beanName);
    }
    if (getGroup() == null) {
      setGroup("DEFAULT");
    }
    if (getStartTime() == null) {
      setStartTime(new Date());
    }
    if (getTimeZone() == null) {
      setTimeZone(TimeZone.getDefault());
    }
    if (this.jobDetail != null) {
      setJobName(this.jobDetail.getName());
      setJobGroup(this.jobDetail.getGroup());
    }
  }
}


 由此类源码可知,该触发器的核心代码还是在CronTrigger 类中。
但是在这个类中,可以在框架配置文件中设置属性jobDetail,至于另外一个属性cronExpression的设置方法是在类CronTrigger 中的。
public class CronTrigger extends Trigger
{
	......
	private CronExpression cronEx = null;
	......
	//由此可知在spring配置文件中,属性名是和set函数后面的字符串一样的,但首字母小写
	public void setCronExpression(String cronExpression) throws ParseException {
		TimeZone origTz = getTimeZone();
		this.cronEx = new CronExpression(cronExpression);
		this.cronEx.setTimeZone(origTz);
	......
}



我们都知道spring框架IOC的容器管理为核心模块,配置文件的一些bean的设置都是为bean对象设置一些属性值来初始化,在此的触发器类分析,我们只关注触发器如何进行实践周期设置,时间字符串是如何解析的。
我们在spring配置文件中是只配置触发时间字符串的,而在CronTrigger类的public void setCronExpression(String cronExpression)内会根据这字符串来 CronExpression
对象,其中触发时间的解析就发生在这个类里面;
CronExpression类中解析后的结果存放在这些属性中:
   
  protected transient TreeSet seconds;//秒 
  protected transient TreeSet minutes;//分
  protected transient TreeSet hours;//时
  protected transient TreeSet daysOfMonth;//月中第几天
  protected transient TreeSet months;//月
  protected transient TreeSet daysOfWeek;//星期中第几天
  protected transient TreeSet years;//年
  protected transient boolean lastdayOfWeek = false;//是否为星期最后一天
  protected transient int nthdayOfWeek = 0;//
  protected transient boolean lastdayOfMonth = false;//月的最后一天,默认为false	
  protected transient boolean nearestWeekday = false;
  protected transient boolean expressionParsed = false;
这些存储时间信息的属性会在类CronExpression中的下面函数进行初始化
  
protected void buildExpression(String expression)
    throws ParseException
  {
	//刚开始触发时间是否解析设置为false,开始解析则设置为true
    this.expressionParsed = true;
	//初始化存储解析结果的属性
    try
    {
      if (this.seconds == null) {
        this.seconds = new TreeSet();
      }
      if (this.minutes == null) {
        this.minutes = new TreeSet();
      }
      if (this.hours == null) {
        this.hours = new TreeSet();
      }
      if (this.daysOfMonth == null) {
        this.daysOfMonth = new TreeSet();
      }
      if (this.months == null) {
        this.months = new TreeSet();
      }
      if (this.daysOfWeek == null) {
        this.daysOfWeek = new TreeSet();
      }
      if (this.years == null) {
        this.years = new TreeSet();
      }

      int exprOn = 0;
	//将触发时间字符串分割成6个字符串
      StringTokenizer exprsTok = new StringTokenizer(expression, " \t", false);

	//遍历这6个字符串,并分别处理,exprOn 从0-5依次增加,作为辨别字符串不同意义的识别码
      while ((exprsTok.hasMoreTokens()) && (exprOn <= 6)) {
        String expr = exprsTok.nextToken().trim();

	//对每个字符串进行格式判断,如果不正确就中断报错。
        if ((exprOn == 3) && (expr.indexOf('L') != -1) && (expr.length() > 1) && (expr.indexOf(",") >= 0)) {
          throw new ParseException("Support for specifying 'L' and 'LW' with other days of the month is not implemented", -1);
        }

        if ((exprOn == 5) && (expr.indexOf('L') != -1) && (expr.length() > 1) && (expr.indexOf(",") >= 0)) {
          throw new ParseException("Support for specifying 'L' with other days of the week is not implemented", -1);
        }

	//对每个字符串进行按“,”分割,并对每个分割后的字符串进行按识别码exprOn解析。
        StringTokenizer vTok = new StringTokenizer(expr, ",");
        while (vTok.hasMoreTokens()) {
          String v = vTok.nextToken();
          storeExpressionVals(0, v, exprOn);
        }

        exprOn++;
      }

	//如果出发时间字符串分割后的字符串数组大小少于5则中断报错,不符合语法
      if (exprOn <= 5) {
        throw new ParseException("Unexpected end of expression.", expression.length());
      }
	//因为出发时间格式可以为6个字符串,所以当处于这种情况的时候,就将第7个时间数据年设置成“*”,即每年的意义
      if (exprOn <= 6) {
        storeExpressionVals(0, "*", 6);
      }
	//get函数的方法体下面已经给出,指的是获取该类对象中存储触发器时间的存储结果。
      TreeSet dow = getSet(5);
      TreeSet dom = getSet(3);  

      boolean dayOfMSpec = !dom.contains(NO_SPEC);
      boolean dayOfWSpec = !dow.contains(NO_SPEC);

      if ((!dayOfMSpec) || (dayOfWSpec))
      {
        if ((!dayOfWSpec) || (dayOfMSpec))
        {
          throw new ParseException("Support for specifying both a day-of-week AND a day-of-month parameter is not implemented.", 0);
        }
      }
    } catch (ParseException pe) {
      throw pe;
    } catch (Exception e) {
      throw new ParseException("Illegal cron expression format (" + e.toString() + ")", 0);
    }
  }

由这个方法确定,最后的每个字符的意义解析由方法storeExpressionVals完成。
get方法:
/*
*	触发器时间解析后会存放在TreeSet属性中,这个函数就是获取这些属性的引用。
*/
protected TreeSet getSet(int type)
  {
    switch (type) {
    case 0:
      return this.seconds;
    case 1:
      return this.minutes;
    case 2:
      return this.hours;
    case 3:
      return this.daysOfMonth;
    case 4:
      return this.months;
    case 5:
      return this.daysOfWeek;
    case 6:
      return this.years;
    }
    return null;
  }




 
protected int storeExpressionVals(int pos, String s, int type)
    throws ParseException
  {
    int incr = 0;
	//由字符串开始位置遍历,跳过空字符,空字符包括空格,tab键,回车键等。
    int i = skipWhiteSpace(pos, s);
	//如果排除掉所有空字符后,只剩下一个字符或是没有字符,则方法返回,解析结束。
    if (i >= s.length()) {
      return i;
    }
	//获取第一个不为空的字符
    char c = s.charAt(i);
	//判断字符是否为字母,触发时间语法中,只有type为4,5的两项为字母,至于L(当月或这周最后一天) LW(当月最后一个工作日)情况在后面考虑
    if ((c >= 'A') && (c <= 'Z') && (!s.equals("L")) && (!s.equals("LW"))) {
	//前面提到,只有type为4,5的两项为字母,且这两项设置的值为字符个数为3的单词,即月份和周几单词的3个字母的缩写
      String sub = s.substring(i, i + 3);
      int sval = -1;
      int eval = -1;
	//当这项为月份时,通过getMonthNumber函数获取月份数据,在此类属性中,有关于月份单词与数字的映射,星期的映射也是一样。
      if (type == 4) {
        sval = getMonthNumber(sub) + 1;
	//月份数字不大于0报错,接下来的类似情况就不赘述了
        if (sval <= 0) {
          throw new ParseException("Invalid Month value: '" + sub + "'", i);
        }
	//如果该项字符数量不只为3,则该项形式就不是JAN(月份项)或者是SUN(星期项),就是JAN-DEC或者是SUN-SAT,下面就是解析第二种情况
        if (s.length() > i + 3) {
          c = s.charAt(i + 3);
          if (c == '-') {
            i += 4;
	//同样是截取3个字符月份单词,然后通过getMonthNumber函数获取月份数字数据
            sub = s.substring(i, i + 3);
            eval = getMonthNumber(sub) + 1;
            if (eval <= 0)
              throw new ParseException("Invalid Month value: '" + sub + "'", i);
          }
        }
      }
	//这个是星期项的数据解析,该项的解析和月份项的解析类似,读者可以自己分析
      else if (type == 5) {
        sval = getDayOfWeekNumber(sub);
        if (sval < 0) {
          throw new ParseException("Invalid Day-of-Week value: '" + sub + "'", i);
        }

        if (s.length() > i + 3) {
          c = s.charAt(i + 3);
          if (c == '-') {
            i += 4;
            sub = s.substring(i, i + 3);
            eval = getDayOfWeekNumber(sub);
            if (eval < 0) {
              throw new ParseException("Invalid Day-of-Week value: '" + sub + "'", i);
            }

          }
	//对于星期项,这个字符为#的时候,后面跟着的一个数字表示这个月的第几个星期。
          else if (c == '#') {
            try {
              i += 4;
              this.nthdayOfWeek = Integer.parseInt(s.substring(i));
		//因为一个月最多横跨5个星期,不可能横跨6个以上的星期。
              if ((this.nthdayOfWeek < 1) || (this.nthdayOfWeek > 5))
                throw new Exception();
            }
            catch (Exception e) {
              throw new ParseException("A numeric value between 1 and 5 must follow the '#' option", i);
            }

          }
	//如果该项这个字符为L时,表示是该月的最后一个星期,前面加数字或单词表示最后一个星期的星期几
          else if (c == 'L') {
            this.lastdayOfWeek = true;
            i++;
          }
        }
      }
      else {
        throw new ParseException("Illegal characters for this position: '" + sub + "'", i);
      }

      if (eval != -1) {
	//这个是将当每一项未设置递增项时候,默认为1,如月份项为0-8,那么此时会按1从0到8递增将数字0,1,2,3,4....8放入月份TreeSet数据集合中。
        incr = 1;
      }
      addToSet(sval, eval, incr, type);
      return i + 3;
    }
	//如果首个字符为?
    if (c == '?') {
      i++;
	//语法规定,?后面不会再有其他字符或数字,所以此处解析中断跳出处理异常。
      if ((i + 1 < s.length()) && (s.charAt(i) != ' ') && (s.charAt(i + 1) != '\t'))
      {
        throw new ParseException("Illegal character after '?': " + s.charAt(i), i);
      }
	//?字符只能用于dayofmonth和dayofweek这两项,即type为3和5的两项
      if ((type != 5) && (type != 3)) {
        throw new ParseException("'?' can only be specfied for Day-of-Month or Day-of-Week.", i);
      }
	//因为在这两项中,如果dayofmonth项已经有了?,那么在dayofweek就不应该有?了。
      if ((type == 5) && (!this.lastdayOfMonth)) {
        int val = ((Integer)this.daysOfMonth.last()).intValue();
        if (val == 98) {
          throw new ParseException("'?' can only be specfied for Day-of-Month -OR- Day-of-Week.", i);
        }

      }
	//98表示字符为?,99表示字符为*;姑且是猜测。
      addToSet(98, -1, 0, type);
      return i;
    }

	//如果该项第一个字符为*或者是/的时候
    if ((c == '*') || (c == '/')) {
	//此情况是该项只有*,后面就没有了其他字符或数字
      if ((c == '*') && (i + 1 >= s.length())) {
	//由此能证实99就是表示*字符的。
        addToSet(99, -1, incr, type);
        return i + 1;
      }
	//这种情况是字符为“/”的情况下,如果后面没有了字符或者后面的字符为空,解析就中断报错,抛出异常。
      if ((c == '/') && ((i + 1 >= s.length()) || (s.charAt(i + 1) == ' ') || (s.charAt(i + 1) == '\t')))
      {
        throw new ParseException("'/' must be followed by an integer.", i);
      }
	//字符为*,且后面还有不为空的字符
      if (c == '*') {
        i++;
      }
      c = s.charAt(i);
	//*字符后面的字符为/
      if (c == '/') {
        i++;
	//如果“/”字符后面没有了字符,就抛出异常。
        if (i >= s.length()) {
          throw new ParseException("Unexpected end of string.", i);
        }
	//得到“/”后面的数字,这个数字为递增量
        incr = getNumericValue(s, i);

        i++;
        if (incr > 10) {
          i++;
        }
	//下面是在不同type下对递增量incr进行判断,每一项都会有最大的值,因此incr的值不能超过这些值
        if ((incr > 59) && ((type == 0) || (type == 1)))
          throw new ParseException("Increment > 60 : " + incr, i);
        if ((incr > 23) && (type == 2))
          throw new ParseException("Increment > 24 : " + incr, i);
        if ((incr > 31) && (type == 3))
          throw new ParseException("Increment > 31 : " + incr, i);
        if ((incr > 7) && (type == 5))
          throw new ParseException("Increment > 7 : " + incr, i);
        if ((incr > 12) && (type == 4))
          throw new ParseException("Increment > 12 : " + incr, i);
      }
	//首字符为*字符的后面没有“/”的话,递增量incr设置为1.
      else {
        incr = 1;
      }
	//99表示的是*
      addToSet(99, -1, incr, type);
      return i;
    }
	//如果首字符为L,表示本月最后一天或是一个星期的最后一天
    if (c == 'L') {
      i++;
      if (type == 3) {
        this.lastdayOfMonth = true;
      }
      if (type == 5) {
        addToSet(7, 7, 0, type);
      }
	//在dayofmonth项,L和W可以合着一起用,表示获取离设置时间最近的工作日
      if ((type == 3) && (s.length() > i)) {
        c = s.charAt(i);
        if (c == 'W') {
          this.nearestWeekday = true;
          i++;
        }
      }
      return i;
    }
	//如果该项首字符为数字,则该项形式有0,0-4, 10, 10-14,0/2等等
      if ((c >= '0') && (c <= '9')) {
      int val = Integer.parseInt(String.valueOf(c));
      i++;
	//如果只是0这种形式,就直接将这个放到TreeSet数据集合中去
      if (i >= s.length()) {
        addToSet(val, -1, -1, type);
      } else {
	//如果是其他形式,就获取多位数字,并调用checkNext函数,即checkNext函数是解析数字形式的函数。
        c = s.charAt(i);
        if ((c >= '0') && (c <= '9')) {
          ValueSet vs = getValue(val, s, i);
          val = vs.value;
          i = vs.pos;
        }
        i = checkNext(i, s, val, type);
        return i;
      }
    } else {
      throw new ParseException("Unexpected character: " + c, i);
    }

    return i;
  }
对于这个函数都是如何解析触发时间字符串的,我将在函数中的每段代码这个做详细的解释。下面给出的是触发时间的语法:
Cron表达式的格式:秒 分 时 日 月 周 年(可选)。
字段名              允许的值                    允许的特殊字符 
秒                     0-59                           , - * / 
分                     0-59                           , - * / 
小时                  0-23                           , - * / 
日                     1-31                            , - * ? / L W C
月                     1-12 or JAN-DEC        , - * / 
周几                  1-7 or SUN-SAT         , - * ? / L C # 
年(可选字段)     empty                         1970-2099 , - * /
为了获取更加详细的语法解释,请读者朋友可以在这个链接的文章学习http://blog.csdn.net/eacter/article/details/44308459,这篇文章解释的非常详细;
checkNext函数的源代码:


protected int checkNext(int pos, String s, int val, int type)
    throws ParseException
  {
    int end = -1;
    int i = pos;

	//在之前已经处理了数为一位的情况,这个if内代码处理的是数为两位的情况
    if (i >= s.length()) {
      addToSet(val, end, -1, type);
      return i;
    }

    char c = s.charAt(pos);

	//继续解析数字后面的字符,如果为L的话
    if (c == 'L') {
	//如果是在dayofweek项,则设置最后一个星期属性为true
      if (type == 5) {
        if ((val < 1) || (val > 7))
          throw new ParseException("Day-of-Week values must be between 1 and 7", -1);
        this.lastdayOfWeek = true;
      } else {
        throw new ParseException("'L' option is not valid here. (pos=" + i + ")", i);
      }
	//将数放入dayofweek项的TreeSet数据集合中去
      TreeSet set = getSet(type);
      set.add(new Integer(val));
      i++;
      return i;
    }

	
	//继续解析数字后面的字符,如果为w的话,w只能用在dayofmonth项,则设置靠近设置时间的工作日(nearestWeekday = true)为true
 if (c == 'W') { if (type == 3) this.nearestWeekday = true; else { throw new ParseException("'W' option is not valid here. (pos=" + i + ")", i); } TreeSet set = getSet(type); set.add(new Integer(val)); i++; return i; }
	
	//继续解析数字后面的字符,如果为#的话,#只能用于dayofweek项,后面的数表示一个月的第几个星期
 if (c == '#') { if (type != 5) { throw new ParseException("'#' option is not valid here. (pos=" + i + ")", i); } i++; try {
	//设置第几个星期值
        this.nthdayOfWeek = Integer.parseInt(s.substring(i));
        if ((this.nthdayOfWeek < 1) || (this.nthdayOfWeek > 5))
          throw new Exception();
      }
      catch (Exception e) {
        throw new ParseException("A numeric value between 1 and 5 must follow the '#' option", i);
      }

      TreeSet set = getSet(type);
      set.add(new Integer(val));
      i++;
      return i;
    }
	//-用于两个数之间,表示两个数的范围内,如果第二个数后面没有/的话,递增量默认为1
    if (c == '-') {
      i++;
      c = s.charAt(i);
      int v = Integer.parseInt(String.valueOf(c));
      end = v;
      i++;
      if (i >= s.length()) {
        addToSet(val, end, 1, type);
        return i;
      }
      c = s.charAt(i);
      if ((c >= '0') && (c <= '9')) {
	//获取-右边的数
        ValueSet vs = getValue(v, s, i);
        int v1 = vs.value;
        end = v1;
        i = vs.pos;
      }
	//第二个数后面跟了/的情况
      if ((i < s.length()) && ((c = s.charAt(i)) == '/')) {
        i++;
        c = s.charAt(i);
	//获取递增量,递增量为一位的数情况
        int v2 = Integer.parseInt(String.valueOf(c));
        i++;
        if (i >= s.length()) {
          addToSet(val, end, v2, type);
          return i;
        }
        c = s.charAt(i);
        if ((c >= '0') && (c <= '9')) {
	//获取递增量,递增量为两位的数情况
 ValueSet vs = getValue(v2, s, i); int v3 = vs.value; addToSet(val, end, v3, type); i = vs.pos; return i; }
//当数为1位数时,但是后面字符为空的情况
 addToSet(val, end, v2, type); return i; }//将默认递增量为1插入TreeSet中 addToSet(val, end, 1, type); return i; }//数字之后字符为/,并获取递增量 if (c == '/') { i++; c = s.charAt(i); int v2 = Integer.parseInt(String.valueOf(c)); i++;
	
      if (i >= s.length()) {
        addToSet(val, end, v2, type);
        return i;
      }
      c = s.charAt(i);
      if ((c >= '0') && (c <= '9')) {
        ValueSet vs = getValue(v2, s, i);
        int v3 = vs.value;
        addToSet(val, end, v3, type);
        i = vs.pos;
        return i;
      }
      throw new ParseException("Unexpected character '" + c + "' after '/'", i);
    }
	//当数为1位数时,但是后面字符为空的情况
    addToSet(val, end, 0, type);
    i++;
    return i;
  }
这些都语法解析的关键代码,至于addToSet函数,它的功能是将解析后的结果放到各项TreeSet数据集合中去。addToSet函数源码如下
protected void addToSet(int val, int end, int incr, int type)
    throws ParseException
  {
	//根据type值获取TreeSet数据集合
    TreeSet set = getSet(type);

	//根据type值的不同分别判断val的值是否在各项的值范围内
	//当时间项是秒和分项的时候,最小值为0 ,最大值为59
    if ((type == 0) || (type == 1)) {
      if (((val < 0) || (val > 59) || (end > 59)) && (val != 99)) {
        throw new ParseException("Minute and Second values must be between 0 and 59", -1);
      }

    }
	//如果时间项为时,最小值为0,最大值为23
   else if (type == 2) {
      if (((val < 0) || (val > 23) || (end > 23)) && (val != 99)) {
        throw new ParseException("Hour values must be between 0 and 23", -1);
      }
    }
	//时间项为dayofmonth,最小值为1,最大为31
    else if (type == 3) {
      if (((val < 1) || (val > 31) || (end > 31)) && (val != 99) && (val != 98))
      {
        throw new ParseException("Day of month values must be between 1 and 31", -1);
      }
    }
	//时间项为月份时,最小值为1,最大值为12
    else if (type == 4) {
      if (((val < 1) || (val > 12) || (end > 12)) && (val != 99)) {
        throw new ParseException("Month values must be between 1 and 12", -1);
      }
    }
	//dayofweek项,范围是1-7
    else if ((type == 5) && 
      ((val == 0) || (val > 7) || (end > 7)) && (val != 99) && (val != 98))
    {
      throw new ParseException("Day-of-Week values must be between 1 and 7", -1);
    }

    if (((incr == 0) || (incr == -1)) && (val != 99)) {
      if (val != -1)
        set.add(new Integer(val));
      else {
        set.add(NO_SPEC);
      }

      return;
    }

    int startAt = val;
    int stopAt = end;

	//如果所有项没有设置最终值,则将最终值都默认设置为最大值,最小值如果没有设置,则将都默认设置为最小值
	//且在“*”的情况下,如果增量没有设置的话,递增量默认设置为1
    if ((val == 99) && (incr <= 0)) {
      incr = 1;
      set.add(ALL_SPEC);
    }

    if ((type == 0) || (type == 1)) {
      if (stopAt == -1) {
        stopAt = 59;
      }
      if ((startAt == -1) || (startAt == 99))
        startAt = 0;
    }
    else if (type == 2) {
      if (stopAt == -1) {
        stopAt = 23;
      }
      if ((startAt == -1) || (startAt == 99))
        startAt = 0;
    }
    else if (type == 3) {
      if (stopAt == -1) {
        stopAt = 31;
      }
      if ((startAt == -1) || (startAt == 99))
        startAt = 1;
    }
    else if (type == 4) {
      if (stopAt == -1) {
        stopAt = 12;
      }
      if ((startAt == -1) || (startAt == 99))
        startAt = 1;
    }
    else if (type == 5) {
      if (stopAt == -1) {
        stopAt = 7;
      }
      if ((startAt == -1) || (startAt == 99))
        startAt = 1;
    }
    else if (type == 6) {
      if (stopAt == -1) {
        stopAt = 2299;
      }
      if ((startAt == -1) || (startAt == 99)) {
        startAt = 1970;
      }

    }

    int max = -1;
    if (stopAt < startAt) {
      switch (type) { case 0:
        max = 60; break;
      case 1:
        max = 60; break;
      case 2:
        max = 24; break;
      case 4:
        max = 12; break;
      case 5:
        max = 7; break;
      case 3:
        max = 31; break;
      case 6:
        throw new IllegalArgumentException("Start year must be less than stop year");
      default:
        throw new IllegalArgumentException("Unexpected type encountered");
      }
      stopAt += max;
    }

    for (int i = startAt; i <= stopAt; i += incr)
      if (max == -1)
      {
        set.add(new Integer(i));
      }
      else {
        int i2 = i % max;

	//此处代码type只有4,5,3满足条件,因为max的值,在这三种情况下都能取的得到,其他type下是无法取到的。
        if ((i2 == 0) && ((type == 4) || (type == 5) || (type == 3))) {
          i2 = max;
        }

        set.add(new Integer(i2));
      }
  }

  这个函数根据传进来的范围值和递增量以及type值,将各个时间项 的所有值都放到TreeSet集合找那个去,当任务调度器实时地将时间与这些TreeSet集合内的时间信息做对比,
如果时间对上后,就会触发跑批任务。
	总结:CronTrigger类是时间点跑批任务设置的类,本问终点分析的是哪一个类对时间进行解析,即CronTrigger类继承的类Trigger中的属性CronExpression类。时间的语法
解析都是在这个类中完成,得到的结果是7个TreeSet数据集合属性,分别存放的是seconds ,minutes,hours,dayOfMonth,months,dayOfWeek,years等属性中,这些集合存放的数据
都是整数数据,即跑批任务触发时间点的各项(年月日时分秒)数据,scheduler对象在每秒都会比对当前时间和存放的触发时间信息,如果吻合就触发跑批任务对象。

                      talk is cheap  ,show you the code and the doc,更多的分享内容请关注我的工作号:大白共图社。公众号会有很多的github开源社区拿来即用项目源码以及相关的文章。欢迎关注。

                                                                       spring Quartz 源码分析--触发器类CronTriggerBean源码剖析

今天的文章spring Quartz 源码分析–触发器类CronTriggerBean源码剖析分享到此就结束了,感谢您的阅读,如果确实帮到您,您可以动动手指转发给其他人。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/29367.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注