前面我们讲到了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对象在每秒都会比对当前时间和存放的触发时间信息，如果吻合就触发跑批任务对象。
