如何监控java quartz定时器中的所有定时任务_百度知道
如何监控java quartz定时器中的所有定时任务
提问者采纳
&testQuarzt&test、首先实现一个用于被执行的类;
&lt.beanid=&quot.springframework.MethodInvokingJobDetailFactoryBean&triggers& /
& &lt.scheduling。下面看一个典型的Quartz定时器的实现;&gt?&doSomething&;
&value&property name=&quot、spring配置文件，这个类用于被定时器调度;targetObject&&gt!-- 将定时触发器注入任务工程 --&& value=&
&lt./&property name=&class=&quot..SchedulerFactoryBean& &#47，代码如下;&beanid=& value=&quot： 1;property name=&class=&quot众所周知spring 的Quartz定时器的功能非常强大;testTrigger&jobDetail&property name=&testQuartzJob& ref=&&#47，具体配置 & &lt!-- 被执行类 --&0 0 6 * * ;&gt.cronExpression&quot.org.bean& &targetMethod&quot，就像windows中得计划任务一样;
&lt!-- 将job注入到定时触发器 --& / ref=&&testQuarzt&quot，可以在特定的年月日小时分秒的时间点触发时间; &beanid=& &lt.CronTriggerBean&property name=&
&testQuartzJob& &
&value&gt.scheduling!-- 将testQuarzt注入到job中 --& /;concurrent&false&
&class=&;beanclass=&list&gt，完成事件的调度;property name=&&property&gt，这个类不需要继承任何类或者接口;TODO
publicTestQuartz{
public void doSomething(){
&#47.testQuarzt&quot
来自团队：
其他类似问题
为您推荐：
quartz的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁如何监控java quartz定时器中的所有定时任务_百度知道
如何监控java quartz定时器中的所有定时任务
提问者采纳
&#47.getTriggerName();&#47.Scheduler&#47:-1表示不存在;暂停scheduler.getTriggerGroup()),0表示正在运行.scheduleJob&#47.getTriggerState(trigger,1表示暂停中int triggerState = scheduler.pauseTrigger&#47,&#47你好:
监控用/TriggerS/移除scheduler.启动scheduler
其他类似问题
为您推荐：
quartz的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁通过spring实现对所有定时任务进行AOP拦截，和实现每个定时任务执行的时间从数据库动态获得
通过spring实现对所有定时任务进行AOP拦截，和实现每个定时任务执行的时间从数据库动态获得，这样可以保证不需要重启容器就可以修改某个定时任务的执行时间
1.spring.xml配置AOP切面
&bean id="methodTimeAdvice"
class="cn.abc.mon.taskManager.MethodTimeAdvice"&
&&&&&/bean&
&!-- 每个定时任务AOP拦截获得执行时间 --&
&aop:config
proxy-target-class="true"&
&&&&&&&&&!--Spring
2.0 可以用 AspectJ 的语法定义 Pointcut，这里拦截 指定
包中的所有方法&--&&&&&
&&&&&&&&aop:advisor
id="methodTimeLog" advice-ref="methodTimeAdvice"
pointcut="execution(*
&&&&cn.abc.timertask.biz.*.*.*Task.work(..))
execution(*
cn.abc.timertask.biz.*.*.*Servlet.work(..))"/&
&/aop:config&
以下配置了两个bean，即两个定时任务
&!-- 配置一个bean
&bean id="huPaymentTask"
class="cn.abc.timertask.biz.fight.huPayment.HuPaymentTask"&
&!-- 定义调用对象和调用对象的方法 --&
id="huPaymentTask_schedulerJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&!-- 调用的类 --&
&property name="targetObject"
ref="huPaymentTask" /&
&!-- 调用类中的方法 --&
&property name="targetMethod" value="work"
&!-- 定义触发时间 --&
&bean id="huPaymentTask_cronTrigger"
class="cn.abc.mon.taskManager.InitializingCronTrigger"&
&property name="taskid"
value="huPaymentTask"&&/property&
&property name="jobDetail"
ref="huPaymentTask_schedulerJobDetail" /&
&property name="scheduleInfoManager"
ref="scheduleInfoManager" /&
配置另一个bean &--&
&bean id="weatherTask"
class="cn.abc.timertask.biz.fight.weather.WeatherTask"&
&/bean& &!--
定义调用对象和调用对象的方法 --&&
&bean id="weatherTask_schedulerJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&&
&&!-- 调用的类
&&property
name="targetObject" ref="weatherTask" /&
&&!-- 调用类中的方法
&&property
name="targetMethod" value="work" /&
&&!-- 定义触发时间
&bean id="weatherTask_cronTrigger"
class="cn.abc.mon.taskManager.InitializingCronTrigger"&
&&property
name="taskid"
value="weatherTask"&&/property&&
&&property
name="jobDetail" ref="weatherTask_schedulerJobDetail"
&&property
name="scheduleInfoManager" ref="scheduleInfoManager"
&!-- 从数据库获得并动态更新所有定时任务的时间
&bean id="schedulerFactoryTask"
class="cn.abc.mon.taskManager.SchedulerFactoryTask"&
&property name="schedulerFactory"
ref="schedulerFactory"/&
&property name="scheduleInfoManager"
ref="scheduleInfoManager"/&
&!-- 定义调用对象和调用对象的方法 --&
id="schedulerFactoryTask_schedulerJobDetail"
class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&
&!-- 调用的类 --&
&property name="targetObject"
ref="schedulerFactoryTask" /&
&!-- 调用类中的方法 --&
&property name="targetMethod" value="work"
&!-- 定义触发时间 --&
id="schedulerFactoryTask_cronTrigger"
class="cn.abc.mon.taskManager.InitializingCronTrigger"&
&property name="taskid"
value="schedulerFactoryTask"&&/property&
&property name="jobDetail"
ref="schedulerFactoryTask_schedulerJobDetail"
&property name="scheduleInfoManager"
ref="scheduleInfoManager" /&
&!-- 数据库操作类 --&
&bean id="scheduleInfoManager"
class="cn.abc.mon.taskManager.ScheduleInfoManager"/&
&!-- 总管理类 如果将lazy-init='false'那么容器启动就会执行调度程序
&bean id="schedulerFactory" lazy-init="false"
class="org.springframework.scheduling.quartz.SchedulerFactoryBean"&
&property name="triggers"&
&ref local="huPaymentTask_cronTrigger"
&ref local="weatherTask_cronTrigger"
&/property&
2.HuPaymentTask.java
一个定时任务类,WeatherTask.java与这个类似，就不写了
cn.abc.timertask.biz.fight.huP
public class HuPaymentTask {
public void work() {
System.out.println("这里写这个定时任务需要执行的操作代码");
3.MethodTimeAdvice.java
切面类，其中加入了将拦截的内容加入到数据库的代码，如果不需要可以相应删掉
package cn.abc.mon.taskM
import java.text.SimpleDateF
import java.util.D
import org.aopalliance.intercept.MethodI
import org.aopalliance.intercept.MethodI
import mons.lang.StringU
import mons.lang.time.StopW
import mons.logging.L
import mons.logging.LogF
import org.springframework.aop.ThrowsA
cn.abc.mon.taskManager.po.TaskD
public class MethodTimeAdvice implements MethodInterceptor
protected final Log log =
LogFactory.getLog(MethodTimeAdvice.class);
public Object invoke(MethodInvocation invocation) {
Object[] object = invocation.getArguments();
ScheduleInfoManager scheduleInfoManager = new
ScheduleInfoManager();//这个类封装了对数据库的增删改查操作
TaskDetail taskDetail = new TaskDetail();//这是一个实体
// 用 commons-lang 提供的 StopWatch 计时，Spring 也提供了一个
StopWatch clock = new StopWatch();
clock.start(); // 计时开始
String beforeTime = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss:SSS").format(new Date());
System.out.println("启动时间："+ beforeTime);
taskDetail.setTask_detail_startdate(beforeTime);
Object result =
result = invocation.proceed();
System.out.println(result);
taskDetail.setTask_detail_isexception("0");
} catch (Exception e) {
// TODO: handle exception
System.out.println("捕获的异常："+e.getMessage());
String exceptionTime = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss:SSS").format(new Date());
taskDetail.setTask_detail_isexception("1");
taskDetail.setTask_detail_exceptiondesc(e.getMessage());
taskDetail.setTask_detail_executedate(exceptionTime);
clock.stop(); // 切面结束
String endTime = new SimpleDateFormat("yyyy-MM-dd
HH:mm:ss:SSS").format(new Date());
System.out.println("结束时间："+ endTime);
taskDetail.setTask_detail_enddate(endTime);
// 方法参数类型，转换成简单类型
Class[] params =
invocation.getMethod().getParameterTypes();
String[] simpleParams = new String[params.length];
for (int i = 0; i & params. i++) {
simpleParams[i] = params[i].getSimpleName();
System.out.println("结束时间：" + clock.getTime() + " ms");
taskDetail.setTask_detail_executedate(clock.getTime() + "
System.out.println("每次执行时间:" + clock.getTime() + " ms");
System.out.println("操作类（包名+类名+方法名+（参数））： ["
+ invocation.getThis().getClass().getName() + "."
+ invocation.getMethod().getName() + "("
+ StringUtils.join(simpleParams, ",") + ")] ");
System.out.println(result);
//这里将拦截的数据插入的数据库
scheduleInfoManager.insertTaskDetail(taskDetail);
4.InitializingCronTrigger.java//每个定时器调用的初始化时间类
package cn.abc.mon.taskM
import java.io.S
import java.text.ParseE
org.springframework.scheduling.quartz.CronTriggerB
org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryB
public class InitializingCronTrigger extends CronTriggerBean
implements Serializable {
private ScheduleInfoManager scheduleInfoM
public void setTaskid(String taskid) {
this.taskid =
public ScheduleInfoManager getScheduleInfoManager() {
return scheduleInfoM
public String getTaskid() {
// 设值注入，通过setter方法传入被调用者的实例scheduleInfoManager
& & public void
setScheduleInfoManager(ScheduleInfoManager
scheduleInfoManager){
System.out.println("----------------初始化"+taskid+"定时任务时间-----------------");
& this.scheduleInfoManager =
scheduleInfoM
& String cronExpression = "0 0 0 */1 *
?";//所有定时任务的执行时间都初始化为一天执行一次
setCronexpression_r(cronExpression);
if(taskid.equals("schedulerFactoryTask")){//如果调用的是总定时器
setCronexpression_r("0/10 * * * *
?");//设置总定时器每个10分钟更新一次所有的定时器的时间
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
&// ②
5.SchedulerFactoryTask.java
为所有定时器更新相应的执行时间
package cn.abc.mon.taskM
import java.sql.C
import java.sql.ResultS
import java.sql.SQLE
import java.sql.S
import java.text.ParseE
import java.util.ArrayL
import java.util.L
import org.quartz.S
import org.quartz.SchedulerE
import org.springframework.context.ApplicationC
org.springframework.context.support.ClassPathXmlApplicationC
org.springframework.scheduling.quartz.CronTriggerB
public class SchedulerFactoryTask {
private Scheduler schedulerF &
private ScheduleInfoManager scheduleInfoM
// 设值注入，通过setter方法传入被调用者的实例scheduler
public void setSchedulerFactory(Scheduler schedulerFactory)
this.schedulerFactory = schedulerF
public ScheduleInfoManager getScheduleInfoManager() {
return scheduleInfoM
public void setScheduleInfoManager(ScheduleInfoManager
scheduleInfoManager) {
this.scheduleInfoManager = scheduleInfoM
public void work(){
ApplicationContext context = new
ClassPathXmlApplicationContext("spring-triggers.xml");//spring-triggers.xml如下，其中是一个所有定时器名字的集合
List quartzList =
(ArrayList)context.getBean("quartzList");
for(int i = 0;i
CronTriggerBean trigger = (CronTriggerBean)
schedulerFactory.getTrigger(quartzList.get(i),
Scheduler.DEFAULT_GROUP); &
String dbCronExpression = "" ; &
dbCronExpression =
scheduleInfoManager.getCronExpressionFromDB(quartzList.get(i).split("_")[0]);
//System.out.println(trigger+"+++++");
String originConExpression =
trigger.getCronexpression_r();&
//System.out.println(trigger+"===="+originConExpression);
判断从DB中取得的任务时间(dbCronExpression)和现在的quartz线程中的任务时间(originConExpression)是否相等
// 如果相等，则表示用户并没有重新设定数据库中的任务时间，这种情况不需要重新rescheduleJob
if(!originConExpression.equalsIgnoreCase(dbCronExpression)){
trigger.setCronexpression_r(dbCronExpression);
schedulerFactory.rescheduleJob(quartzList.get(i),
Scheduler.DEFAULT_GROUP, trigger); &
} catch (SchedulerException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ParseException e) {
// TODO: handle exception
e.printStackTrace();
6.spring-triggers.xml
这是一个所有定时任务名字的LIST，当然你也可以从数据库获得或其他方式定义
&?xml version="1.0"
encoding="UTF-8"?&
xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans&
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd"&
&!-- 所有定时任务的id名字集合List --&
&bean id="quartzList"
class="java.util.ArrayList"&
&constructor-arg&
&value&huPaymentTask_cronTrigger&/value&
&value&weatherTask_cronTrigger&/value&
&/constructor-arg&
已投稿到：
以上网友发言只代表其个人观点，不代表新浪网的观点或立场。&&&&spring java 定时器 执行两次 quartz
&spring java 定时器 执行两次 quartz
spring定时器代码。解决多次执行问题。包含quartz-all.jar包。
说明很详细。希望能帮上哪位朋友。
若举报审核通过，可奖励20下载分
被举报人：
举报的资源分：
请选择类型
资源无法下载
资源无法使用
标题与实际内容不符
含有危害国家安全内容
含有反动色情等内容
含广告内容
版权问题，侵犯个人或公司的版权
*详细原因：
VIP下载&&免积分60元/年（1200次）
您可能还需要
Q.为什么我点的下载下不了，但积分却被扣了
A. 由于下载人数众多，下载服务器做了并发的限制。若发现下载不了，请稍后再试，多次下载是不会重复扣分的。
Q.我的积分不多了，如何获取积分？
A. 获得积分，详细见。
完成任务获取积分。
论坛可用分兑换下载积分。
第一次绑定手机，将获得5个C币，C币可。
关注并绑定CSDNID，送10个下载分
下载资源意味着您已经同意遵守以下协议
资源的所有权益归上传用户所有
未经权益所有人同意，不得将资源中的内容挪作商业或盈利用途
CSDN下载频道仅提供交流平台，并不能对任何下载资源负责
下载资源中如有侵权或不适当内容，
本站不保证本站提供的资源的准确性，安全性和完整性，同时也不承担用户因使用这些下载资源对自己和他人造成任何形式的伤害或损失。
开发技术下载排行
您当前C币：0&&&可兑换 0 下载积分
兑换下载分:&
消耗C币:0&
立即兑换&&
兑换成功你当前的下载分为 。前去下载资源
你下载资源过于频繁，请输入验证码
如何快速获得积分？
你已经下载过该资源，再次下载不需要扣除积分
spring java 定时器 执行两次 quartz
所需积分：3
剩余积分：0
扫描微信二维码精彩活动、课程更新抢先知
VIP会员，免积分下载
会员到期时间：日
剩余下载次数：1000
spring java 定时器 执行两次 quartz
剩余次数：&&&&有效期截止到：
你还不是VIP会员VIP会员享免积分 . 专属通道极速下载
VIP下载次数已满VIP会员享免积分 . 专属通道极速下载，请继续开通VIP会员
你的VIP会员已过期VIP会员享免积分 . 专属通道极速下载，请继续开通VIP会员在做项目时有时候会有定时器任务的功能，比如某某时间应该做什么，多少秒应该怎么样之类的。
spring支持多种定时任务的实现。我们来介绍下使用spring的定时器和使用quartz定时器
　　1.我们使用spring-boot作为基础框架，其理念为零配置文件，所有的配置都是基于注解和暴露bean的方式。
　　2.使用spring的定时器:
　　　　spring自带支持定时器的任务实现。其可通过简单配置来使用到简单的定时任务。
@Component
@Configurable
@EnableScheduling
public class ScheduledTasks{
@Scheduled(fixedRate = 1000 * 30)
public void reportCurrentTime(){
System.out.println (&Scheduling Tasks Examples: The time is now & + dateFormat ().format (new Date ()));
//每1分钟执行一次
@Scheduled(cron = &0 */1 *
public void reportCurrentByCron(){
System.out.println (&Scheduling Tasks Examples By Cron: The time is now & + dateFormat ().format (new Date ()));
private SimpleDateFormat dateFormat(){
return new SimpleDateFormat (&HH:mm:ss&);
&&&&&&&&& 没了，没错，使用spring的定时任务就这么简单，其中有几个比较重要的注解：
　　　@EnableScheduling：标注启动定时任务。
&&&&&&&&& @Scheduled(fixedRate = 1000 * 30)& 定义某个定时任务。
　　3.使用quartz实现定时任务。　　　　Quartz设计者做了一个设计选择来从调度分离开作业。Quartz中的触发器用来告诉调度程序作业什么时候触发。框架提供了一把触发器类型，但两个最常用的是SimpleTrigger和CronTrigger。SimpleTrigger为需要简单打火调度而设计。典型地，如果你需要在给定的时间和重复次数或者两次打火之间等待的秒数打火一个作业，那么SimpleTrigger适合你。另一方面，如果你有许多复杂的作业调度，那么或许需要CronTrigger。　　　　CronTrigger是基于Calendar-like调度的。当你需要在除星期六和星期天外的每天上午10点半执行作业时，那么应该使用CronTrigger。正如它的名字所暗示的那样，CronTrigger是基于Unix克隆表达式的。
　　　　使用quartz说使用的maven依赖。
&dependency&
&groupId&org.quartz-scheduler&/groupId&
&artifactId&quartz&/artifactId&
&version&1.8.4&/version&
&/dependency&
　　　　由于我们使用的是spring-boot框架，其目的是做到零配置文件，所以我们不使用xml文件的配置文件来定义一个定时器，而是使用向spring容器暴露bean的方式。
　　　　向spring容器暴露所必须的bean
@Configuration
public class SchedledConfiguration {
// 配置中设定了
// ① targetMethod: 指定需要定时执行scheduleInfoAction中的simpleJobTest()方法
// ② concurrent：对于相同的JobDetail，当指定多个Trigger时, 很可能第一个job完成之前，
// 第二个job就开始了。指定concurrent设为false，多个job不会并发运行，第二个job将不会在第一个job完成之前开始。
// ③ cronExpression：0/10 * * * * ?表示每10秒执行一次，具体可参考附表。
// ④ triggers：通过再添加其他的ref元素可在list中放置多个触发器。 scheduleInfoAction中的simpleJobTest()方法
@Bean(name = &detailFactoryBean&)
public MethodInvokingJobDetailFactoryBean detailFactoryBean(ScheduledTasks scheduledTasks){
MethodInvokingJobDetailFactoryBean bean = new MethodInvokingJobDetailFactoryBean ();
bean.setTargetObject (scheduledTasks);
bean.setTargetMethod (&reportCurrentByCron&);
bean.setConcurrent (false);
@Bean(name = &cronTriggerBean&)
public CronTriggerBean cronTriggerBean(MethodInvokingJobDetailFactoryBean detailFactoryBean){
CronTriggerBean tigger = new CronTriggerBean ();
tigger.setJobDetail (detailFactoryBean.getObject ());
tigger.setCronExpression (&0/5 * * * * ? &);//每5秒执行一次
} catch (ParseException e) {
e.printStackTrace ();
public SchedulerFactoryBean schedulerFactory(CronTriggerBean[] cronTriggerBean){
SchedulerFactoryBean bean = new SchedulerFactoryBean ();
System.err.println (cronTriggerBean[0]);
bean.setTriggers (cronTriggerBean);
　　　　MethodInvokingJobDetailFactoryBean：此工厂主要用来制作一个jobDetail，即制作一个任务。由于我们所做的定时任务根本上讲其实就是执行一个方法。所以用这个工厂比较方便。
　　　　　　注意：其setTargetObject所设置的是一个对象而不是一个类。
　　　　CronTriggerBean：定义一个触发器。
　　　　　　注意：setCronExpression：是一个表达式，如果此表达式不合规范，即会抛出异常。
　　　　SchedulerFactoryBean：主要的管理的工厂，这是最主要的一个bean。quartz通过这个工厂来进行对各触发器的管理。
　　4.对quartz的封装
　　　　由上面代码可以看出来，此处我们设置的是一个固定的cronExpression，那么，做为项目中使用的话，我们一般是需要其动态设置比如从数据库中取出来。
　　　　其实做法也很简单，我们只需要定义一个Trigger来继承CronTriggerBean。顶用其setCronExpression方法即可。
　　　　那么另外一个问题，如果我们要定义两个定时任务则会比较麻烦，需要先注入一个任务工厂，在注入一个触发器。
　　　 && 为了减少这样的配置，我们定义了一个抽象的超类来继承CronTriggerBean。
　　　　具体代码如下：
public abstract class BaseCronTrigger extends CronTriggerBean implements Serializable {
private static final long serialVersionUID = 1L;
public void init(){
// 得到任务
JobDetail jobdetail = new JobDetail (this.getClass ().getSimpleName (),this.getMyTargetObject ().getClass ());
this.setJobDetail (jobdetail);
this.setJobName (jobdetail.getName ());
this.setName (this.getClass ().getSimpleName ());
this.setCronExpression (this.getMyCronExpression ());
} catch (java.text.ParseException e) {
e.printStackTrace ();
public abstract String getMyCronExpression();
public abstract Job getMyTargetObject();
　　　　其init()方法，来为这个触发器绑定任务。其任务为一个Job类型的，也就是说其执行的任务为实现了Job接口的类，这个任务会有一个execute()方法，来执行任务题。
public class ScheduledTasks implements Job {
public void execute(JobExecutionContext context) throws JobExecutionException{
System.out.println (&Scheduling Tasks Examples By Cron: The time is now & + dateFormat ().format (new Date ()));
private SimpleDateFormat dateFormat(){
return new SimpleDateFormat (&HH:mm:ss&);
　　　　为了给触发器添加任务，我们需要在子类中调用init()方法，由于spring容器注入时是使用的空参的构造函数，所以我们在此构造函数中调用init（）方法。
@Component
public class InitializingCronTrigger extends BaseCronTrigger implements Serializable {
private static final long
serialVersionUID = 1L;
@Autowired
private SchedulerFactoryBean schedulerFactoryB
public InitializingCronTrigger() {
public String getMyCronExpression(){
return &0/5 * * * * ?&;
public Job getMyTargetObject(){
return new ScheduledTasks ();
public void parse(){
schedulerFactoryBean.getObject ().pauseAll ();
} catch (SchedulerException e) {
e.printStackTrace ();
　　　　此时我们只需要在配置类中加入一个配置就可以了。
public SchedulerFactoryBean schedulerFactory(CronTriggerBean[] cronTriggerBean){
SchedulerFactoryBean bean = new SchedulerFactoryBean ();
System.err.println (cronTriggerBean[0]);
bean.setTriggers (cronTriggerBean);
　　4.介绍一个cronExpression表达式。
　　　　这一部分是摘抄的：
　　　　　　
字段 & 允许值 & 允许的特殊字符
, - * & / L W C
1-12&或者 JAN-DEC
1-7&或者 SUN-SAT
, - * & / L C #
年（可选）
　&如上面的表达式所示:&“*”字符被用来指定所有的值。如：”*“在分钟的字段域里表示“每分钟”。&“-”字符被用来指定一个范围。如：“10-12”在小时域意味着“10点、11点、12点”。&“,”字符被用来指定另外的值。如：“MON,WED,FRI”在星期域里表示”星期一、星期三、星期五”.&“?”字符只在日期域和星期域中使用。它被用来指定“非明确的值”。当你需要通过在这两个域中的一个来指定一些东西的时候，它是有用的。看下面的例子你就会明白。&“L”字符指定在月或者星期中的某天（最后一天）。即“Last ”的缩写。但是在星期和月中“Ｌ”表示不同的意思，如：在月子段中“L”指月份的最后一天-1月31日，2月28日，如果在星期字段中则简单的表示为“7”或者“SAT”。如果在星期字段中在某个value值得后面，则表示“某月的最后一个星期value”,如“6L”表示某月的最后一个星期五。“W”字符只能用在月份字段中，该字段指定了离指定日期最近的那个星期日。“#”字符只能用在星期字段，该字段指定了第几个星期value在某月中
每一个元素都可以显式地规定一个值（如6），一个区间（如9-12），一个列表（如9，11，13）或一个通配符（如*）。“月份中的日期”和“星期中的日期”这两个元素是互斥的，因此应该通过设置一个问号（？）来表明你不想设置的那个字段。表7.1中显示了一些cron表达式的例子和它们的意义：
&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年的每月的最后一个星期五上午10:15触发
&0 15 10 ? * 6#3&
每月的第三个星期五上午10:15触发
　　　　　　　　　　 &每天早上6点&0 6 * * *&
　　　　　　　　　　 　每两个小时&0 */2 * * *&
　　　　　　　　　　　　晚上11点到早上8点之间每两个小时，早上八点&0 23-7/2，8 * * *&
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& 每个月的4号和每个礼拜的礼拜一到礼拜三的早上11点&0 11 4 * 1-3&
　　　　　　　　　　　　1月1日早上4点&0 4 1 1 *