精华内容
下载资源
问答
  • ssm整合quartz 并持久化到数据库中,实现动态增删改查,暂停任务,恢复任务等 将链接内的target文件直接放到项目ssmquartztest文件夹下 运行环境: jdk5+tomcat7+mysql+eclipse+maven lib jar包下载地址 地址1:...
  • SSM整合Quartz框架

    千次阅读 2018-06-07 09:44:03
    1.Quartz概述 Quartz是一款开源的优秀任务调度框架,易上手使用简单 运行环境 Quartz 可以运行嵌入在另一个独立式应用程序 Quartz 可以在应用程序服务器(或servlet容器)内被实例化,并且参与XA事务 Quartz 可以...

    1.Quartz概述

    Quartz是一款开源的优秀任务调度框架,易上手使用简单

    运行环境

    • Quartz 可以运行嵌入在另一个独立式应用程序
    • Quartz 可以在应用程序服务器(或servlet容器)内被实例化,并且参与XA事务
    • Quartz 可以作为一个独立的程序运行(其自己的Java虚拟机内),可以通过RMI使用
    • Quartz 可以被实例化,作为独立的项目集群(负载平衡和故障转移功能),用于作业的执行

    作业调度

    作业被安排在一个给定的触发时运行。触发器可以使用以下指令的接近任何组合来创建:

    • 在一天中的某个时间(到毫秒)
    • 在一周的某几天
    • 在每月的某一天
    • 在一年中的某些日期
    • 不在注册的日历中列出的特定日期(如商业节假日除外)
    • 重复特定次数
    • 重复进行,直到一个特定的时间/日期
    • 无限重复
    • 重复的延迟时间间隔 作业是由其创建者赋予的名字,也可以组织成命名组。触发器也可以给予名称和放置在组中,以方便地将它们调度内组织。作业可以被添加到所述调度器一次,而是具有多个触发器注册。在企业Java环境中,作业可以执行自己的工作作为分布式(XA)事务的一部分。

    作业执行

    • 作业可以实现简单的作业接口,为作业执行工作的任何Java类。
    • Job类的实例可以通过Quartz被实例化,或者通过应用程序框架。
    • 当触发时,调度通知实现JobListener和TriggerListener接口零个或多个Java对象(监听器可以是简单的Java对象,或EJB,JMS或发布者等)。这些监听器在作业已经执行之后通知。
    • 由于作业完成后返回JobCompletionCode,它通知的成功或失败的调度。JobCompletionCode还可以指示的基础上,成功的话就采取行动调度/失败的代码 - 如立即重新执行作业。

    作业持久性

    • Quartz的设计包括可被实现以提供的作业存储各种机制一个作业存储接口
    • 通过使用包含的JDBCJobStore,所有的作业和触发器配置为“非挥发性”都存储在通过JDBC关系数据库。
    • 通过使用包含的RAMJobStore,所有的作业和触发器存储在RAM,因此不计划执行仍然存在 - 但这是无需使用外部数据库的优势。

    事务

    • 可以参与JTA事务,通过使用JobStoreCMT(JDBCJobStore的子类)。 Quartz可以管理JTA事务(开始并提交它们)周围作业的执行,从而使作业执行的工作自动将JTA事务中发生。 集群 故障切换 负载均衡 Quartz的内置的群集功能,通过JDBCJobStore(如上所述)依靠数据库持久 Terracotta扩展Quartz提供集群功能,而不需要一个支持数据库 监听器和插件 应用程序可以捕捉事件的调度监控或通过实现一个或多个监听器接口控制工作/触发行为。 插件机制,可以用来添加功能,Quartz让作业执行过程中或工作负载和触发定义的历史不受限在一个文件中。 附带了一些“工厂建有”插件和监听器。

    Quartz核心组件

    组件描述
    Job

    是一个接口,只有一个方法void execute(JobExecutionContext context),开发者实现该接口定义运行任务,JobExecutionContext类提供了调度上下文的各种信息。Job运行时的信息保存在 JobDataMap实例中。

    JobDetail

    Quartz在每次执行Job时,都重新创建一个Job实例,所以它不直接接受一个Job的实例,相反它接收一个Job实现类,以便运行时通过newInstance()的反射机制实例化Job。因此需要通过一个类来描述Job的实现类及其它相关的静态信息,如Job名字、描述、关联监听器等信息,JobDetail承担了这一角色。

    Trigger

    是一个类,描述触发Job执行的时间触发规则。主要有SimpleTrigger和CronTrigger这两个子类。当仅需触发一次或者以固定时间间隔周期执行,SimpleTrigger是最适合的选择;而CronTrigger则可以通过Cron表达式定义出各种复杂时间规则的调度方案:如每早晨9:00执行,周一、周三、周五下午5:00执行等。

    Calendar

    org.quartz.Calendar和java.util.Calendar不同,它是一些日历特定时间点的集合(可以简单地将org.quartz.Calendar看作java.util.Calendar的集合——java.util.Calendar代表一个日历时间点,无特殊说明后面的Calendar即指org.quartz.Calendar)。一个Trigger可以和多个Calendar关联,以便排除或包含某些时间点。

    Scheduler

    代表一个Quartz的独立运行容器,Trigger和JobDetail可以注册到Scheduler中,两者在 Scheduler中拥有各自的组及名称,组及名称是Scheduler查找定位容器中某一对象的依据,Trigger的组及名称必须唯一,JobDetail的组和名称也必须唯一(但可以和Trigger的组和名称相同,因为它们是不同类型的)。Scheduler定义了多个接口方法,允许外部通过组及名称访问和控制容器中Trigger和JobDetail。

    ThreadPool

    Scheduler使用一个线程池作为任务运行的基础设施,任务通过共享线程池中的线程提高运行效率。

    JobDataMap

    是一个Map的实现,用于存储Job中所需用到的数据

    JobStore

    用于将Job和Trigger信息存储,以便Scheduler再次恢复使用。常用子类:JobStoreCMT, JobStoreTX,RAMJobStore

    2.持久化方式选择



     

    • JDBC方式持久化 

       

    3.配置文件applicationContext-qaurtz.xml的编写

     

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
           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.1.xsd
                            http://www.springframework.org/schema/context
                            http://www.springframework.org/schema/context/spring-context-3.1.xsd">
    
       <!-- =========JDBC版=========== -->
       <!--
           持久化数据配置,需要添加quartz.properties
        -->
       <bean id="quartzDataSource" class="org.apache.commons.dbcp.BasicDataSource">
          <property name="driverClassName" value="${quartz.driver}"/>
          <property name="url" value="${quartz.url}"/>
          <property name="username" value="${quartz.username}"/>
          <property name="password" value="${quartz.password}"/>
          <property name="initialSize" value="${quartz.initialSize}"/>
          <property name="maxActive" value="${quartz.maxActive}"/>
          <property name="maxIdle" value="${quartz.maxIdle}"/>
          <property name="minIdle" value="${quartz.minIdle}"/>
          <property name="maxWait" value="${quartz.maxWait}"/>
       </bean>
    
       <!-- spring对quartz的整合所提供的SchedulerFactory -->
       <bean name="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
          <property name="dataSource" ref="quartzDataSource"/>
          <property name="applicationContextSchedulerContextKey" value="applicationContextKey"/>
    
          <!-- configLocation属性,通过读取quartz.properties配置文件初始化Scheduler -->
          <property name="configLocation" value="classpath:properties/quartz.properties"/>
       </bean>
    </beans>
    

    4.配置文件Quartz.properties的编写

    # Default Properties file for use by StdSchedulerFactory
    # to create a Quartz Scheduler Instance, if a different
    # properties file is not explicitly specified.
    #
    
    #============================================================================
    # Configure Main Scheduler Properties   (Qaurtz调度器的主要属性配置)
    #============================================================================
    org.quartz.scheduler.instanceName: dufy_test
    org.quartz.scheduler.instanceId = AUTO
    
    org.quartz.scheduler.rmi.export: false
    org.quartz.scheduler.rmi.proxy: false
    org.quartz.scheduler.wrapJobExecutionInUserTransaction: false
    #============================================================================
    # Configure ThreadPool                  (Quartz的线程池配置)
    #============================================================================
    org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
    org.quartz.threadPool.threadCount: 1
    org.quartz.threadPool.threadPriority: 5
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true
    
    org.quartz.jobStore.misfireThreshold: 60000
    #============================================================================
    # Configure JobStore                    (Quartz任务存储的配置,采用jdbc持久化存储方式)
    #============================================================================
    
    #default config
    #org.quartz.jobStore.class: org.quartz.simpl.RAMJobStore
    #持久化配置
    org.quartz.jobStore.class:org.quartz.impl.jdbcjobstore.JobStoreTX
    org.quartz.jobStore.driverDelegateClass:org.quartz.impl.jdbcjobstore.PostgreSQLDelegate
    #org.quartz.jobStore.useProperties:true
    
    
    #数据库表前缀
    org.quartz.jobStore.tablePrefix:qrtz_
    #org.quartz.jobStore.dataSource:qzDS
    
    #============================================================================
    #havent cluster spring                  (Quartz集群配置,不采用集群方式)
    #============================================================================
    org.quartz.jobStore.isClustered = false
    
    #============================================================================
    # Configure Datasources                 (Quartz数据源的配置,无需配置独立的数据源,采用已配置的dbcp连接池)
    #============================================================================
    ##JDBC驱动
    #org.quartz.dataSource.qzDS.driver:org.postgresql.Driver
    #org.quartz.dataSource.qzDS.URL:jdbc:postgresql://127.0.0.1:5432/postgres
    #org.quartz.dataSource.qzDS.user:postgres
    #org.quartz.dataSource.qzDS.password:111
    #org.quartz.dataSource.qzDS.maxConnection:10
    

    5.Qaurtz的各种操作的使用示例

    (1)Qaurtz中Job的编写

    public class HelloWordJob implements Job {
    
        private static final Logger logger = LoggerFactory.getLogger(HelloWordJob.class);
    
        //execute()方法中为job所执行的任务逻辑
        @Override
        public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
            logger.info("This is a first spring combine quartz !");
            logger.info("Welcome to Spring_Quartz World!"+ new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) );
            logger.info("Let's begin ! \n \n");
        }
    }
    

    (2)新建添加任务

    //(1)创建JobDetail实例
    JobDetail jobDetail=JobBuilder.newJob(HelloWordJob.class)
            .withIdentity("job005","group005")
            .build();
    //(2)创建Trigger实例
    Trigger trigger=TriggerBuilder.newTrigger()
            .withIdentity("job005","group005")
            .startNow()
            .withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ? *"))
            .build();
    //(3)开启scheduler,执行任务,关闭scheduler
    scheduler.scheduleJob(jobDetail,trigger);
    scheduler.start();
    Thread.sleep(10*1000L);
    scheduler.shutdown(true);
    

    (3)将数据传送到任务

    JobDataMap jobDataMap=new JobDataMap();
    jobDataMap.put("name","Wu Menghao");
    //(1)创建JobDetail实例
    JobDetail jobDetail=JobBuilder.newJob(DataMapJob.class)
            .usingJobData(jobDataMap)
            .withIdentity("job001","group001")
            .build();
    //(2)创建Trigger实例
    Trigger trigger=TriggerBuilder.newTrigger()
            .withIdentity("trigger001","group001")
            .startNow()
            .withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ? *"))
            .build();
    //(3)开启scheduler,执行任务,关闭scheduler
    scheduler.scheduleJob(jobDetail,trigger);
    scheduler.start();
    Thread.sleep(10*1000L);
    scheduler.shutdown(true);
    

    (4)任务绑定多个触发器

    JobDataMap jobDataMap=new JobDataMap();
    jobDataMap.put("name","job002");
    //Job
    JobDetail jobDetail=JobBuilder.newJob(DataMapJob.class)
            .usingJobData(jobDataMap)
            .withIdentity("job002","group002")
            .build();
    //Triggers
    Set<Trigger> triggers=new HashSet<>();
    Trigger trigger1=TriggerBuilder.newTrigger()
            .withIdentity("trigger001","group002")
            .withSchedule(CronScheduleBuilder.cronSchedule("0/10 * * * * ? *"))
            .build();
    Trigger trigger2=TriggerBuilder.newTrigger()
            .withIdentity("trigger002","group002")
            .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ? *"))
            .build();
    triggers.add(trigger1);
    triggers.add(trigger2);
    //scheduleJob
    scheduler.scheduleJob(jobDetail,triggers,false);
    scheduler.start();
    Thread.sleep(60*1000L);
    scheduler.shutdown();
    

    (5)任务的暂停与恢复

    任务暂停后恢复,任务会继续按触发器的规则执行

    //暂停
    scheduler.pauseJob(JobKey.jobKey("job004","group004"));
    scheduler.pauseJob(JobKey.jobKey("job005","group005"));
    Thread.sleep(5*1000L);
    System.out.println("停止5s");
    
    //恢复(按照trigger执行)
    scheduler.resumeJob(JobKey.jobKey("job005","group005"));
    scheduler.start();
    Thread.sleep(60*1000L);
    scheduler.shutdown();
    

    (6)任务的暂停与立执行

    任务暂停后立即执行,任务仅执行一次

    //暂停
    scheduler.pauseJob(JobKey.jobKey("job004","group004"));
    scheduler.pauseJob(JobKey.jobKey("job005","group005"));
    Thread.sleep(5*1000L);
    System.out.println("停止5s");
    
    //立即执行(仅执行一次)
    scheduler.triggerJob(JobKey.jobKey("job005","group005"));
    scheduler.start();
    Thread.sleep(60*1000L);
    scheduler.shutdown();
    

    (7)任务的删除--暂停-解绑-删除

    TriggerKey triggerKey = TriggerKey.triggerKey("job003","group003");
    JobKey jobKey=JobKey.jobKey("job003","group003");
    //(1)暂停触发器
    scheduler.pauseTrigger(triggerKey);
    //(2)解除触发器
    scheduler.unscheduleJob(triggerKey);
    //(3)删除任务
    scheduler.deleteJob(jobKey);
    scheduler.shutdown();
    

    (8)任务的删除--直接删除

    JobKey jobKey=JobKey.jobKey("job002","group002");
    scheduler.deleteJob(jobKey);
    scheduler.shutdown();
    System.out.println(scheduler.isShutdown());
    Thread.sleep(60*1000L);
    

    (9)暂停触发器与暂停任务

    • 暂停触发器与暂停任务都能使任务暂停,都能通过resumeJobe()方法恢复

    • 一个任务可以绑定多个触发器,pauseTrigger只能暂停指定的Trigger,puaseJob可以暂停所有的Trigger

      @Test
      public void pauseTrigger() throws SchedulerException, InterruptedException {
          //暂停触发器
          scheduler.pauseTrigger(TriggerKey.triggerKey("trigger001","group002"));
          Thread.sleep(60*1000L);
      }
      
      @Test
      public void pauseJob() throws SchedulerException, InterruptedException {
          //暂停任务
          scheduler.pauseJob(JobKey.jobKey("job001","group001"));
          Thread.sleep(60*1000L);
          scheduler.shutdown();
      }
      

    (10)恢复所有任务

    @Test
    public void resumeAll() throws SchedulerException, InterruptedException {
        scheduler.resumeAll();
        Thread.sleep(60*1000L);
    }
    

    (11)暂停所有任务

    @Test
    public void pauseAll() throws SchedulerException, InterruptedException {
        scheduler.pauseAll();
        Thread.sleep(60*1000L);
    }
    

    (12)任务信息检出

    //GroupMatcher<JobKey>
    GroupMatcher<JobKey> matcher=GroupMatcher.anyJobGroup();
    //Set<JobKey>
    Set<JobKey> jobKeys = scheduler.getJobKeys(matcher);
    for (JobKey jobKey : jobKeys) {
        //List<Trigger>
        List<? extends Trigger> triggers=scheduler.getTriggersOfJob(jobKey);
        for (Trigger trigger : triggers) {
            System.out.println("Job:"+jobKey.getName()+"-- trigger:"+trigger.getStartTime()+"-- group:"+jobKey.getGroup());
        }
    }
    Thread.sleep(60*1000L);
    

    (13)查询正在运行的任务

    • 方法获取的不是打开状态的任务,而是正在执行的任务

      List<JobExecutionContext> contexts = scheduler.getCurrentlyExecutingJobs();
      System.out.println(contexts.size());
      if (CollectionUtils.isEmpty(contexts)){
          System.out.println("无正在运行的任务");
      }else {
          for (JobExecutionContext context:contexts) {
              //JobDetail
              JobDetail jobDetail = context.getJobDetail();
              //JobKey
              JobKey jobKey = jobDetail.getKey();
              //List<Trigger>
              List<? extends Trigger> triggers = scheduler.getTriggersOfJob(jobKey);
              for (Trigger trigger: triggers) {
                  System.out.println("Job:"+jobKey.getName()+"-- trigger:"+trigger.getStartTime()+"-- group:"+jobKey.getGroup());
              }
          }
      }
      

    (14)更新Trigger

        //TriggerKey
        TriggerKey triggerKey = TriggerKey.triggerKey("trigger001", "group002");
        //Trigger
        Trigger trigger = ((CronTrigger)scheduler.getTrigger(triggerKey))
                .getTriggerBuilder()
                .withIdentity(triggerKey)
                .withSchedule(CronScheduleBuilder.cronSchedule("0/5 * * * * ? *"))
                .build();
        //reschedulerJob
        scheduler.rescheduleJob(triggerKey,trigger);
        scheduler.resumeJob(JobKey.jobKey("job002","group002"));
        Thread.sleep(60*1000L);
    

     

    结束

     

    展开全文
  • ssm整合quartz 并持久化到数据库中,实现动态增删改查,暂停任务,恢复任务等 将链接内的target文件直接放到项目ssmquartztest文件夹下 运行环境: jdk5+tomcat7+mysql+eclipse+maven lib jar包下载
  • 该项目是简单的实现quartz持久化集成ssm的,实现定时任务,仅为本人学习的一个简单实例
  • Ssm整合quartz定时任务

    2020-12-08 21:54:26
    Ssm整合quartz定时任务 1.添加maven <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.2.0</version> </...

    Ssm整合quartz定时任务

    1.添加maven

       <dependency>
          <groupId>org.quartz-scheduler</groupId>
          <artifactId>quartz</artifactId>
          <version>2.2.0</version>
        </dependency>
    

    2.配置spring-quartz.xml文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd">
        <!-- 添加调度的任务bean 配置对应的类-->
        <bean id="myQuartz" class="com.athome.quarter.MyJob" />
        <!--配置调度具体执行的方法-->
        <bean id="myMethod" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
            <property name="targetObject" ref="myQuartz" /><!--将上面的任务bean myQuartz注入到这里-->
            <property name="targetMethod" value="runJob" />
            <!-- 使用Quartz做计划任务时,默认情况下,当前任务总会执行,无论前一个任务是否结束 -->
            <!-- 下面的concurrent属性默认为true,设置成false可以让任务按照顺序执行,上一个任务没有结束,下面的任务不会执行-->
            <property name="concurrent" value="false" />
        </bean>
        <!--配置调度执行的触发的时间-->
        <bean id="myTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
            <property name="jobDetail" ref="myMethod" />
            <property name="cronExpression">
                <!--每隔20秒执行一次-->
                <value>0/20 * * * * ?</value>
            </property>
      <!--
             0 0 2 * * ?    秒 分 时 天 月 日  每天凌晨2点
             */5 * * * * ?  每隔5秒执行一次
             0 */5 * * * ?  每隔5分钟执行一次
             0 30 0 * * ?   每天半夜12点30分执行一次
             0 15 10 ? * * 或 0 15 10 * * ? 每天上午10:15执行一次
             0 * 14 * * ?      每天14点到14:59分,每1分钟执行一次
             0 0-5 14 * * ?    每天14点到14:05分,每1分钟执行一次
             0 0 7-23 * * ?    每天7点到23点,每整点执行一次
             0 0 18,22 * * ?   每天18点、22点执行一次
             不全的话 自行百度。
            -->
        </bean>
        <!-- 
        quartz的调度工厂只能有一个,多个调度任务在list中添加 。
        bean中的id可能需要加上,之前我自己没加上导致启动到不知道触发器报错。不过也有看到没加上id也可以正常运作,可能是版本的原因吧。
        -->
        <bean id="schedulerFactory" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers">
                <list>
                    <ref bean="myTrigger" />
                </list>
            </property>
        </bean>
    </beans>
    
    

    3.把spring-quartz.xml加到applicationContext.xml

    <import resource="spring-quartz.xml" />
    

    4.将spring-quartz.xml加载在web.xml中

    <context-param>
      <param-name>contextConfigLocation</param-name>
      <param-value>
       classpath*:applicationContext.xml,
       classpath*:spring-quartz.xml
      </param-value>
    </context-param>
    

    5.编写对应的任务

    在com.athome.quarter.MyJob类中写一个方法,方法名叫runJob。

    类名和方法名要与spring-quartz.xml一一对应。

    package com.athome.quarter;
    
    import java.text.SimpleDateFormat;
    import java.util.Date;
    
    public class MyJob {
        public void runJob(){
            System.out.println("现在的时间是:"+new SimpleDateFormat("yyyy-MM-dd:HH:mm:ss").format(new Date()));
        }
    }
    
    

    结果:

    2020-12-08 21:50:00,000 23106  [SchedulerThread] DEBUG rtz.core.QuartzSchedulerThread  - batch acquisition of 0 triggers
    2020-12-08 21:50:00,000 23106  [actory_Worker-2] DEBUG    org.quartz.core.JobRunShell  - Calling execute on job DEFAULT.myMethod
    现在的时间是:2020-12-08:21:50:00
    2020-12-08 21:50:00,005 23111  [SchedulerThread] DEBUG rtz.core.QuartzSchedulerThread  - batch acquisition of 1 triggers
    2020-12-08 21:50:20,001 43107  [SchedulerThread] DEBUG rtz.core.QuartzSchedulerThread  - batch acquisition of 0 triggers
    2020-12-08 21:50:20,001 43107  [actory_Worker-3] DEBUG    org.quartz.core.JobRunShell  - Calling execute on job DEFAULT.myMethod
    现在的时间是:2020-12-08:21:50:20
    2020-12-08 21:50:20,001 43107  [SchedulerThread] DEBUG rtz.core.QuartzSchedulerThread  - batch acquisition of 1 triggers
    
    展开全文
  • SSM整合Quartz

    2021-11-24 09:36:49
    整合1.1 mysql中创建quartz表1.2 添加quartz依赖1.3 添加quartz.properties1.4 编写quartzConfig文件1.4.1 quartz的初始化配置1.4.2 创建job 实例工厂1.5 编写定时任务1.5.1 静态方式编写定时任务1.5.2 动态方式编写...

    整合步骤:
    1.在数据库中添加quartz的表
    2.pom.xml文件中添加依赖
    3.添加quartz.properties的配置
    4.编写quartzConfig文件
    5.编写定时任务
    

    1.整合

    1.1 mysql中创建quartz表

    #
    # Quartz seems to work best with the driver mm.mysql-2.0.7-bin.jar
    #
    # PLEASE consider using mysql with innodb tables to avoid locking issues
    #
    # In your Quartz properties file, you'll need to set 
    # org.quartz.jobStore.driverDelegateClass = org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    #
    
    DROP TABLE IF EXISTS QRTZ_FIRED_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_PAUSED_TRIGGER_GRPS;
    DROP TABLE IF EXISTS QRTZ_SCHEDULER_STATE;
    DROP TABLE IF EXISTS QRTZ_LOCKS;
    DROP TABLE IF EXISTS QRTZ_SIMPLE_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_SIMPROP_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_CRON_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_BLOB_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_TRIGGERS;
    DROP TABLE IF EXISTS QRTZ_JOB_DETAILS;
    DROP TABLE IF EXISTS QRTZ_CALENDARS;
    
    
    CREATE TABLE QRTZ_JOB_DETAILS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        JOB_NAME  VARCHAR(200) NOT NULL,
        JOB_GROUP VARCHAR(200) NOT NULL,
        DESCRIPTION VARCHAR(250) NULL,
        JOB_CLASS_NAME   VARCHAR(250) NOT NULL,
        IS_DURABLE VARCHAR(1) NOT NULL,
        IS_NONCONCURRENT VARCHAR(1) NOT NULL,
        IS_UPDATE_DATA VARCHAR(1) NOT NULL,
        REQUESTS_RECOVERY VARCHAR(1) NOT NULL,
        JOB_DATA BLOB NULL,
        PRIMARY KEY (SCHED_NAME,JOB_NAME,JOB_GROUP)
    );
    
    CREATE TABLE QRTZ_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        JOB_NAME  VARCHAR(200) NOT NULL,
        JOB_GROUP VARCHAR(200) NOT NULL,
        DESCRIPTION VARCHAR(250) NULL,
        NEXT_FIRE_TIME BIGINT(13) NULL,
        PREV_FIRE_TIME BIGINT(13) NULL,
        PRIORITY INTEGER NULL,
        TRIGGER_STATE VARCHAR(16) NOT NULL,
        TRIGGER_TYPE VARCHAR(8) NOT NULL,
        START_TIME BIGINT(13) NOT NULL,
        END_TIME BIGINT(13) NULL,
        CALENDAR_NAME VARCHAR(200) NULL,
        MISFIRE_INSTR SMALLINT(2) NULL,
        JOB_DATA BLOB NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        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 VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        REPEAT_COUNT BIGINT(7) NOT NULL,
        REPEAT_INTERVAL BIGINT(12) NOT NULL,
        TIMES_TRIGGERED BIGINT(10) NOT NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
            REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_CRON_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        CRON_EXPRESSION VARCHAR(200) NOT NULL,
        TIME_ZONE_ID VARCHAR(80),
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
            REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_SIMPROP_TRIGGERS
      (          
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        STR_PROP_1 VARCHAR(512) NULL,
        STR_PROP_2 VARCHAR(512) NULL,
        STR_PROP_3 VARCHAR(512) NULL,
        INT_PROP_1 INT NULL,
        INT_PROP_2 INT NULL,
        LONG_PROP_1 BIGINT NULL,
        LONG_PROP_2 BIGINT NULL,
        DEC_PROP_1 NUMERIC(13,4) NULL,
        DEC_PROP_2 NUMERIC(13,4) NULL,
        BOOL_PROP_1 VARCHAR(1) NULL,
        BOOL_PROP_2 VARCHAR(1) NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP) 
        REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_BLOB_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        BLOB_DATA BLOB NULL,
        PRIMARY KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP),
        FOREIGN KEY (SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
            REFERENCES QRTZ_TRIGGERS(SCHED_NAME,TRIGGER_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_CALENDARS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        CALENDAR_NAME  VARCHAR(200) NOT NULL,
        CALENDAR BLOB NOT NULL,
        PRIMARY KEY (SCHED_NAME,CALENDAR_NAME)
    );
    
    CREATE TABLE QRTZ_PAUSED_TRIGGER_GRPS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        TRIGGER_GROUP  VARCHAR(200) NOT NULL, 
        PRIMARY KEY (SCHED_NAME,TRIGGER_GROUP)
    );
    
    CREATE TABLE QRTZ_FIRED_TRIGGERS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        ENTRY_ID VARCHAR(95) NOT NULL,
        TRIGGER_NAME VARCHAR(200) NOT NULL,
        TRIGGER_GROUP VARCHAR(200) NOT NULL,
        INSTANCE_NAME VARCHAR(200) NOT NULL,
        FIRED_TIME BIGINT(13) NOT NULL,
        SCHED_TIME BIGINT(13) NOT NULL,
        PRIORITY INTEGER NOT NULL,
        STATE VARCHAR(16) NOT NULL,
        JOB_NAME VARCHAR(200) NULL,
        JOB_GROUP VARCHAR(200) NULL,
        IS_NONCONCURRENT VARCHAR(1) NULL,
        REQUESTS_RECOVERY VARCHAR(1) NULL,
        PRIMARY KEY (SCHED_NAME,ENTRY_ID)
    );
    
    CREATE TABLE QRTZ_SCHEDULER_STATE
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        INSTANCE_NAME VARCHAR(200) NOT NULL,
        LAST_CHECKIN_TIME BIGINT(13) NOT NULL,
        CHECKIN_INTERVAL BIGINT(13) NOT NULL,
        PRIMARY KEY (SCHED_NAME,INSTANCE_NAME)
    );
    
    CREATE TABLE QRTZ_LOCKS
      (
        SCHED_NAME VARCHAR(120) NOT NULL,
        LOCK_NAME  VARCHAR(40) NOT NULL, 
        PRIMARY KEY (SCHED_NAME,LOCK_NAME)
    );
    
    
    commit;
    

    1.2 添加quartz依赖

            <!--quartz-->
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.3</version>
                <exclusions>
                    <exclusion>
                        <artifactId>slf4j-api</artifactId>
                        <groupId>org.slf4j</groupId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz-jobs</artifactId>
                <version>2.2.3</version>
                <exclusions>
                    <exclusion>
                        <artifactId>slf4j-api</artifactId>
                        <groupId>org.slf4j</groupId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
            </dependency>
    

    1.3 添加quartz.properties

    org.quartz.scheduler.instanceName=quartzScheduler
    org.quartz.scheduler.instanceId=AUTO
    org.quartz.scheduler.rmi.export=false
    org.quartz.scheduler.rmi.proxy=false
    org.quartz.scheduler.wrapJobExecutionInUserTransaction=false
    org.quartz.jobStore.misfireThreshold=50000
    org.quartz.jobStore.class=org.quartz.impl.jdbcjobstore.JobStoreTX
    org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate
    org.quartz.jobStore.tablePrefix=QRTZ_
    org.quartz.jobStore.isClustered=true
    org.quartz.jobStore.useProperties=false
    org.quartz.jobStore.clusterCheckinInterval=20000
    org.quartz.threadPool.class=org.quartz.simpl.SimpleThreadPool
    org.quartz.threadPool.threadCount=10
    org.quartz.threadPool.threadPriority=5
    org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread=true
    

    1.4 编写quartzConfig文件

    1.4.1 quartz的初始化配置

    package com.fii.gac.web.config;
    
    import java.io.IOException;
    import java.util.Properties;
    
    import javax.sql.DataSource;
    
    import lombok.RequiredArgsConstructor;
    import org.springframework.beans.factory.config.PropertiesFactoryBean;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.io.ClassPathResource;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    
    /**
     * quartz的初始化配置
     * @author Administrator
     *
     */
    @Configuration
    @RequiredArgsConstructor
    public class QuartzConfiguration {
    	
    	private final QuartzJobFactory quartzJobFactory;
    
    	private final DataSource dataSource;
    
        @Bean(name = "schedulerFactoryBean")
    	public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
            //获取配置属性
            PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();
            propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));
            //在quartz.properties中的属性被读取并注入后再初始化对象
            propertiesFactoryBean.afterPropertiesSet();
            //创建SchedulerFactoryBean
            SchedulerFactoryBean factory = new SchedulerFactoryBean();
            Properties pro = propertiesFactoryBean.getObject();
            //覆盖已存在的任务
            factory.setOverwriteExistingJobs(true);
            // 设置自动启动
            factory.setAutoStartup(true);
            // 设置延迟10s启动
            factory.setStartupDelay(10);
            if (pro != null) {
                factory.setQuartzProperties(pro);
            }
            factory.setJobFactory(quartzJobFactory);
            factory.setDataSource(dataSource);
            return factory;
        }
    }
    
    

    1.4.2 创建job 实例工厂

    package com.fii.gac.web.config;
    
    import org.quartz.spi.TriggerFiredBundle;
    import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.scheduling.quartz.SpringBeanJobFactory;
    import org.springframework.stereotype.Component;
    
    /**
     * 创建job 实例工厂,解决spring注入问题,如果使用默认会导致spring的@Autowired 无法注入问题(很重要)
     * @author Administrator
     *
     */
    @Component
    public class QuartzJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {
    
    	private transient AutowireCapableBeanFactory beanFactory;
    
        @Override
        public void setApplicationContext(final ApplicationContext context) {
            beanFactory = context.getAutowireCapableBeanFactory();
        }
    
        @Override
        protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
            final Object job = super.createJobInstance(bundle);
            beanFactory.autowireBean(job);
            return job;
        }
    	
    }
    
    

    1.5 编写定时任务

    1.5.1 静态方式编写定时任务

     /**
         * 静态方式配置定时任务
         *
         * @param jobDetail
         * @return
         */
        @Bean
        public CronTriggerFactoryBean simpleJobTrigger(
                @Qualifier("simpleJobDetail") JobDetail jobDetail) {
            CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
    
            factoryBean.setJobDetail(jobDetail);
            factoryBean.setStartDelay(1000L);
            factoryBean.setName("trigger2");
            factoryBean.setGroup("group1");
            //周1至周5,每天上午8点至下午18点,每分钟执行一次
            factoryBean.setCronExpression("0 0/1 8-18 ? * 2-6");
    
            return factoryBean;
        }
    
        @Bean
        public JobDetailFactoryBean simpleJobDetail() {
            JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
    
            factoryBean.setJobClass(ScheduledJob.class);
            factoryBean.setGroup("group1");
            factoryBean.setName("job4");
    
            return factoryBean;
        }
    
    

    执行结果:
    执行结果

    1.5.2 动态方式编写定时任务

    代码不全,只是为了展示编写方法

    public void execute(JobExecutionContext context) throws JobExecutionException {
            preExecute(context);
            try {
                executeWrapper(context);
                setStatus(1);
            } catch (Exception e) {
                setStatus(0);
                String exceptionString = Exceptions.getStackTrace(e);
                addDescription(exceptionString);
                log.error(exceptionString);
    
            }
            postExecute(context);
            clearAll();
        }
    
        protected void preExecute(JobExecutionContext context) {
            initThreadLocal();
            try {
                LocalDateTime now = LocalDateTime.now();
                JobKey jobKey = context.getJobDetail().getKey();
                JobDataMap jobDataMap = context.getMergedJobDataMap();
                String jobName = jobKey.getName();
                String jobGroup = jobKey.getGroup();
    
                // 更状态
                QuartzJobDetailPO jobDetailPO = quartzJobDetailMapper.findByGroupAndName(jobGroup, jobName);
                jobDetailPO.setStatus(1);
                quartzJobDetailMapper.updateById(jobDetailPO);
    
                jobDataMap.put("startTime", now);
                log.info("jobGroup: {}, jobName: {}, startTime: {}", jobGroup, jobName, DateTimes.dateTimeToString(now));
            } catch (Exception e) {
                log.error(Exceptions.getStackTrace(e));
            }
        }
    
        protected void postExecute(JobExecutionContext context) {
            try {
                LocalDateTime now = LocalDateTime.now();
                JobKey jobKey = context.getJobDetail().getKey();
                JobDataMap jobDataMap = context.getMergedJobDataMap();
                String jobName = jobKey.getName();
                String jobGroup = jobKey.getGroup();
                LocalDateTime startTime = (LocalDateTime) jobDataMap.get("startTime");
                int executeTime = (int) startTime.until(now, ChronoUnit.SECONDS);
    
                LoadDataJobResult result = LOAD_DATA_JOB_RESULT_THREAD_LOCAL.get();
    
                // 更新状态
                QuartzJobDetailPO jobDetailPO = quartzJobDetailMapper.findByGroupAndName(jobGroup, jobName);
                jobDetailPO.setLastRunResult(result.getStatus());
                jobDetailPO.setLastRunTime(startTime);
                jobDetailPO.setNextRunTime(Quartzs.getCronNextRunTime(jobDetailPO.getCronExpression()));
                jobDetailPO.setStatus(2);
                quartzJobDetailMapper.updateById(jobDetailPO);
    
                quartzJobLogMapper.insert(QuartzJobLogPO.builder()
                        .jobGroup(jobGroup)
                        .jobName(jobName)
                        .status(result.getStatus())
                        .description(result.getStatus() == 1 ? Jsons.objectToJson(result) : result.getDescription())
                        .executeTime(executeTime)
                        .addTime(now)
                        .build());
    
                log.info("jobGroup: {}, jobName: {}, endTime: {}, 耗时: {}", jobGroup, jobName,
                        DateTimes.dateTimeToString(now),
                        executeTime);
            }catch (Exception e) {
                log.error(Exceptions.getStackTrace(e));
            }
        }
    

    2.quartz

    2.1 quartz概念

    Quartz是一个开源的任务调度框架。基于定时、定期的策略来执行任务是它的核心功能,可以用来创建简单或运行十个,百个,甚至是好几万个Jobs这样复杂的程序。quartz官网

    2.2 quartz核心要素

    Quartz有3个核心要素:调度器(Scheduler)、任务(Job)、触发器(Trigger)。

    2.2.1 要素关系

    quartz体系结构

    2.2.2 要素作用

    Job(任务):是一个接口,有一个方法void execute(),可以通过实现该接口来定义需要执行的任务(具体的逻辑代码)。
    
    Trigger(触发器):描述触发Job执行的时间触发规则实现类SimpleTrigger和CronTrigger可以通过crom表达式定义出各种复杂的调度方案。
    
    Scheduler(调度器):代表一个Quartz的独立运行容器。Trigger和JobDetail可以注册到Scheduler中。Scheduler可以将Trigger绑定到某一JobDetail上,这样当Trigger被触发时,对应的Job就会执行。一个Job可以对应多个Trigger,但一个Trigger只能对应一个Job.
    
    

    补充说明

    JobDetail:Quartz每次执行job时,都重新创建一个Job实例,会接收一个Job实现类,以便运行的时候通过newInstance()的反射调用机制去实例化Job.JobDetail是用来描述Job实现类以及相关静态信息,比如任务在scheduler中的组名等信息。
    
    Calendar:是一些日历特定时间的集合。一个Trigger可以和多个 calendar关联,比如每周一早上10:00执行任务,法定假日不执行,则可以通过calendar进行定点排除。
    

    2.3 quartz优点

    Quartz提供了极为广泛的特性如持久化任务,集群和分布式任务等,其特点如下:

    完全由Java写成,方便集成(Spring)
    伸缩性
    负载均衡
    高可用性

    2.4 quartz数据表

    2.4.1 数据表获取路径

    quartz数据表的获取路径: 官网—>官网下载quartz---->quartz-2.2.3-distribution.tar\quartz-2.2.3\docs\dbTables

    多种数据表文件
    数据库文件

    2.4.1 数据表的作用

    QRTZ_CALENDARS 以 Blob 类型存储 Quartz 的 Calendar 信息 
    
    QRTZ_CRON_TRIGGERS 存储 Cron Trigger,包括 Cron表达式和时区信息 
    
    QRTZ_FIRED_TRIGGERS 存储与已触发的 Trigger 相关的状态信息,以及相联 Job的执行信息 QRTZ_PAUSED_TRIGGER_GRPS 存储已暂停的 Trigger 组的信息 
    
    QRTZ_SCHEDULER_STATE 存储少许的有关 Scheduler 的状态信息,和别的 Scheduler实例(假如是用于一个集群中) 对象
    
    QRTZ_LOCKS 存储程序的悲观锁的信息(假如使用了悲观锁) 
    
    QRTZ_JOB_DETAILS 存储每个已配置的 Job 的详细信息 
    
    QRTZ_JOB_LISTENERS 存储有关已配置的 JobListener 的信息 
    
    QRTZ_SIMPLE_TRIGGERS 存储简单的Trigger,包括重复次数,间隔,以及已触的次数 
    
    QRTZ_BLOG_TRIGGERS Trigger 做为 Blob 类型存储(用于 Quartz 用户用 JDBC建立他们本身定制的 Trigger 类型,JobStore 并不知道如何存储实例的时候) 集群
    
    QRTZ_TRIGGER_LISTENERS 存储已配置的 TriggerListener 的信息 配置
    
    QRTZ_TRIGGERS 存储已配置的 Trigger 的信息 
    

    2.5 cron表达式

    cron表达式支持到七个,其中参数如下:
    在这里插入图片描述
    字符表达的意思

    1)* 星号
    使用星号(*) 指示着你想在这个域上包含所有合法的值,在你希望 trigger 在该域的所有有效值上被激发时使用 * 字符。例如,在月份域上使用星号意味着每个月都会触发这个 trigger。
    
      表达式样例:0 * 17 * * ? 
    意义:每天从下午5点到下午5:59中的每分钟激发一次 trigger。它停在下午 5:59 是因为值 17 在小时域上,在下午 6 点时,小时变为 18 了,也就不再理会这个 trigger,直到下一天的下午5点。 
    
    
    2)? 问号 
    
    ? 号只能用在日和周域上,但是不能在这两个域上同时使用。你可以认为 ? 字符是 "我并不关心在该域上是什么值。" 这不同于星号,星号是指示着该域上的每一个值。? 是说不为该域指定值。你为这两域的其中一个指定了值,那就必须在另一个字值上放一个 ?。
    不能同时这两个域上指定值的理由是难以解释甚至是难以理解的。基本上,假定同时指定值的话,意义就会变得含混不清了:考虑一下,如果一个表达式在日域上有值11,同时在周域上指定了 WED。那么是要 trigger 仅在每个月的11号,且正好又是星期三那天被激发?还是在每个星期三的11号被激发呢?要去除这种不明确性的办法就是不能同时在这两个域上指定值。 
    
        表达式样例:0 10,44 14 ? 3 WEB 
    意义:在三月中的每个星期三的下午 2:10 和 下午 2:44 被触发。
    
    3), 逗号 
    逗号 (,) 是用来在给某个域上指定一个值列表的。例如,使用值 0,15,30,45 在秒域上意味着每15秒触发一个 trigger。
    
    表达式样例: 0 0,15,30,45 * * * ? 
    意义:每刻钟触发一次 trigger。
    
    4)/ 斜杠 
    
    斜杠 (/) 是用于时间表的递增的。我们刚刚用了逗号来表示每15分钟的递增,但是我们也能写成这样 0/15。 
    
    表达式样例: 0/15 0/30 * * * ? 
    意义:在整点和半点时每15秒触发 trigger。
    
    5)- 中划线 
    
    中划线 (-) 用于指定一个范围。例如,在小时域上的 3-8 意味着 "3,4,5,6,7 和 8 点。"  域的值不允许回卷,所以像 50-10 这样的值是不允许的。 
    
    表达式样例:0 45 3-8 ? * * 
    意义:在上午的3点至上午的8点的45分时触发 trigger。
    
    6)L 字母
    L 说明了某域上允许的最后一个值。它仅被日和周域支持。当用在日域上,表示的是在月域上指定的月份的最后一天。例如,当月域上指定了 JAN 时,在日域上的 L 会促使 trigger 在1月31号被触发。假如月域上是 SEP,那么 L 会预示着在9月30号触发。换句话说,就是不管指定了哪个月,都是在相应月份的时最后一天触发 trigger。
    
    表达式 0 0 8 L * ? 
    意义是在每个月最后一天的上午 8:00 触发 trigger。在月域上的 * 说明是 "每个月"。 
    
    当 L 字母用于周域上,指示着周的最后一天,就是星期六 (或者数字7)。所以如果你需要在每个月的最后一个星期六下午的 11:59 触发 trigger,你可以用这样的表达式 0 59 23 ? * L。 
    当使用于周域上,你可以用一个数字与 L 连起来表示月份的最后一个星期 X。例如,表达式 0 0 12 ? * 2L 说的是在每个月的最后一个星期一触发 trigger。
    不要让范围和列表值与 L 连用。虽然你能用星期数(1-7)与 L 连用,但是不允许你用一个范围值和列表值与 L 连用。这会产生不可预知的结果。
    
    7)W 字母 
    W 字符代表着*日 (Mon-Fri),并且仅能用于日域中。它用来指定离指定日的最*的一个*日。大部分的商业处理都是基于工作周的,所以 W 字符可能是非常重要的。例如,日域中的 15W 意味着 "离该月15号的最*一个*日。" 假如15号是星期六,那么 trigger 会在14号(星期四)触发,因为距15号最*的是星期一,这个例子中也会是17号(译者Unmi注:不会在17号触发的,如果是15W,可能会是在14号(15号是星期六)或者15号(15号是星期天)触发,也就是只能出现在邻*的一天,如果15号当天为*日直接就会当日执行)。W 只能用在指定的日域为单天,不能是范围或列表值。 
    
    8)井号
    
    井号字符仅能用于周域中。它用于指定月份中的第几周的哪一天。例如,如果你指定周域的值为 6#3,它意思是某月的第三个周五 (6=星期五,#3意味着月份中的第三周)。另一个例子 2#1 意思是某月的第一个星期一 (2=星期一,#1意味着月份中的第一周)。注意,假如你指定 #5,然而月份中没有第 5 周,那么该月不会触发。
    

    例子:

    表达式意义
    
    "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 ? 3WED" 每年三月的星期三的下午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 ? * 6L2002-2005" 2002年至2005年的每月的最后一个星期五上午10:15触发
    
    "0 15 10 ? *6#3" 每月的第三个星期五上午10:15触发
    

    3.参考文章

    https://blog.csdn.net/chenmingxu438521/article/details/94485695
    https://www.cnblogs.com/zhaobingqing/p/7449474.html
    http://www.javashuo.com/article/p-dxpgfazn-bt.html

    展开全文
  • ssm整合quartz定时器

    2020-01-21 09:23:50
    第一步:编写spring-quratz.xml文件 < ? xml version = "1.0" encoding ......jar包:quartz-2.3.0.jar,spring-context-support-5.2.2.RELEASE.jar,slf4j-api-2.0.0-alpha1.jar

    第一步:编写spring-quratz.xml文件

    <?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans 
           http://www.springframework.org/schema/beans/spring-beans.xsd">
        
        <!-- 添加调度的任务bean 配置对应的类-->
        <bean id="autoAttendance" class="com.topcheer.quartz.AutoAttendance" />
        
        <!--配置调度具体执行的方法-->
        <bean id="autoAttendanceDetail" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
            <property name="targetObject" ref="autoAttendance" />
    		<property name="targetMethod" value="execute" />
    		<!-- 使用Quartz做计划任务时,默认情况下,当前任务总会执行,无论前一个任务是否结束 -->
    		<!-- 下面的concurrent属性默认为true,设置成false可以让任务按照顺序执行,上一个任务没有结束,下面的任务不会执行-->
    		<property name="concurrent" value="false" />
        </bean>
        
        <!--配置调度执行的触发的时间-->
        <bean id="autoAttendanceTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
            <property name="jobDetail" ref="autoAttendanceDetail" />
            <property name="cronExpression">
            	<!--每周六和周日下午六点执行一次,给每人添加一条空的考勤-->
                <value>0 30 17 ? * 1,7 </value>
            </property>
        </bean>
        
        <!-- quartz的调度工厂只能有一个,多个调度任务在list中添加 -->
        <bean class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers">
                <list>
                    <ref bean="autoAttendanceTrigger" />
                </list>
            </property>
        </bean>
    </beans>
    
    

    第二步:编写工作类

    package com.topcheer.quartz;
    
    public class AutoAttendance{
    	public void execute() {
    		System.out.println("定时器执行");	
    	}
    }
    

    第三步:将spring-quratz.xml导入到springmvc.xml文件中

    <import resource="spring-quartz.xml" />
    

    jar包:quartz-2.3.0.jar,spring-context-support-5.2.2.RELEASE.jar,slf4j-api-2.0.0-alpha1.jar

    展开全文
  • SSM整合Quartz(八)

    2020-04-30 16:01:33
    > 勿以恶小而为之,勿以善小而不为--------------------------刘备 > 劝诸君,多行善事积福报,莫作恶 主要内容: SSM整合 Quartz, 解决 userService对象注入的问题
  • ssm整合quartz定时任务

    2019-02-13 13:53:08
    参考文档:https://blog.csdn.net/qq_33678647/article/details/81285908 1.添加jar包(2个)  &lt;!-- 定时器jar --&gt; ...org.quartz-scheduler&lt;/groupId&gt;  &lt...
  • Quartz是Java领域最著名的开源任务调度工具,是一个任务调度框架,通过触发器设置作业的定时运行规则,来执行定时任务。在项目中使用频繁,本文将在SSM整合项目上整合Quartz框架实现任务调度。
  • maven依赖 <dependency> ...org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>2.2.2</version> </dependency> sprin...
  • ssm-springMVC-整合Quartz(解决了无法注入service问题)-项目示例
  • -- quartz--&gt; &lt;dependency&gt; &lt;groupId&gt;org.quartz-scheduler&lt;/groupId&gt; &lt;artifactId&gt;quartz&lt;/artifactId&gt; &lt;ver...
  • 代码下载: http://download.csdn.net/detail/bird73/9859199第1章 ssm 整合 quartz (解决了无法注入service问题)1.1.2 简单项目整合流程 1. 导入jar包log4j-1.2.17.jar spring-beans-3.2.0.RELEASE.jar ...
  • org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> <version>${quartz.version}</version> //2.2.2 </dependency> 2.创建spring-task xml文件 <?

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,612
精华内容 644
关键字:

ssm整合quartz