精华内容
下载资源
问答
  • 求教各位大神,定时任务每周6的凌晨1点运行跑7个小时,这个该怎么配呢?
  • quartz定时器时间配置

    2017-07-13 16:12:11
    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    年     否        empty1970-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/5 * * * ?每6秒执行一次。(一般用与测试调试用,设置短一点)
    0 0 8-0 * * ?早8点至晚12点,每小时处理一次。
    0 0 1 * * ?每天凌晨1点执行
    0 0/10 * * * ?每十分钟执行一次
    0 0/15 * * * ?每30分钟执行一次
    0 0 18 * * ?每天晚上6点执行一次
    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分触发(光棍节)

    展开全文
  • 1、 CronTrigger时间格式配置说明 CronTrigger配置格式: 格式: [秒] [分] [小时] [日] [月] [周] [年] 序号 说明 是否必填 允许填写的值 允许的通配符 1 秒 ...

    1、   CronTrigger时间格式配置说明

    CronTrigger配置格式:

    格式: [秒] [分] [小时] [日] [月] [周] [年]

    序号

    说明

    是否必填

    允许填写的值

    允许的通配符

    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"表示在每月的第三个周星期六.注意如果指定"6#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 * * ?        每天下午的 18点到18点59分(整点开始,每隔5分触发)

    0 0-5 14 * * ?            每天下午的 2点到2点05分每分触发 
    0 10,44 14 ? 3 WED        3月分每周三下午的 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           每月的第三周的星期五开始触发 
    0 0 12 1/5 * ?            每月的第一个中午开始每隔5天触发一次 
    0 11 11 11 11 ?           每年的11月11号 11点11分触发(光棍节)

    展开全文
  • Quartz定时器的动态配置

    千次阅读 2019-03-18 17:24:39
    代码解释:Quartz定时器的动态配置。 1、需要的库环境,maven配置如下 <!-- TIMER --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</...

    代码解释:Quartz定时器的动态配置。

    1、需要的库环境,maven配置如下

    <!-- TIMER -->
       	<dependency>
       		<groupId>org.quartz-scheduler</groupId>
       		<artifactId>quartz</artifactId>
       	</dependency>
       	<dependency>
       		<groupId>org.quartz-scheduler</groupId>
       		<artifactId>quartz-jobs</artifactId>
       		<version>2.2.1</version>
     	</dependency>
    

    2、web.xml引入quartz.properties

    <!--定时器 -->
        <context-param>
           <param-name>quartz:config-file</param-name>
           <param-value>quartz.properties</param-value>
       </context-param>
       <context-param>
           <param-name>quartz:shutdown-on-unload</param-name>
           <param-value>true</param-value>
       </context-param>
       <context-param>
           <param-name>quartz:wait-on-shutdown</param-name>
           <param-value>false</param-value>
       </context-param>
       <context-param>
           <param-name>quartz:start-scheduler-on-load</param-name>
           <param-value>true</param-value>
       </context-param>
       <listener>
           <listener-class>
               org.quartz.ee.servlet.QuartzInitializerListener
           </listener-class>
       </listener>
    

    3、quartz.properties quartz持久化配置以及其他配置

    #固定前缀org.quartz
    #主要分为scheduler、threadPool、jobStore、plugin等部分
    org.quartz.scheduler.instanceName =DefaultQuartzScheduler
    org.quartz.scheduler.rmi.export =false
    org.quartz.scheduler.rmi.proxy =false
    org.quartz.scheduler.wrapJobExecutionInUserTransaction =false
    
    #实例化ThreadPool时,使用的线程类为SimpleThreadPool
    org.quartz.threadPool.class =org.quartz.simpl.SimpleThreadPool
    
    #threadCount和threadPriority将以setter的形式注入ThreadPool实例
    #并发个数
    org.quartz.threadPool.threadCount =5
    #优先级
    org.quartz.threadPool.threadPriority =5
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread =true
    
    org.quartz.jobStore.misfireThreshold =5000
    
    #默认存储在内存中
    #org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore
    
    #持久化
    org.quartz.jobStore.class =org.quartz.impl.jdbcjobstore.JobStoreTX
    
    org.quartz.jobStore.tablePrefix =QRTZ_
    
    org.quartz.jobStore.dataSource =qzDS
    
    org.quartz.dataSource.qzDS.driver =oracle.jdbc.driver.OracleDriver
    
    org.quartz.dataSource.qzDS.URL =jdbc:oracle:thin:@***.***.**.***:1521:orcl
    
    
    org.quartz.dataSource.qzDS.user =admin
    
    org.quartz.dataSource.qzDS.password =111111
    
    org.quartz.dataSource.qzDS.maxConnections =10
    

    4、创建数据库表 QUAR_//用来保存定时任务,以便于后期扫描装填,因为本人是Oracle环境,所以贴出Oracle代码,如果是其他数据库环境,可以去 Quartz官网下载完整文档,然后在压缩包下的z\quartz-2.2.2\docs\dbTables找到自己的环境表,运行脚本就ok了。

    delete from qrtz_fired_triggers;
    delete from qrtz_simple_triggers;
    delete from qrtz_simprop_triggers;
    delete from qrtz_cron_triggers;
    delete from qrtz_blob_triggers;
    delete from qrtz_triggers;
    delete from qrtz_job_details;
    delete from qrtz_calendars;
    delete from qrtz_paused_trigger_grps;
    delete from qrtz_locks;
    delete from qrtz_scheduler_state;
    
    drop table qrtz_calendars;
    drop table qrtz_fired_triggers;
    drop table qrtz_blob_triggers;
    drop table qrtz_cron_triggers;
    drop table qrtz_simple_triggers;
    drop table qrtz_simprop_triggers;
    drop table qrtz_triggers;
    drop table qrtz_job_details;
    drop table qrtz_paused_trigger_grps;
    drop table qrtz_locks;
    drop table qrtz_scheduler_state;
    
    
    CREATE TABLE qrtz_job_details
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      JOB_NAME  VARCHAR2(200) NOT NULL,
      JOB_GROUP VARCHAR2(200) NOT NULL,
      DESCRIPTION VARCHAR2(250) NULL,
      JOB_CLASS_NAME   VARCHAR2(250) NOT NULL, 
      IS_DURABLE VARCHAR2(1) NOT NULL,
      IS_NONCONCURRENT VARCHAR2(1) NOT NULL,
      IS_UPDATE_DATA VARCHAR2(1) NOT NULL,
      REQUESTS_RECOVERY VARCHAR2(1) NOT NULL,
      JOB_DATA BLOB NULL,
      CONSTRAINT QRTZ_JOB_DETAILS_PK PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
    );
    CREATE TABLE qrtz_triggers
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      TRIGGER_NAME VARCHAR2(200) NOT NULL,
      TRIGGER_GROUP VARCHAR2(200) NOT NULL,
      JOB_NAME  VARCHAR2(200) NOT NULL, 
      JOB_GROUP VARCHAR2(200) NOT NULL,
      DESCRIPTION VARCHAR2(250) NULL,
      NEXT_FIRE_TIME NUMBER(13) NULL,
      PREV_FIRE_TIME NUMBER(13) NULL,
      PRIORITY NUMBER(13) NULL,
      TRIGGER_STATE VARCHAR2(16) NOT NULL,
      TRIGGER_TYPE VARCHAR2(8) NOT NULL,
      START_TIME NUMBER(13) NOT NULL,
      END_TIME NUMBER(13) NULL,
      CALENDAR_NAME VARCHAR2(200) NULL,
      MISFIRE_INSTR NUMBER(2) NULL,
      JOB_DATA BLOB NULL,
      CONSTRAINT QRTZ_TRIGGERS_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
      CONSTRAINT QRTZ_TRIGGER_TO_JOBS_FK FOREIGN KEY (SCHED_NAME,JOB_NAME,JOB_GROUP) 
        REFERENCES QRTZ_JOB_DETAILS(SCHED_NAME,JOB_NAME,JOB_GROUP) 
    );
    CREATE TABLE qrtz_simple_triggers
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      TRIGGER_NAME VARCHAR2(200) NOT NULL,
      TRIGGER_GROUP VARCHAR2(200) NOT NULL,
      REPEAT_COUNT NUMBER(7) NOT NULL,
      REPEAT_INTERVAL NUMBER(12) NOT NULL,
      TIMES_TRIGGERED NUMBER(10) NOT NULL,
      CONSTRAINT QRTZ_SIMPLE_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
      CONSTRAINT QRTZ_SIMPLE_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
      REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_cron_triggers
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      TRIGGER_NAME VARCHAR2(200) NOT NULL,
      TRIGGER_GROUP VARCHAR2(200) NOT NULL,
      CRON_EXPRESSION VARCHAR2(120) NOT NULL,
      TIME_ZONE_ID VARCHAR2(80),
      CONSTRAINT QRTZ_CRON_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
      CONSTRAINT QRTZ_CRON_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_simprop_triggers
    (          
      SCHED_NAME VARCHAR2(120) NOT NULL,
      TRIGGER_NAME VARCHAR2(200) NOT NULL,
      TRIGGER_GROUP VARCHAR2(200) NOT NULL,
      STR_PROP_1 VARCHAR2(512) NULL,
      STR_PROP_2 VARCHAR2(512) NULL,
      STR_PROP_3 VARCHAR2(512) NULL,
      INT_PROP_1 NUMBER(10) NULL,
      INT_PROP_2 NUMBER(10) NULL,
      LONG_PROP_1 NUMBER(13) NULL,
      LONG_PROP_2 NUMBER(13) NULL,
      DEC_PROP_1 NUMERIC(13,4) NULL,
      DEC_PROP_2 NUMERIC(13,4) NULL,
      BOOL_PROP_1 VARCHAR2(1) NULL,
      BOOL_PROP_2 VARCHAR2(1) NULL,
      CONSTRAINT QRTZ_SIMPROP_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
      CONSTRAINT QRTZ_SIMPROP_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_blob_triggers
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      TRIGGER_NAME VARCHAR2(200) NOT NULL,
      TRIGGER_GROUP VARCHAR2(200) NOT NULL,
      BLOB_DATA BLOB NULL,
      CONSTRAINT QRTZ_BLOB_TRIG_PK PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
      CONSTRAINT QRTZ_BLOB_TRIG_TO_TRIG_FK FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
          REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_calendars
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      CALENDAR_NAME  VARCHAR2(200) NOT NULL, 
      CALENDAR BLOB NOT NULL,
      CONSTRAINT QRTZ_CALENDARS_PK PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
    );
    CREATE TABLE qrtz_paused_trigger_grps
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      TRIGGER_GROUP  VARCHAR2(200) NOT NULL, 
      CONSTRAINT QRTZ_PAUSED_TRIG_GRPS_PK PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
    );
    CREATE TABLE qrtz_fired_triggers 
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      ENTRY_ID VARCHAR2(95) NOT NULL,
      TRIGGER_NAME VARCHAR2(200) NOT NULL,
      TRIGGER_GROUP VARCHAR2(200) NOT NULL,
      INSTANCE_NAME VARCHAR2(200) NOT NULL,
      FIRED_TIME NUMBER(13) NOT NULL,
      SCHED_TIME NUMBER(13) NOT NULL,
      PRIORITY NUMBER(13) NOT NULL,
      STATE VARCHAR2(16) NOT NULL,
      JOB_NAME VARCHAR2(200) NULL,
      JOB_GROUP VARCHAR2(200) NULL,
      IS_NONCONCURRENT VARCHAR2(1) NULL,
      REQUESTS_RECOVERY VARCHAR2(1) NULL,
      CONSTRAINT QRTZ_FIRED_TRIGGER_PK PRIMARY KEY (SCHED_NAME,ENTRY_ID)
    );
    CREATE TABLE qrtz_scheduler_state 
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      INSTANCE_NAME VARCHAR2(200) NOT NULL,
      LAST_CHECKIN_TIME NUMBER(13) NOT NULL,
      CHECKIN_INTERVAL NUMBER(13) NOT NULL,
      CONSTRAINT QRTZ_SCHEDULER_STATE_PK PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
    );
    CREATE TABLE qrtz_locks
    (
      SCHED_NAME VARCHAR2(120) NOT NULL,
      LOCK_NAME  VARCHAR2(40) NOT NULL, 
      CONSTRAINT QRTZ_LOCKS_PK PRIMARY KEY (SCHED_NAME,LOCK_NAME)
    );
    
    create index idx_qrtz_j_req_recovery on qrtz_job_details(SCHED_NAME,REQUESTS_RECOVERY);
    create index idx_qrtz_j_grp on qrtz_job_details(SCHED_NAME,JOB_GROUP);
    
    create index idx_qrtz_t_j on qrtz_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);
    create index idx_qrtz_t_jg on qrtz_triggers(SCHED_NAME,JOB_GROUP);
    create index idx_qrtz_t_c on qrtz_triggers(SCHED_NAME,CALENDAR_NAME);
    create index idx_qrtz_t_g on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP);
    create index idx_qrtz_t_state on qrtz_triggers(SCHED_NAME,TRIGGER_STATE);
    create index idx_qrtz_t_n_state on qrtz_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP,TRIGGER_STATE);
    create index idx_qrtz_t_n_g_state on qrtz_triggers(SCHED_NAME,TRIGGER_GROUP,TRIGGER_STATE);
    create index idx_qrtz_t_next_fire_time on qrtz_triggers(SCHED_NAME,NEXT_FIRE_TIME);
    create index idx_qrtz_t_nft_st on qrtz_triggers(SCHED_NAME,TRIGGER_STATE,NEXT_FIRE_TIME);
    create index idx_qrtz_t_nft_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME);
    create index idx_qrtz_t_nft_st_misfire on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_STATE);
    create index idx_qrtz_t_nft_st_misfire_grp on qrtz_triggers(SCHED_NAME,MISFIRE_INSTR,NEXT_FIRE_TIME,TRIGGER_GROUP,TRIGGER_STATE);
    
    create index idx_qrtz_ft_trig_inst_name on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME);
    create index idx_qrtz_ft_inst_job_req_rcvry on qrtz_fired_triggers(SCHED_NAME,INSTANCE_NAME,REQUESTS_RECOVERY);
    create index idx_qrtz_ft_j_g on qrtz_fired_triggers(SCHED_NAME,JOB_NAME,JOB_GROUP);
    create index idx_qrtz_ft_jg on qrtz_fired_triggers(SCHED_NAME,JOB_GROUP);
    create index idx_qrtz_ft_t_g on qrtz_fired_triggers(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP);
    create index idx_qrtz_ft_tg on qrtz_fired_triggers(SCHED_NAME,TRIGGER_GROUP);
    

    5、编写后台QuartzManager类,完成定时任务的增删改查停启恢

    public class QuartzManager {
        /**
         * @param jobClass 任务实现类
         * @param jobName 任务名称
         *  @param jobGroupName 任务组名
         * @param jobTime 时间表达式 (如:0/5 * * * * ? )
         * @throws SchedulerException 
         */
        public  void addJob(Class<? extends Job> jobClass, String jobName,String jobGroupName,String jobTime)  {
            try {
            	// 通过SchedulerFactory获取一个调度器实例  
                SchedulerFactory sf = new StdSchedulerFactory();      
                Scheduler scheduler = sf.getScheduler();  
                //创建jobDetail实例,绑定Job实现类  
                //指明job的名称,所在组的名称,以及绑定job类
                JobDetail jobDetail = JobBuilder.newJob(jobClass)
                                .withIdentity(jobName, jobGroupName)//任务名称和组构成任务key
                                .build();
                //定义调度触发规则  
                //使用cornTrigger规则 
                Trigger trigger = TriggerBuilder.newTrigger()
                            .withIdentity(jobName, jobGroupName)//触发器key
                            .startAt(DateBuilder.futureDate(1, IntervalUnit.SECOND))
                            .withSchedule(CronScheduleBuilder.cronSchedule(jobTime))
                            .startNow().build();
                //把作业和触发器注册到任务调度中
                scheduler.scheduleJob(jobDetail, trigger);
                // 启动
                if (!scheduler.isShutdown()) {
                    scheduler.start();
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
     
        /**
         * 增加一个job
         * @param jobClass  任务实现类
         * @param jobName  任务名称
         * @param jobGroupName 任务组名
         * @param jobTime  时间表达式 (这是每隔多少秒为一次任务)
         */
        public void addJob(Class<? extends Job> jobClass, String jobName,String jobGroupName,int jobTime){
            addJob(jobClass,jobName,jobGroupName,jobTime,-1);
        }
     
        /**
         * 增加一个job
         * @param jobClass 任务实现类
         * @param jobName  任务名称
         * @param jobGroupName 任务组名
         * @param jobTime  时间表达式 (这是每隔多少秒为一次任务)
         * @param jobTimes  运行的次数 (<0:表示不限次数)
         */
        public void addJob(Class<? extends Job> jobClass, String jobName,String jobGroupName,int jobTime,int jobTimes){
             try {
            	// 通过SchedulerFactory获取一个调度器实例  
                 SchedulerFactory sf = new StdSchedulerFactory();      
                 Scheduler scheduler = sf.getScheduler();  
                 JobDetail jobDetail = JobBuilder.newJob(jobClass)
                                 .withIdentity(jobName, jobGroupName)//任务名称和组构成任务key
                                 .build();
               //使用simpleTrigger规则
                 Trigger trigger=null;
                 if(jobTimes<0){
                     trigger=TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)  
                            .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1).withIntervalInSeconds(jobTime))  
                            .startNow().build();
                 }else{
                     trigger=TriggerBuilder.newTrigger().withIdentity(jobName, jobGroupName)  
                            .withSchedule(SimpleScheduleBuilder.repeatSecondlyForever(1).withIntervalInSeconds(jobTime).withRepeatCount(jobTimes))  
                            .startNow().build();
                 }
                scheduler.scheduleJob(jobDetail, trigger);
                if (!scheduler.isShutdown()) {
                    scheduler.start();
                }
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
     
        /**
         * @param jobName
         * @param jobGroupName
         * @param jobTime
         *  修改 一个job的 时间表达式
         */
        public void updateJob(String jobName,String jobGroupName,String jobTime){
            try {
            	// 通过SchedulerFactory获取一个调度器实例  
                SchedulerFactory sf = new StdSchedulerFactory();      
                Scheduler scheduler = sf.getScheduler();  
                TriggerKey triggerKey = TriggerKey.triggerKey(jobName, jobGroupName);  
                CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);  
                trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                        .withSchedule(CronScheduleBuilder.cronSchedule(jobTime))
                        .build();
                //重启触发器
                scheduler.rescheduleJob(triggerKey, trigger);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }  
        }
     
        /**
         *  删除任务一个job
         * @param jobName 任务名称
         * @param jobGroupName 任务组名
         */
        public  void deleteJob(String jobName,String jobGroupName) {
            try {
            	// 通过SchedulerFactory获取一个调度器实例  
                SchedulerFactory sf = new StdSchedulerFactory();      
                Scheduler scheduler = sf.getScheduler();  
                scheduler.deleteJob(new JobKey(jobName, jobGroupName));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
     
        /**
         *  暂停一个job
         * @param jobName
         * @param jobGroupName
         */
        public void pauseJob(String jobName,String jobGroupName){
            try {
            	// 通过SchedulerFactory获取一个调度器实例  
                SchedulerFactory sf = new StdSchedulerFactory();      
                Scheduler scheduler = sf.getScheduler();  
                JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);  
                scheduler.pauseJob(jobKey);
            } catch (SchedulerException e) {
                e.printStackTrace();
            } 
        }
     
        /**
         *   恢复一个job
         * @param jobName
         * @param jobGroupName
         */
        public void resumeJob(String jobName,String jobGroupName){
            try {
            	// 通过SchedulerFactory获取一个调度器实例  
                SchedulerFactory sf = new StdSchedulerFactory();      
                Scheduler scheduler = sf.getScheduler();  
                JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
                scheduler.resumeJob(jobKey);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
     
        /**
         *   立即执行一个job
         * @param jobName
         * @param jobGroupName
         */
        public void runAJobNow(String jobName,String jobGroupName){
            try {
            	// 通过SchedulerFactory获取一个调度器实例  
                SchedulerFactory sf = new StdSchedulerFactory();      
                Scheduler scheduler = sf.getScheduler();  
                JobKey jobKey = JobKey.jobKey(jobName, jobGroupName);
                scheduler.triggerJob(jobKey);
            } catch (SchedulerException e) {
                e.printStackTrace();
            }
        }
     
        /**
         *    获取所有计划中的任务列表
         * @return
         */
        public List<Map<String,Object>> queryAllJob(){
            List<Map<String,Object>> jobList=null;
            try {
            	// 通过SchedulerFactory获取一个调度器实例  
                SchedulerFactory sf = new StdSchedulerFactory();      
                Scheduler scheduler = sf.getScheduler();  
                 GroupMatcher<JobKey> matcher = GroupMatcher.anyJobGroup();  
                 Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
                 jobList = new ArrayList<Map<String,Object>>();  
                 for (JobKey jobKey : jobKeys) {  
                      List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);  
                      for (Trigger trigger : triggers) {  
                          Map<String,Object> map=new HashMap<String,Object>();
                          map.put("jobName",jobKey.getName());
                          map.put("jobGroupName",jobKey.getGroup());
                          map.put("description","触发器:" + trigger.getKey());
                          Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());  
                          map.put("jobStatus",triggerState.name());
                          if (trigger instanceof CronTrigger) {  
                              CronTrigger cronTrigger = (CronTrigger) trigger;  
                              String cronExpression = cronTrigger.getCronExpression();  
                              map.put("jobTime",cronExpression);
                          }  
                          jobList.add(map);  
                      }  
                  }  
            } catch (SchedulerException e) {
                e.printStackTrace();
            }  
            return jobList;  
        }
     
        /**
         *   获取所有正在运行的job
         * @return
         */
        public List<Map<String,Object>> queryRunJon(){
            List<Map<String,Object>> jobList=null;
            try {
            	// 通过SchedulerFactory获取一个调度器实例  
                SchedulerFactory sf = new StdSchedulerFactory();      
                Scheduler scheduler = sf.getScheduler();  
                List<JobExecutionContext> executingJobs = scheduler.getCurrentlyExecutingJobs();
                jobList = new ArrayList<Map<String,Object>>(executingJobs.size());  
                for (JobExecutionContext executingJob : executingJobs) {  
                    Map<String,Object> map=new HashMap<String, Object>();  
                    JobDetail jobDetail = executingJob.getJobDetail();  
                    JobKey jobKey = jobDetail.getKey();  
                    Trigger trigger = executingJob.getTrigger(); 
                    map.put("jobName",jobKey.getName());
                    map.put("jobGroupName",jobKey.getGroup());
                    map.put("description","触发器:" + trigger.getKey());
                    Trigger.TriggerState triggerState = scheduler.getTriggerState(trigger.getKey());  
                    map.put("jobStatus",triggerState.name());
                    if (trigger instanceof CronTrigger) {  
                        CronTrigger cronTrigger = (CronTrigger) trigger;  
                        String cronExpression = cronTrigger.getCronExpression();  
                        map.put("jobTime",cronExpression);
                    }  
                    jobList.add(map);  
                }  
            } catch (SchedulerException e) {
                e.printStackTrace();
            }  
            return jobList;  
        }
    

    6、编写后台Job类实现job接口

    
    public class FirstJob implements Job {  
    
        private static Logger _log = LoggerFactory.getLogger(FirstJob.class);  
    
        public FirstJob() {  
    
        }  
    
        public void execute(JobExecutionContext context)  
            throws JobExecutionException {  
            _log.error("Hello Job执行时间: " + new Date());  
    
        }  
    }  
    

    6、后台测试容器监听器代码,主要用于在未开发前端增删改查页面,用于模拟数据包请求该功能使用。

     
    /**
    * 容器监听器
    * @author jing
    */
    public class QuartzJobListener implements ServletContextListener {
    
      @SuppressWarnings("unchecked")
      public void contextInitialized(ServletContextEvent arg0) {
          /***处理获取数据库的job表,然后遍历循环每个加到job中 ***/
          QuartzManager quartzManager = WebApplicationContextUtils.getWebApplicationContext(arg0.getServletContext()).getBean(QuartzManager.class);
    
          //此处就不写获取数据库了,模拟一个集合遍历的数据  
          List<Map<String,Object>> listMap=new ArrayList<>();
          Map<String, Object> map1=new HashMap<String, Object>();
          map1.put("jobClass","com.gsww.kfpt.web.controller.quartz.job.test.FirstJob");
          map1.put("jobName","job1");
          map1.put("jobGroupName","job1");
          map1.put("jobTime","0/5 * * * * ? ");
          listMap.add(map1);
    
          for (Map<String, Object> map : listMap) {
              try {
                  quartzManager.addJob((Class<? extends Job>)(Class.forName((String)map.get("jobClass")).newInstance().getClass()),(String)map.get("jobName"), (String)map.get("jobGroupName"),(String)map.get("jobTime"));
              } catch (Exception e) {
                  e.printStackTrace();
              } 
          }
          System.out.println("QuartzJobListener 启动了");
      }
      public void contextDestroyed(ServletContextEvent arg0) {
      	
      }
    }
    

    7、编写前端界面,主要包括列表,增删改查停启恢,页面如下,自行开发。
    在这里插入图片描述
    新增定时任务页面如下,添加任务:
    在这里插入图片描述
    点击保存,看到后台:
    在这里插入图片描述
    就算你服务重启,还重新载入你的定时任务,不会出现定时任务失效的情况。至此整个功能开发完毕。后台数据库如下:
    在这里插入图片描述

    展开全文
  • org.springframework.scheduling.quartz.CronTriggerBean允许你更精确地控制任务的运行时间,只需要设置其cronExpression属性。 一个cronExpression表达式有至少6个(也可能是7个)由空格分隔的时间元素。从左至右...

    单纯针对时间的设置规则

    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秒"。而"5/15"则表示"第5, 20, 35,和50".在'/'前加"*"字符相当于指定从0秒开始.每个字段都有一系列可以开始或结束的数值。对于“秒”和“分”字段来说,其数值范围为0到59,对于“小时”字段来说其为0到23,对于“日”字段来说为0到31,而对于“月”字段来说为1到12。"/"字段仅仅只是帮助你在允许的数值范围内从开始"第n"的值。

    “L”——字符可用在“日”和“周几”这两个字段。它是"last"的缩写,但是在这两个字段中有不同的含义。例如,“日”字段中的"L"表示"一个月中的最后一天" ——对于一月就是31号对于二月来说就是28号(非闰年)。而在“周几”字段中,它简单的表示"7" or "SAT",但是如果在“周几”字段中使用时跟在某个数字之后,它表示"该月最后一个星期×" ——比如"6L"表示"该月最后一个周五"。当使用'L'选项时,指定确定的列表或者范围非常重要,否则你会被结果搞糊涂的。

    “W”——可用于“日”字段。用来指定历给定日期最近的工作日(周一到周五)。比如你将“日”字段设为"15W",意为: "离该月15号最近的工作日"。因此如果15号为周六,触发器会在14号即周五调用。如果15号为周日,触发器会在16号也就是周一触发。如果15号为周二,那么当天就会触发。然而如果你将“日”字段设为"1W",而一号又是周六,触发器会于下周一也就是当月的3号触发,因为它不会越过当月的值的范围边界。'W'字符只能用于“日”字段的值为单独的一天而不是一系列值的时候。

    “L”和“W”可以组合用于“日”字段表示为'LW',意为"该月最后一个工作日"。

    “#”——字符可用于“周几”字段。该字符表示“该月第几个周×”,比如"6#3"表示该月第三个周五( 6表示周五而"#3"该月第三个)。再比如: "2#1" =表示该月第一个周一而"4#5" =该月第五个周三。注意如果你指定"#5"该月没有第五个“周×”,该月是不会触发的。

    “C”——字符可用于“日”和“周几”字段,它是"calendar"的缩写。它表示为基于相关的日历所计算出的值(如果有的话)。如果没有关联的日历,那它等同于包含全部日历。“日”字段值为"5C"表示"日历中的第一天或者5号以后",“周几”字段值为"1C"则表示"日历中的第一天或者周日以后"。

    对于“月份”字段和“周几”字段来说合法的字符都不是大小写敏感的。

    一些例子:

    "0 0 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:55分结束每5分钟一次触发
    
    "0 0/5 14,18 * * ?"每天的下午2点至2:55和6点至6点55分两个时间段内每5分钟一次触发
    
    "0 0-5 14 * * ?"每天14:00至14:05每分钟一次触发
    
    "0 10,44 14 ? 3 WED"三月的每周三的14:10和14: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

    展开全文
  • 一个cron表达式有至少6个(也可能7个)有空格分隔的时间元素。 按顺序依次为 1.秒(0~59) 2.分钟(0~59) 3.小时(0~23)  4.天(月)(0~31,但是你需要考虑你月的天数) 5.月(0~11) 6.天(星期)(1~7 1=SUN ...
  • quartz定时器

    千次阅读 2019-06-27 09:51:18
    一、关于 Quartz Quartz 是一个完全由 Java 编写的开源作业调度框架,为在... Quartz 允许程序开发人员根据时间的间隔来调度作业。 Quartz 实现了作业和触发器的多对多的关系,还能把多个作业与不同的触发...
  • Quartz定时器 时间设置

    2021-03-30 23:48:08
    Quartz定时器 时间设置: CronTrigger配置完整格式为: [秒] [分] [小时] [日] [月] [周] [年] 通配符说明: "* " 表示所有值. 例如:在分的字段上设置 “*”,表示每一分钟都会触发。 “?” 表示不指定值。使用的...
  • springboot 集成quartz定时器 pom.xml 添加quartz依赖 <groupId>org.springframework.boot <artifactId>spring-boot-starter-quartz application.properties配置文件(线程池的基本大小、...
  • quartz.properties用于存放quart的配置 job.xml 用于存放定时任务job Test.java package com.zte.quartzTest; import java.util.Date; import org.quartz.JobBuilder; import org.quartz.JobDetail; ...
  • 导入的jar包第二步: 在XML Spring中类型中配置: 1:定义需要调用对象 2:定义调用的对象和调用的对象方法 3:定义触发器并配置触发时间(可为多个) 4:配置调度器第三步: 1:在spring-config.xml的容器中...
  • 1. 添加maven依赖。pom.xml 中添加jar文件 <!-- 作业任务调度机制 --> <dependency>...org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <...
  • 如何配置quartz定时器?

    2019-04-26 15:41:34
    首先创建配置文件:applicationContext_job.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...
  • Quartz定时器时间设置

    万次阅读 2017-08-29 14:55:31
    Quartz 定时器时间设置 时间配置如下:0 26 16 * * ?  时间大小由小到大排列,从秒开始,顺序为 秒,分,时,天,月,年 *为任意 ?为无限制。 由此上面所配置的内容就是,在每天的16点26分启动...
  • Quartz定时器主要核心组件包括调度器,触发器,作业,调度器作为作业的总指挥,触发器作为作业的操作者,作业为应用的功能模块、 Job是一个接口,该接口只有一个方法execute,被调度的作业(类)需要实现该接口的...
  • springboot整合quartz定时器实现定时任务详解

    万次阅读 多人点赞 2018-06-08 15:40:39
    最近需要 做一个按照时间,定时初始化一些信息的功能,研究了一下quartz,也简单了解一下TimerTask,废话不多说。 quartz和TimerTask的区别: timer是jdk自带的(可想而知,肯定是不怎么好用)。 Quartz可以...
  • Spring Quartz定时器配置

    千次阅读 2014-10-25 17:55:00
    Spring中Quartz配置 各种企业应用几乎都会碰到任务调度的需求,就拿论坛来说:每隔半个小时生成精华文章的RSS文件, 每天凌晨统计论坛用户的积分排名,每隔30分钟执行锁定用户解锁任务。对于一个典型的MIS系统来...
  • Spring集成Quartz定时器

    千次阅读 2019-04-25 10:33:59
    一、什么是Quartz? quartz是一个由java编写的任务调度库。它能用来干什么? 1、每天定时发送系统邮件 ...spring整合配置quartz定时器任务非常的简单 1、首先导入spring quartz的jar包 <dep...
  • CronTriggers往往比SimpleTrigger更有用,如果您需要基于日历的概念,而非SimpleTrigger完全指定的时间间隔,复发的发射工作的时间表。 CronTrigger,你可以指定触发的时间表如“每星期五中午”,或“每个工作日9:30...
  • Spring quartz定时器不报错,但不执行

    万次阅读 2018-08-07 15:45:05
    原理现在我还没有太搞懂,可能是因为项目...org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"&gt; &lt;property name="targetObject" ref="helloTask...
  • Quartz定时器的学习总结

    千次阅读 2018-06-26 09:43:29
    Quartz可以用来做什么?Quartz是一个任务调度框架。比如你遇到这样的问题想每月25号,信用卡自动还款想每年4月1日自己给当年暗恋女神发一封匿名贺卡想每隔1小时,备份一下自己的爱情动作片 学习笔记到云盘这些问题...
  • 一、核心概念Quartz的原理不是很复杂,只要搞明白几个概念,然后知道如何去启动和关闭一个调度程序即可。1、Job表示一个工作,要执行的具体内容。此接口中只有一个方法void execute(JobExecutionContext context)2、...
  • 第9章 Quartz定时器和发送Email

    千次阅读 2018-09-23 15:50:56
    代码开发完成之后,我们重新启动项目,在Intellij IDEA控制台中可以看到如图9-2所示的信息,证明在Spring Boot中整合Quartz定时器成功。 图9-2 Quartz定时器打印信息 9.2 Spring Boot发送Email 9.2.1 Email...
  • Quartz 定时器时间设置时间配置如下:&lt;value&gt;0 26 16 * * ?&lt;/value&gt; 时间大小由小到大排列,从秒开始,顺序为 秒,分,时,天,月,年 *为任意 ?为无限制。 由此上面所配置的...
  • quartz定时器使用

    2019-06-17 09:30:17
    quartz和spring整合,需要配置SchedulerFactoryBean用来产生StdScheduler 首先使用SchedulerFactory得到Scheduler,我们的任务时一个实现job接口的类,而真正被调度使用的是JobDetail 剩下的就是使用触发器Trigger...
  • 首先介绍一下关于quartz的相关信息: 1.核心元素 Quartz核心要素有Scheduler、Trigger、Job、JobDetail,其中...Trigger用于定义调度任务的时间规则,在Quartz中主要有四种类型的Trigger:SimpleTrigger、CronTrigger...
  • Spring Quartz 定时器任务

    千次阅读 2017-02-27 20:29:33
    Spring Quartz 定时器任务本文介绍了Spring Quartz使用定时器任务的2种方式 基于XML文件的方式 基于注解的方式 Spring Quartz部分有如下一些核心概念: Scheduler是一个计划调度器容器,容器里面可以很多的JobDetail...
  • Quartz定时器精解

    2018-07-16 14:33:37
    Quartz概述 1.1 quartz介绍和下载 官网:http://www.quartz-scheduler.org/   Quartz是OpenSymphony开源组织在Jobscheduling领域又一个开源项目,它可以与J2EE与J2SE应用程序相结合也可以单独使用。...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,798
精华内容 2,719
关键字:

quartz定时器时间配置