quartz定时任务时间设置

合集下载

quartz的cron表达式

quartz的cron表达式Quartz的Cron表达式简介1. 什么是Cron表达式Cron表达式是一种用于定时任务调度的标准格式。

在Quartz框架中，Cron表达式被广泛使用，用于设置任务的执行时间。

2. Cron表达式的语法Cron表达式由6个或7个字段组成，每个字段代表时间的一个维度。

这6个或7个字段分别是：•秒（0~59）•分钟（0~59）•小时（0~23）•日（1~31）•月（1~12）•周几（0~7，0和7都代表周日）可以使用通配符或范围来表示时间的不确定性。

例如，“*“代表所有可能的值，”?“在日和周几字段中代表不指定值，”-“用来表示范围，” / “用来表示递增间隔。

例如，要设置每天早上9点执行任务，Cron表达式可以是0 0 9 ? * *。

3. 常用的Cron表达式示例以下是一些常见的Cron表达式示例：•0 0/5 * * * ?表示每隔5分钟执行一次任务。

•0 0 12 * * ?表示每天中午12点执行任务。

•0 0 8 ? * MON-FRI表示周一到周五每天早上8点执行任务。

•0 0 8 ? * 6L表示每个月的最后一个周五早上8点执行任务。

4. Cron表达式的高级用法Cron表达式还支持一些高级功能，例如使用”#“指定月份中的第几个周几，使用”L”指定月份中的最后一天，使用”W”指定平日最近的工作日等等。

以下是一些高级用法的示例：•0 0 12 ? JAN,FEB,DEC *表示一月、二月和十二月每天中午12点执行任务。

•0 0/30 9-17 * * MON-FRI#2表示周一到周五上午9点到下午5点之间，每隔30分钟执行一次任务，并且每个月的第二个周一符合条件。

5. 总结Cron表达式是Quartz框架中用于指定任务执行时间的标准格式。

它非常灵活，并且支持多种时间维度的设置。

掌握Cron表达式的语法和常用示例，可以帮助我们轻松实现定时任务的调度。

6. Cron表达式的注意事项在使用Cron表达式时，需要注意以下几点：•时间表达式字段之间使用空格分隔。

定时任务时间格式设置

org.springframework.scheduling.quartz.CronTriggerBean允许你更精确地控制任务的运行时间，只需要设置其cronExpression属性。

一个cronExpression表达式有至少6个（也可能是7个）由空格分隔的时间元素。

从左至右，这些元素的定义如下：1．秒（0–59）2．分钟（0–59）3．小时（0–23）4．月份中的日期（1–31）5．月份（1–12或JAN–DEC）6．星期中的日期（1–7或SUN–SAT）7．年份（1970–2099）0 0 10,14,16 * * ? 每天上午10点,下午2点和下午4点0 0,15,30,45 * 1-10 * ? 每月前10天每隔15分钟30 0 0 1 1 ? 2012 在2012年1月1日午夜过30秒时0 0 8-5 ? * MON-FRI 每个工作日的工作时间各个时间可用值如下：秒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 , – * /可用值详细分析如下：―*‖——字符可以用于所有字段，在―分‖字段中设为‖*‖表示‖每一分钟‖的含义。

―?‖——字符可以用在―日‖和―周几‖字段. 它用来指定‗不明确的值‘. 这在你需要指定这两个字段中的某一个值而不是另外一个的时候会被用到。

在后面的例子中可以看到其含义。

―-‖——字符被用来指定一个值的范围，比如在―小时‖字段中设为‖10-12″表示‖10点到12点‖。

―,‖——字符指定数个值。

比如在―周几‖字段中设为‖MON,WED,FRI‖表示‖the days Monday, Wednesday, and Friday‖。

―/‖——字符用来指定一个值的的增加幅度. 比如在―秒‖字段中设置为‖0/15″表示‖第0, 15, 30, 和45秒‖。

quartz java 参数解释

文章主题：深度解析quartz java参数一、前言在quartz java编程中，参数扮演着非常重要的角色。

掌握quartz java参数的含义和用法，对于实现定时任务和调度任务至关重要。

本文将对quartz java参数进行深度解析，帮助读者更好地理解和运用这些参数。

二、quartz java参数概述1. JobDetail参数JobDetail是quartz中用来描述作业实例的类。

它包含了执行任务所需的所有信息，其中包括：- jobClass：指定实际执行的job类。

- jobDataMap：存储作业所需的参数或数据。

2. Trigger参数Trigger是quartz中用来触发作业执行的类。

在定义Trigger时，需要设置以下参数：- startTime：指定任务启动的时间。

- endTime：指定任务结束的时间。

- cronExpression：使用cron表达式来定义作业执行的时间规则。

3. Scheduler参数Scheduler是quartz中用来管理Trigger和JobDetail，执行作业的类。

在创建Scheduler时，可以设置一些重要的参数：- 是否立即启动任务。

- 是否以集群方式运行。

三、深入解析各参数的含义和用法1. JobDetail参数的含义和用法JobDetail中的jobClass参数用于指定实际执行的job类，可以是实现了Job接口的任何类。

jobDataMap参数用于存储作业所需的参数或数据，可以通过它向作业类传递参数。

2. Trigger参数的含义和用法在定义Trigger时，startTime参数用于指定任务启动的时间，可以是立即启动或者指定一个未来时间；endTime参数用于指定任务结束的时间，可以是永久执行或者指定一个截止时间；cronExpression参数用于定义作业执行的时间规则，可以通过它精确地控制作业的执行时间。

3. Scheduler参数的含义和用法Scheduler中的参数设置非常重要，通过设置是否立即启动任务和是否以集群方式运行，可以灵活地控制任务的执行方式。

SpringBoot中使用Quartz管理定时任务的方法

SpringBoot中使⽤Quartz管理定时任务的⽅法定时任务在系统中⽤到的地⽅很多，例如每晚凌晨的数据备份，每⼩时获取第三⽅平台的 Token 信息等等，之前我们都是在项⽬中规定这个定时任务什么时候启动，到时间了便会⾃⼰启动，那么我们想要停⽌这个定时任务的时候，就需要去改动代码，还得启停服务器，这是⾮常不友好的事情直⾄遇见 Quartz，利⽤图形界⾯可视化管理定时任务，使得我们对定时任务的管理更加⽅便，快捷⼀、Quartz 简介Quartz是⼀个开源的作业调度框架，它完全由Java写成，并设计⽤于J2SE和J2EE应⽤中。

它提供了巨⼤的灵活性⽽不牺牲简单性。

你能够⽤它来为执⾏⼀个作业⽽创建简单的或复杂的调度。

它有很多特征，如：数据库⽀持，集群，插件，EJB作业预构建，JavaMail及其它，⽀持cron-like表达式等等。

⼆、开发前戏1、引⼊ maven 依赖<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-quartz</artifactId></dependency>这⾥引⼊了 web 的依赖，以及 Quartz 的依赖，其余依赖请根据需求⾃⾏引⼊2、创建数据表数据模型：SQL语句：drop table if exists sys_quartz;/*==============================================================*//* Table: sys_quartz *//*==============================================================*/create table sys_quartz(id bigint(20) not null auto_increment comment '主键id',class_name varchar(32) comment '任务类名',cron_expression varchar(32) comment 'cron表达式',param varchar(32) comment '参数',descript varchar(11) comment '描述',quartz_status varchar(255) comment '启动状态(0--启动1--停⽌)',create_time datetime comment '创建时间',create_user bigint(20) comment '创建⼈',status tinyint(1) default 0 comment '状态（0--正常1--停⽤）',del_flag tinyint(1) default 0 comment '删除状态（0，正常，1已删除）',primary key (id))type = InnoDB;alter table sys_quartz comment '定时任务信息表';三、开发进⾏中1、创建实体类import com.baomidou.mybatisplus.annotation.*;import com.baomidou.mybatisplus.extension.activerecord.Model;import mon.annotation.Dict;import io.swagger.annotations.ApiModel;import io.swagger.annotations.ApiModelProperty;import lombok.Data;import lombok.EqualsAndHashCode;import lombok.experimental.Accessors;import java.io.Serializable;/*** <p>* 定时任务信息表* </p>** @author lizhou* @since 2020-07-21*/@Data@EqualsAndHashCode(callSuper = false)@Accessors(chain = true)@TableName("sys_quartz")@ApiModel(value="SysQuartz对象", description="定时任务信息表")public class SysQuartz extends Model<SysQuartz> {@ApiModelProperty(value = "主键id")@TableId(value = "id", type = IdType.AUTO)private Long id;@ApiModelProperty(value = "任务类名")@TableField("class_name")private String className;@ApiModelProperty(value = "cron表达式")@TableField("cron_expression")private String cronExpression;@ApiModelProperty(value = "参数")@TableField("param")private String param;@ApiModelProperty(value = "描述")@TableField("descript")private String descript;@ApiModelProperty(value = "启动状态（0--启动1--停⽌）")@TableField("quartz_status")private Integer quartzStatus;@ApiModelProperty(value = "状态（0--正常1--停⽤）")@TableField("status")private Integer status;@ApiModelProperty(value = "删除状态（0--未删除1--已删除）")@TableField("del_flag")@TableLogicprivate Integer delFlag;@ApiModelProperty(value = "创建者")@TableField("create_user")private Long createUser;@ApiModelProperty(value = "创建时间")@TableField("create_time")private String createTime;@Overrideprotected Serializable pkVal() {return this.id;}}2、实现定时任务的 CRUD下⾯我们就要完成定时任务的新增、修改、删除、启停等基本操作了，由于不是很复杂，这⾥的代码就不贴出来了，贴⼏张图吧列表页：新增页：四、定时任务1、定时任务类我们把定时任务都放在 job 包下⾯，⼀个定时任务就是⼀个⽂件，写⼀个测试的类 TestJob.javaimport mon.utils.DateUtils;import lombok.extern.slf4j.Slf4j;import org.quartz.Job;import org.quartz.JobExecutionContext;import org.quartz.JobExecutionException;/*** @ClassName TestJob* 测试定时任务* @Author Lizhou* @Date 2020-07-21 10:58:58**/@Slf4jpublic class TestJob implements Job {@Overridepublic void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {System.out.println("定时任务启动：" + DateUtils.getYmdHms());}}TestJob 这个类实现了 Job 接⼝，实现了 execute ⽅法，这⾥还可以接收参数这个⽂件在 com.zyxx.sbm.job 包下⾯，那么在页⾯新增定时任务的时候，就需要填写任务类名为：com.zyxx.sbm.job.TestJob cron 表达式的知识这⾥就不⼀⼀介绍了2、页⾯添加定时任务那么我们的任务类名就是：com.zyxx.sbm.job.TestJobcron 表达式：*/2 * * * * ?，表⽰两秒钟执⾏⼀次参数：我们没有传⼊参数3、后台添加定时任务package com.zyxx.sbm.service.impl;import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.baomidou.mybatisplus.core.metadata.IPage;import com.baomidou.mybatisplus.extension.plugins.pagination.Page;import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;import mon.shiro.SingletonLoginUtils;import mon.utils.DateUtils;import yTableResult;import mon.utils.ResponseResult;import com.zyxx.sbm.entity.SysQuartz;import com.zyxx.sbm.mapper.SysQuartzMapper;import com.zyxx.sbm.service.SysQuartzService;import lombok.extern.slf4j.Slf4j;import ng3.StringUtils;import org.quartz.*;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Service;import java.util.List;/*** <p>* 定时任务信息表服务实现类* </p>** @author lizhou* @since 2020-07-21*/@Slf4j@Servicepublic class SysQuartzServiceImpl extends ServiceImpl<SysQuartzMapper, SysQuartz> implements SysQuartzService {@Autowiredprivate Scheduler scheduler;/*** 添加定时任务*/@Overridepublic ResponseResult add(SysQuartz sysQuartz) {QueryWrapper<SysQuartz> queryWrapper = new QueryWrapper<>();queryWrapper.eq("class_name", sysQuartz.getClassName());List<SysQuartz> sysQuartzList = list(queryWrapper);if (null != sysQuartzList && !sysQuartzList.isEmpty()) {return ResponseResult.getInstance().error("该任务类名已经存在");}sysQuartz.setCreateTime(DateUtils.getYmdHms());sysQuartz.setCreateUser(SingletonLoginUtils.getUserId());save(sysQuartz);// 启动if (0 == sysQuartz.getQuartzStatus()) {this.schedulerAdd(sysQuartz.getClassName().trim(), sysQuartz.getCronExpression().trim(), sysQuartz.getParam());}return ResponseResult.getInstance().success();}/*** 添加定时任务** @param className* @param cronExpression* @param param*/@Overridepublic void schedulerAdd(String className, String cronExpression, String param) {try {// 启动调度器scheduler.start();// 构建job信息JobDetail jobDetail = JobBuilder.newJob(getClass(className).getClass()).withIdentity(className).usingJobData("param", param).build(); // 表达式调度构建器(即任务执⾏的时间)CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);// 按新的cronExpression表达式构建⼀个新的triggerCronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(className).withSchedule(scheduleBuilder).build();scheduler.scheduleJob(jobDetail, trigger);} catch (SchedulerException e) {log.error(e.getMessage());} catch (RuntimeException e) {log.error(e.getMessage());} catch (Exception e) {log.error(e.getMessage());}}/*** 删除定时任务** @param className*/@Overridepublic void schedulerDelete(String className) {try {scheduler.pauseTrigger(TriggerKey.triggerKey(className));scheduler.unscheduleJob(TriggerKey.triggerKey(className));scheduler.deleteJob(JobKey.jobKey(className));} catch (Exception e) {log.error(e.getMessage(), e);}}private static Job getClass(String className) throws Exception {Class<?> class1 = Class.forName(className);return (Job) class1.newInstance();}}需要注⼊ Scheduler 对象，使⽤该对象开启或停⽌定时任务在启动定时任务之前，我们应先删除该任务类名开启的定时任务，防⽌该任务类名已经添加过了// 删除定时任务schedulerDelete(sysQuartz.getClassName().trim());// 添加定时任务schedulerAdd(sysQuartz.getClassName().trim(), sysQuartz.getCronExpression().trim(), sysQuartz.getParam());添加定时任务，传⼊任务类名，cron 表达式，参数停⽌定时任务，只需要：scheduler.pauseJob(JobKey.jobKey(sysQuartz.getClassName().trim()));根据任务类名，停⽌定时任务即可五、开发测试启动项⽬，在管理界⾯，开启定时任务，即可在控制台看到打印的信息表⽰我们的定时任务已经启动成功了六、优化建议当我们添加了定时任务并启动后，重新启动项⽬的时候，定时任务却不会⾃动启动，这时候，我们就需要在项⽬启动的时候做⼀些事情了，也就是系统启动任务不清楚的同学可以复习⼀下之前我的博客【SpringBoot】⼗九、SpringBoot中实现启动任务import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;import com.zyxx.sbm.entity.SysQuartz;import com.zyxx.sbm.service.SysQuartzService;import org.springframework.beans.factory.annotation.Autowired;import mandLineRunner;import org.springframework.core.annotation.Order;import ponent;import java.util.List;/*** @ClassName SystemStartTask* 项⽬启动任务--启动定时任务* @Author Lizhou* @Date 2020-07-21 12:56:56**/@Component@Order(100)public class SystemQuartzStartTask implements CommandLineRunner {@Autowiredprivate SysQuartzService sysQuartzService;@Overridepublic void run(String... args) throws Exception {// 查询启动的定时任务QueryWrapper<SysQuartz> queryWrapper = new QueryWrapper<>();queryWrapper.eq("status", 0);queryWrapper.eq("quartz_status", 0);List<SysQuartz> list = sysQuartzService.list(queryWrapper);if (null != list && !list.isEmpty()) {for (SysQuartz item : list) {// 删除定时任务sysQuartzService.schedulerDelete(item.getClassName().trim());// 添加定时任务sysQuartzService.schedulerAdd(item.getClassName().trim(), item.getCronExpression().trim(), item.getParam());}}}}从数据库查询出启动的定时任务，并将他们添加到定时任务启动中，这样项⽬⼀启动时，就会⾃动启动我们定义的定时任务了最后任务类名的正则表达式/^[a-zA-Z]+(\.([a-zA-Z])+)+$/cron 表达式的验证使⽤正则太⿇烦，可以使⽤ Quartz ⾃带验证⽅法CronExpression.isValidExpression(cron)SpringBoot 中使⽤ Quartz 管理定时任务的学习就到这⼉了，其实也并不难理解，相⽐于之前⽤的定时任务是不是好很多了呢，别忘了最后加上系统启动任务哦总结到此这篇关于SpringBoot中使⽤Quartz管理定时任务的⽂章就介绍到这了,更多相关SpringBoot管理定时任务内容请搜索以前的⽂章或继续浏览下⾯的相关⽂章希望⼤家以后多多⽀持！。

springquartz实现定时任务的配置方法

Spring+Quartz实现定时任务的配置方法第一步：.导入相关的jar包(1)spring.jar(2)quartz-1.6.0.jar(3)相关包commons-collections-3.2.jar ; commons-logging-1.1.1.jar; log4j-1.2.16.jar第二步：创建一个类来定义工作定义Quartz工作的第一步是创建一个类来定义工作。

要做到这一点，你需要从Spring 的QuartzJobBean中派生子类。

第三步：配置JobDetail值得注意的是，在这里你并没有直接声明一个TopTenTask Bean，而是声明了一个JobDetailBean。

这是使用Quartz时的一个特点。

JobDetailBean是Quartz的org.quartz.JobDetail的子类，它要求通过jobClass属性来设置一个Job对象。

使用Quartz的JobDetail中的另一个特别之处是TopTenTask的timeout属性是间接设置的。

JobDetail的jobDataAsMap属性接受一个java.util.Map，其中包含了需要设置给jobClass的各种属性。

在这里，这个map包含了一个键值为timeout。

当JobDetailBean实例化时，它会将5注入到EmailReportJob的timeout属性中。

第四步：配置Trigger工作已经被定义好了，接下来你需要调度这个工作。

Quartz的org.quartz.Trigger类描述了何时及以怎样的频度运行一个Quartz工作。

Spring提供了两个触发器，SimpleTriggerBean和CronTriggerBean。

SimpleTriggerBean与ScheduledTimerTask类似。

你可以用它来指定一个工作应该以怎样的频度运行，以及（可选地）在第一次运行工作之前应该等待多久。

例如，要调度报表工作每24小时运行一次，第一次在1小时之后开始运行，可以按照以下方式进行声明：<bean id="topTenTrigger"class="org.springframework.scheduling.quartz.SimpleTriggerBean"><property name="jobDetail"><ref bean="topTenTask"/></property><property name="startDelay"><value>3600000</value></property><property name="repeatInterval"><value>86400000</value></property></bean>属性jobDetail装配了将要被调度的工作，在这个例子中是topTenTask Bean。

quart 定时规则

quart 定时规则
Quartz定时规则的语法是一种基于cron的表达式，它允许你定义在特定时间执行的计划任务。

以下是Quartz定时规则的一些常见符号和用法：
1. 秒（0-59）
2. 分（0-59）
3. 小时（0-23）
4. 日期（1-31）
5. 月份（1-12 或 JAN-DEC）
6. 星期（0-7 或 SUN-SAT，其中0和7都表示SAT）
你可以使用这些字段来定义任务的执行时间。

例如：
"0 0 12 ?" 表示每天中午12点执行任务。

"0 15 10 ? MON-FRI" 表示每周一到周五的上午10点15分执行任务。

"0 0/15 9-17 ?" 表示在每天的上午9点到下午5点之间，每小时执行一次任务。

"0 0 9 1/15 ?" 表示每月的1号、15号的上午9点执行任务。

"0 0 12 1/2 ?" 表示每两个月的1号中午12点执行任务。

"0 0 0 25 12 ?" 表示每年的12月25日午夜执行任务。

这只是Quartz定时规则的一些基本示例，你可以根据自己的需求来定义更
复杂的表达式。

请注意，Quartz定时规则的具体语法可能因不同的编程语
言或框架而有所差异，因此建议查阅相关语言的文档以获得准确的语法规范。

quartz定时任务cron表达式详解

quartz定时任务cron表达式详解cron表达式⽤于配置cronTrigger的实例。

cron表达式实际上是由七个⼦表达式组成。

这些表达式之间⽤空格分隔。

1.Seconds （秒）2.Minutes（分）3.Hours（⼩时）4.Day-of-Month （天）5.Month（⽉）6.Day-of-Week （周）7.Year（年）例："0 0 12 ? * WED” 意思是：每个星期三的中午12点执⾏。

个别⼦表达式可以包含范围或者列表。

例如：上⾯例⼦中的WED可以换成"MON-FRI"，"MON,WED,FRI"，甚⾄"MON-WED,SAT"。

⼦表达式范围：1.Seconds (0~59)2.Minutes (0~59)3.Hours (0~23)4.Day-of-Month (1~31,但是要注意有些⽉份没有31天)5.Month (0~11，或者"JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV,DEC")6.Day-of-Week (1~7,1=SUN 或者"SUN, MON, TUE, WED, THU, FRI, SAT”)7.Year (1970~2099)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 , - * /字符含义：* ：代表所有可能的值。

因此，“*”在Month中表⽰每个⽉，在Day-of-Month中表⽰每天，在Hours表⽰每⼩时- ：表⽰指定范围。

Quartz在Spring中如何动态配置时间

Quartz在Spring中如何动态配置时间在项目中有一个需求，需要灵活配置调度任务时间，并能自由启动或停止调度。

有关调度的实现我就第一就想到了Quartz这个开源调度组件，因为很多项目使用过，Spring 结合Quartz静态配置调度任务时间，非常easy。

比如：每天凌晨几点定时运行一个程序，这只要在工程中的spring配置文件中配置好spring整合quartz的几个属性就好。

Spring配置文件引用<bean id="jobDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"><property name="targetObject" ref="simpleService" /><property name="targetMethod" value="test" /></bean><bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerBean"><property name="jobDetail" ref="jobDetail" /><property name="cronExpression" value="0 0/50 * ? * * *" /></bean><bean id="schedulerTrigger" class="org.springframework.scheduling.quartz.SchedulerFactoryBean"><property name="triggers"><list><ref bean="cronTrigger"/></list></property></bean>这种配置就是对quartz的一种简单的使用了，调度任务会在spring启动的时候加载到内存中，按照cronTrigger中定义的cronExpression定义的时间按时触发调度任务。

quartz_定时器执行原理_概述说明以及概述

quartz 定时器执行原理概述说明以及概述引言部分的内容如下：1.1 概述Quartz定时器是一个功能强大且灵活的任务调度框架，它可以以预定的时间间隔或特定时间点触发指定的任务。

它可以帮助开发人员在复杂的应用中实现各种调度需求，并提供了可靠和稳定的任务执行机制。

本文将重点介绍Quartz定时器的执行原理及相关使用方法。

1.2 文章结构本文将按照以下结构来介绍Quartz定时器的执行原理和使用方法。

首先，我们将对Quartz进行简要介绍，包括其作用和特点。

然后，我们会详细讲解Quartz 定时任务的调度机制，包括任务触发方式和执行规则等内容。

接着，我们会深入探讨Quartz定时器的实现原理，解析其内部工作机制并说明其设计思路。

此外，我们还会给出配置Quartz定时器、创建定时任务以及执行定时任务的具体步骤和注意事项。

最后，我们会对Quartz定时器进行优缺点分析，并总结文章内容以及对Quartz定时器执行原理做出概述说明。

1.3 目的本文旨在帮助读者更加全面深入地了解Quartz定时器的底层执行原理和使用方法，使其能够正确配置和管理定时任务，并充分发挥Quartz的优势。

同时，通过分析Quartz定时器的优缺点，读者可以更好地评估其适用性和局限性，从而在实际应用中做出明智的选择。

2. Quartz定时器执行原理2.1 Quartz简介Quartz是一个功能强大且广泛使用的Java定时任务调度框架。

它提供了灵活的任务调度方式，并支持多种触发器来定义任务执行的频率和时间规则。

2.2 定时任务的调度机制Quartz使用基于日历的调度机制来实现定时任务的执行。

它可以根据指定的时间触发器，在指定的时间点或者一定周期内执行任务。

Quartz支持各种类型的触发器，包括简单触发器、Cron触发器和日历触发器等。

- 简单触发器：它基于设定的间隔时间以及开始时间，按照预定规则重复执行任务。

- Cron触发器：它是基于Cron表达式定义任务执行规则，可以非常灵活地设置年、月、日、周、小时、分钟等参数。

定时任务时间配置规则

定时任务时间配置规则1. 什么是定时任务时间配置规则定时任务时间配置规则是指在开发或运维过程中，为定时任务设置执行时间的一系列规范和约定。

通过合理配置定时任务的执行时间，可以保证任务的准确性、稳定性和高效性，提高系统的可靠性和性能。

2. 为什么需要定时任务时间配置规则定时任务在很多系统和应用中扮演着重要的角色，常用于定期生成报表、清理数据、发送通知等重要业务功能。

合理配置定时任务的执行时间，可以确保任务在合适的时间、间隔和频率下执行，避免任务冲突、占用过多系统资源或影响系统性能。

同时，规范的时间配置规则也有助于提高团队协作效率和代码可维护性。

3. 定时任务时间配置规则的基本原则合理的定时任务时间配置规则应遵循以下几个基本原则：3.1. 定时任务时间规则简洁清晰定时任务时间规则应尽量简洁清晰，易于理解和维护。

过于复杂的时间规则会增加理解和维护的难度，容易引发错误和问题。

3.2. 定时任务时间规则充分考虑各种情况定时任务时间规则应充分考虑到常见的业务场景和需求，确保任务能够在不同情况下准确、稳定地执行。

例如，是否需要跨时区或跨日期执行，是否存在依赖关系等。

3.3. 定时任务时间规则具备灵活性和扩展性定时任务时间规则应具备一定的灵活性和扩展性，以满足不同项目和业务的需求变化。

例如，设置支持动态配置执行时间的参数，方便根据实际情况进行调整。

4. 定时任务时间配置规则的常见格式常见的定时任务时间配置规则主要有以下几种格式：4.1. 简单固定时间格式简单固定时间格式是最常见的一种定时任务时间配置格式，可以按照固定的时间点执行任务。

例如：•每天固定时间点执行：每天凌晨2点执行任务•每周固定时间点执行：每周五下午3点执行任务4.2. 周期性时间格式周期性时间格式是指任务按照一定的间隔和频率执行。

常见的周期性时间格式有以下几种：•每隔固定时间执行：每隔5分钟执行任务一次•每隔固定时间段执行：每隔1小时执行任务一次，在9:00到17:00之间执行4.3. 指定时间点执行指定时间点执行是指任务在指定的时间点执行一次。

基于Quartz的可视化定时任务管理方案

基于Quartz的可视化定时任务管理方案作者：叶刚来源：《电子技术与软件工程》2018年第17期摘要Quartz的可视化定时任务管理方案介绍了如何直观、有效地管理诸多的定时任务。

该方案高效管理着全部任务的执行状态，直观地在页面显示着他们的运行结果;任务调度失败时，可以及时调出日志查明异常原因;同时在具有大量并发执行定时任务的应用系统中效率会大幅提升。

【关键词】可视化 Quartz 定时任务1 引言定时任务指在特定的时间点（如：每天23：59：59），特定的时间段（如：每周一12：00-13：00），自行执行的任务。

伴随着客户的需求，软件系统中会出现诸如此类的场景如：定期清理日志数据，定时发送消息，定时更新与备份数据，定期统计数据等等，它的出现解决了诸多上述类型的问题。

如果它仅仅靠后台处理执行，我们无法直观地知道它的运行的状态即是否执行，运行结果即是否成功以及运行异常。

针对此种情况，Quartz的可视化定时任务管理方案可以帮助我们高效的管理定时任务。

2 Quartz概述Quartz是一个使特定的功能在给定的时间点或时间范围自行执行的框架，即任务调度的框架，他有三个重要要素：（1）调度任的调度器Scheduler，所有的任务执行与否都由其控制;（2）控制任务什么时候被调度器触发的触发器Trigger，触发器可以设置任务才特定的时间或者时间段触发与任务是否并发执行等;（3）设置任务执行方法、任务标识等作业属性的JobDetail。

3 定时任务管理方案设计在基于Quartz的可视化定时任务管理方案设计时，为了给予定时任务更高效、更直观的管理方式，同时也为了对给每个任务的运行状况的全面追踪，故而此方案针对可视化以及定时任务的调度进行了以下的设计：3.1 可视化设计可视化化设计是对所有任务进行界面化的管理，针对每项定时任务的各项属性，如任务的标识、名称、执行状态、调度表达式、任务数据路径（类完整路径）、任务执行方法以及是否并发执行等以一条完整记录形式存入数据库中。

Quartz定时任务的使用和配置，全注解和xml

Quartz定时任务的使⽤和配置，全注解和xml
简介
Quartz是Job scheduling（作业调度）领域的⼀个开源项⽬，Quartz既可以单独使⽤也可以跟spring框架整合使⽤，在实际开发中⼀般会使⽤后者。

使⽤Quartz可以开发⼀个或者多个定时任务，每个定时任务可以单独指定执⾏的时间，例如每隔1⼩时执⾏⼀次、每个⽉第⼀天上午10点执⾏⼀次、每个⽉最后⼀天下午5点执⾏⼀次等。

maven坐标：
</dependency
xml配置
创建⼀个⼯作类
}
主要配置的内容有
配置⾃定义Job、任务描述、触发器、调度⼯⼚等
⾃动扫包
注册任务对象
注册JobDetail
触发器
调度⼯⼚
</bean
全注解(1)对应xml配置写⼀⼀注⼊就ok ⼯作类
}
@Configuration
}
按照xml顺序配置下来测试没问题。

全注解配置(2),推荐⽤法，⾮常简洁⾸先有⼀个配置类
}
@EnableScheduling
使⽤定时任务
}。

Quartz定时器时间设置

Quartz定时器时间设置Quartzspring定时器的时间设置时间的配置如下：<value>0 26 16 * * ?</value>时间大小由小到大排列，从秒开始，顺序为秒，分，时，天，月，年 *为任意？为无限制。

由此上面所配置的内容就是，在每天的16点26分启动buildSendHtml() 方法具体时间设定可参考"0/10 * * * * ?" 每10秒触发"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触发0 0 06,18 * * ? 在每天上午6点和下午6点触发0 30 5 * * ? * 在每天上午5:30触发0 0/3 * * * ? 每3分钟触发。

quartz实现定时功能实例详解（servlet定时器配置方法）

quartz实现定时功能实例详解（servlet定时器配置⽅法）复制代码代码如下:public class TestJob implements Job{public TestJob(){}public void execute(JobExecutionContext arg0) throws JobExecutionException{String name = context.getJobDetail().getJobDataMap().getString("name");System.out.println("job executing..."+name); }}public class QuartzTest{public static void main(String[] args){QuartzTest test = new QuartzTest();try{test.startSchedule();}catch (Exception e){e.printStackTrace();}}public void startSchedule() throws Exception{Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();JobDetail jobDetail =new JobDetail("testJob", Scheduler.DEFAULT_GROUP, TestJob.class);//结束时间long end = System.currentTimeMillis() + 9000L;//执⾏10次，每3秒执⾏⼀次，到9秒后结束SimpleTrigger trigger = new SimpleTrigger("test",null,new Date(),new Date(end),10,3000L);scheduler.scheduleJob(jobDetail, trigger);scheduler.start();}}执⾏上⾯这个类基本实现了⼀个简单的定时程序。

quartz定时任务时间设置

quartz定时任务时间设置这些星号由左到右按顺序代表： * * * * * * *格式： [秒] [分] [⼩时] [⽇] [⽉] [周] [年]序号说明是否必填允许填写的值允许的通配符1 秒是 0-59 , - * /2 分是 0-59, - * /3 ⼩时是 0-23 , - * /4 ⽇是 1-31 , - * ? / L W5 ⽉是 1-12 or JAN-DEC , - * /6 周是 1-7 or SUN-SAT , - * ? / L #7 年否 empty 或 1970-2099 , - * /通配符说明:* 表⽰所有值. 例如:在分的字段上设置 "*",表⽰每⼀分钟都会触发。

? 表⽰不指定值。

使⽤的场景为不需要关⼼当前设置这个字段的值。

例如:要在每⽉的10号触发⼀个操作，但不关⼼是周⼏，所以需要周位置的那个字段设置为"?" 具体设置为 0 0 0 10 * ?- 表⽰区间。

例如在⼩时上设置 "10-12",表⽰ 10,11,12点都会触发。

, 表⽰指定多个值，例如在周字段上设置 "MON,WED,FRI" 表⽰周⼀，周三和周五触发/ ⽤于递增触发。

如在秒上⾯设置"5/15" 表⽰从5秒开始，每增15秒触发(5,20,35,50)。

在⽉字段上设置'1/3'所⽰每⽉1号开始，每隔三天触发⼀次。

L 表⽰最后的意思。

在⽇字段设置上，表⽰当⽉的最后⼀天(依据当前⽉份，如果是⼆⽉还会依据是否是润年[leap]), 在周字段上表⽰星期六，相当于"7"或"SAT"。

如果在"L"前加上数字，则表⽰该数据的最后⼀个。

例如在周字段上设置"6L"这样的格式,则表⽰“本⽉最后⼀个星期五"W 表⽰离指定⽇期的最近那个⼯作⽇(周⼀⾄周五). 例如在⽇字段上设置"15W"，表⽰离每⽉15号最近的那个⼯作⽇触发。

用Quartz处理定时执行的任务

⽤Quartz处理定时执⾏的任务这次做的项⽬中，有⼀部分功能需要实现定时执⾏。

呃，这样说可能有点笼统，打个⽐⽅吧。

例如⽤户在登录的时候，连续输错3次密码后，系统会将该⽤户冻结，不再允许该⽤户登录系统，等到了晚上零晨时分，再为所有被冻结的⽤户解冻，这样，⽤户在第⼆天⼜可以正常登录系统了。

这样做是为了⽤户帐号安全，可有效防⽌暴⼒破解密码。

呃，好像跑题了，咱还是回到正题来。

在这⾥我们只关⼼怎么能实现每天晚上零晨准时执⾏为⽤户解冻的程序。

第⼀时间，我想到了JDK⾃带的Timer和TimerTask类，可经过测试，要想做到精准的定时，还是⽐较困难的。

于是另寻其它解决⽅案，就找到了Quartz，⾄于Quartz是什么，我想百度会告诉⼤家的。

⼆话不说，下载了Quartz包，下载的是官⽅最新版2.1.7。

然后兴致勃勃的百度起来，关于Quartz的⽤法，⽂章还是挺多的，但是，Copy进来后，总是报错。

⽆奈，最新版的⽤法，⽹上⼜很难找到。

怎么办呢？⾃⼰E⽂⼜不好！哎，E⽂是我永远的痛啊，谁叫俺爱国呢。

翻了⼀下下载的Quartz包，发现⾥⾯有好多例⼦，然后挨个挨个跑例⼦。

哈，功夫不负有⼼⼈啊，第三个例⼦刚好能解决我现在的问题，再仔细推敲⼀下，发现Quartz原来如此好⽤。

为了⽅便⽇后重复利⽤，也为了其他没⽤过Quartz⽽且E⽂也不怎么好的朋友不再受折磨，就决定把这次的使⽤⼼德记录下来。

第⼀步：引包要使⽤Quartz，必须要引⼊以下这⼏个包： 1、log4j-1.2.16 2、quartz-2.1.7 3、slf4j-api-1.6.1.jar 4、slf4j-log4j12-1.6.1.jar 这些包都在下载的Quartz包⾥⾯包含着，因此没有必要为寻找这⼏个包⽽头疼。

第⼆步：创建要被定执⾏的任务类这⼀步也很简单，只需要创建⼀个实现了org.quartz.Job接⼝的类，并实现这个接⼝的唯⼀⼀个⽅法execute(JobExecutionContext arg0) throws JobExecutionException即可。

Quartz中时间表达式的设置

Quartz中时间表达式的设置-----corn表达式时间格式: , 分别对应: 秒>分>小时>日>月>周>年, 举例:1.每天什么时候执行:<value>0 59 23 * * ?</value>: 如下为每天23:59:00开始执行<value>0 1,2,3 11,12 * * ? </value>: 每天11:01,11:02,11:03;12:01,12:02,12:03分执行任务2.每隔多久执行:汇总说明:Cron表达式的时间字段除允许设置数值外，还可使用一些特殊的字符，提供列表、范围、通配符等功能，细说如下：●星号(*)：可用在所有字段中，表示对应时间域的每一个时刻，例如，*在分钟字段时，表示“每分钟”；●问号（?）：该字符只在日期和星期字段中使用，它通常指定为“无意义的值”，相当于点位符；●减号(-)：表达一个范围，如在小时字段中使用“10-12”，则表示从10到12点，即10,11,12；●逗号(,)：表达一个列表值，如在星期字段中使用“MON,WED,FRI”，则表示星期一，星期三和星期五；●斜杠(/)：x/y表达一个等步长序列，x为起始值，y为增量步长值。

如在分钟字段中使用0/15，则表示为0,15,30和45秒，而5/15在分钟字段中表示5,20,35,50，你也可以使用*/y，它等同于0/y；==================================================Quartz cron 表达式的格式十分类似于UNIX cron 格式，但还是有少许明显的区别。

区别之一就是Quartz 的格式向下支持到秒级别的计划，而UNIX cron 计划仅支持至分钟级。

许多我们的触发计划要基于秒级递增的(例如，每45秒)，因此这是一个非常好的差异。

C#Quartz.Net定时任务的简单使用

C#定时任务的简单使⽤最近做了⼀个定时执⾏任务的软件。

执⾏任务时，会使⽤log4net记录⽇志，如果执⾏任务有异常，则发送邮件给指定的对象。

我做的是每天的9点和16点执⾏⼀次任务，以此记录：⾸先，获得，其实可以使⽤vs2015的Nuget管理器，下载。

我做了⼀个QuartzHelper，但是在主程序中，还是需要其他代码的。

这是QuartzHelper的代码：1using Quartz;2using Quartz.Impl;34namespace Cong.Utility5 {6public class QuartzHelper7 {8///<summary>9///时间间隔执⾏任务10///</summary>11///<typeparam name="T">任务类，必须实现IJob接⼝</typeparam>12///<param name="seconds">时间间隔(单位：毫秒)</param>13public static void ExecuteInterval<T>(int seconds) where T : IJob14 {15 ISchedulerFactory factory = new StdSchedulerFactory();16 IScheduler scheduler = factory.GetScheduler();1718//IJobDetail job = JobBuilder.Create<T>().WithIdentity("job1", "group1").Build();19 IJobDetail job = JobBuilder.Create<T>().Build();2021 ITrigger trigger = TriggerBuilder.Create()22 .StartNow()23 .WithSimpleSchedule(x => x.WithIntervalInSeconds(seconds).RepeatForever())24 .Build();2526 scheduler.ScheduleJob(job, trigger);2728 scheduler.Start();29 }3031///<summary>32///指定时间执⾏任务33///</summary>34///<typeparam name="T">任务类，必须实现IJob接⼝</typeparam>35///<param name="cronExpression">cron表达式，即指定时间点的表达式</param>36public static void ExecuteByCron<T>(string cronExpression) where T : IJob37 {38 ISchedulerFactory factory = new StdSchedulerFactory();39 IScheduler scheduler = factory.GetScheduler();4041 IJobDetail job = JobBuilder.Create<T>().Build();4243//DateTimeOffset startTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddSeconds(1), 2);44//DateTimeOffset endTime = DateBuilder.NextGivenSecondDate(DateTime.Now.AddYears(2), 3);4546 ICronTrigger trigger = (ICronTrigger)TriggerBuilder.Create()47//.StartAt(startTime).EndAt(endTime)48 .WithCronSchedule(cronExpression)49 .Build();5051 scheduler.ScheduleJob(job, trigger);5253 scheduler.Start();5455//Thread.Sleep(TimeSpan.FromDays(2));56//scheduler.Shutdown();57 }58 }5960#region任务执⾏例61//public class MyJob : IJob62//{63// public void Execute(IJobExecutionContext context)64// {65// Console.WriteLine("executed..." + DateTime.Now.ToString("yyyy/MM/dd HH:mm:ss"));66// }67//}68#endregion69 }⼤概的过程是这样的：通过ISchedulerFactory实例化⼀个计划⼯⼚对象，并使⽤⼯⼚实例化⼀个scheduler计划对象，然后实例化⼀个任务对象job，也就是定义任务内容的对象，需要传⼊⼀个实现IJob接⼝的类，这⾥我使⽤了泛型，接着，需要⼀个能触发任务的对象，这⾥有两种，⼀种是ITrigger，这是⽤于规格时间间隔，计划开始后，会根据间隔的时间值，触发执⾏任务；另⼀种是ICronTrigger，这是通过Cron表达式规格执⾏的时间，计划开始后，如果时间符合规定时间，就触发执⾏任务。

Quartz动态修改数据库cronExpression（无须重启服务器即可更改定时时间）

Quartz动态修改数据库cronExpression（无须重启服务器即
可更改定时时间）
quartz通过动态设置配置文件确实可以实现与数据库的同步，但现实开发上线后我们基本是不会对配置文件等进行变动，因为重启一次服务器所需的成本太多。

这时，就需要我们仅仅修改数据库就能实现动态的更新定时任务的定时时间。

但仅仅修改表qrtz_cron_triggers对应cronExpression 并不能生效，原因在于表qrtz_triggers中的所有时间相关的值并没有变动。

那么，如何做呢？
原本我想查看cronExpression表达式对应的各个时间段的计算规则，然后再进行相应的修改。

结果发现这方法既没找到对应的计算方法又很麻烦。

然后我想到如果将表qrtz_triggers中的下一次执行的时间NEXT_FIRE_TIME和上一次执行的时间PREV_FIRE_TIME值改为0，是不是可以解决？尝试后发现确实可以，而且执行任务后对应的相关时间值都变成了表qrtz_cron_triggers当前cronExpression值对应的时间。

实现步骤：
1.更改表qrtz_cron_triggers的cronExpression
2.将表qrtz_triggers的NEXT_FIRE_TIME和PREV_FIRE_TIME的值改为0
友情提示：使用此法则不能实现配置文件同数据库的同步，不然在执行定时任务前数据库数据会同步成配置文件对应的值，那么修改数据库也无法修改。

基于quartz的定时任务

基于quartz的定时任务功能概述：1首页显示自己添加的定时任务1.1页面追加可以嵌入定时任务1.2任务状态分为：运行中、暂停、已失效，运行中的任务可以删除、编辑、暂停，已失灵的任务只可以删掉、编辑（再次编辑后任务可以再次运转）2任性新增界面2.12.22.32.4编写任务标题撰写告诫内容（告诫内容并无字数管制）告诫时间可以挑选详尽、每日、每周、每月、cron（相似linux的cron）向谁告诫可以挑选多人功能实现：1定时任务长久化如果定时任务不进行持久化配置用户设置的定时任务会保存在内存中，应用重启后定时任务就不存在了。

1.1配置文件各布局参数恳请自己百度org.quartz.scheduler.instancename=defaultquartzschedulerorg.quartz.scheduler.r mi.export=falseorg.quartz.scheduler.rmi.proxy=falseorg.quartz.scheduler.wrapjobexecutioninusertransaction=falseorg.quartz.threadp ool.class:org.quartz.simpl.simplethreadpoolorg.quartz.threadpool.threadcount:10org.quartz.threadpool.threadpriority:5org.quartz.threadpool.threadsinheritcontextclassloaderofinitializingthread:fal se#org.quartz.jobstore.misfirethreshold=100000org.quartz.jobstore.class:org.quartz.impl.jdbcjobstore.jobstoretxorg.quartz.jo bstore.driverdelegateclass:org.quartz.impl.jdbcjobstore.stdjdbcdelegateeproperties:tureorg.quartz.jobstore.datasource:mydsorg.q uartz.jobstore.tableprefix:qrtz_org.quartz.jobstore.isclustered:false#上线时须要修正数据库布局org.quartz.datasource.myds.connectionprovider.class:tool.remind.mypoolingconne ctionproviderjdbc:mysql://localhost:3306/zcglpz1?characterencoding=utf-8&zerodatetimebehavior=converttonullorg.quartz.datasource.myds.driver=net.sf.log4jdbc.driverspyorg.quartz.datasour ce.myds.url=jdbc:log4jdbc:mysql://localhost:3306/zcglpz1?characterencoding=utf -8&zerodatetimebehavior=converttonuller:rootorg.quartz.datasource.myds.password:123654 org.quartz.datasource.myds.maxconnections:51.2编写mypoolingconnectionprovider.java类packagetool.remind;importjava.sql.connection;importjava.sql.sqlexception;publicclassmypoolingconnectionproviderimplementsconnectionprovider{privatebasi cdatasourcedatasource;privatestringdbdriver;privatestringurl;privatestringdbus er;privatestringdbpassword;privateintmaxconnections;privateintmaxstatementsperconnection;privatestringdbvalidationquery;privateboo leanvalidateoncheckout;privateintidlevalidationseconds;privateintmaxidlesecond s;publicmypoolingconnectionprovider(){}privatevoidinitialize(stringdbdriver,stringurl,stringdbuser,stringdbpassword,i ntmaxconnections,intmaxstatementsperconnection,stringdbvalidationquery,booleanvalidateoncheckout,intidlevalidationseconds,intmaxidl eseconds)throwssqlexception,schedulerexception{if(url==null){thrownewsqlexception(\}if(dbdriver==null){thrownewsqlexception(\\}if(maxconnections<0){thrownewsqlexception(\\}datasource=newbasicdatasource();datasource.setdriverclassname(dbdriver); datasource.seturl(url);datasource.setusername(dbuser);。

1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

quartz定时任务时间设置
这些星号由左到右按顺序代表：* * * * * * *
格式：[秒] [分] [小时] [日] [月] [周] [年]
序号说明
是否必填允许填写的值允许的通配符
1 秒是0-59 , - * /
2 分是0-59
, - * /
3 小时是0-23 , - * /
4 日是1-31 , - * ? / L W
5 月是1-12 or JAN-DEC , - * /
6 周是1-
7 or SUN-SAT , - * ? / L #
7 年否empty 或1970-2099 , - * /
通配符说明:
* 表示所有值. 例如:在分的字段上设置"*",表示每一分钟都会触发。

? 表示不指定值。

使用的场景为不需要关心当前设置这个字段的值。

例如:要在每月的10号触发一个操作，但不关心是周几，所以需要周位置的那个字段设置为"?" 具体设置为0 0 0 10 * ? - 表示区间。

例如在小时上设置"10-12",表示10,11,12点都会触发。

, 表示指定多个值，例如在周字段上设置"MON,WED,FRI" 表示周一，周三和周五触发
/ 用于递增触发。

如在秒上面设置"5/15" 表示从5秒开始，每增15秒触发(5,20,35,50)。

在月字段上设置'1/3'所示每月1号开始，每隔三天触发一次。

L 表示最后的意思。

在日字段设置上，表示当月的最后一天(依据当前月份，如果是二月还会依据是否是润年[leap]), 在周字段上表示星期六，相当于"7"或"SAT"。

如果在"L"前加上数字，则表示该数据的最后一个。

例如在周字段上设置"6L"这样的格式,则表示“本月最后一个星期五" W 表示离指定日期的最近那个工作日(周一至周五). 例如在日字段上设置"15W"，表示离每月15号最近的那个工作日触发。

如果15号正好是周六，则找最近的周五(14号)触发, 如果15号是周未，则找最近的下周一(16号)触发.如果15号正好在工作日(周一至周五)，则就在该天触发。

如果指定格式为"1W",它则表示每月1号往后最近的工作日触发。

如果1号正是周六，则将在3号下周一触发。

(注，"W"前只能设置具体的数字,不允许区间"-").
小提示
'L'和'W'可以一组合使用。

如果在日字段上设置"LW",则表示在本月的最后一个工作日触发(一般指发工资)
# 序号(表示每月的第几个周几)，例如在周字段上设置"6#3"表示在每月的第三个周六.注意如果指定"#5",正好第五周没有周六，则不会触发该配置(用在母亲节和父亲节再合适不过了)
小提示
周字段的设置，若使用英文字母是不区分大小写的MON 与mon相同.
常用示例:
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分每分触发
0 0/5 14 * * ? 每天下午的2点到2点59分(整点开始，每隔5分触发)
0 0/5 14,18 * * ? 每天下午的2点到2点59分(整点开始，每隔5分触发)
每天下午的18点到18点59分(整点开始，每隔5分触发)
0 0-5 14 * * ? 每天下午的2点到2点05分每分触发
0 10,44 14 ? 3 WED 3月分每周三下午的2点10分和2点44分触发（特殊情况，在一个时间设置里，执行两次或两次以上的情况）0 59 2 ? * FRI 每周5凌晨2点59分触发；
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 每月的第三周的星期五开始触发
0 0 12 1/5 * ? 每月的第一个中午开始每隔5天触发一次
0 11 11 11 11 ? 每年的11月11号11点11分触发(光棍节)。