精华内容
下载资源
问答
  • Quartz是一个定时任务框架,其他介绍网上也很详尽。这里要介绍一下Quartz里的几个非常核心的接口。通过实例代码给大家讲解SpringBoot集成Quartz实现定时任务的方法,感兴趣的朋友一起看看吧
  • Quartz.net作业调度自定义定时执行任务多任务执行c#,定时执行任务,如超时取消订单,自动确认收货等等
  • 首先在开篇前,先放一Springboot简单使用定时器的文章:https://blog.csdn.net/qq_35387940/article/details/82800403 以上这篇其实已经满足了大多数的情形,而且是...jobDetail 任务实例 定时任务执行的具体内容...

    首先在开篇前,先放一个Springboot简单使用定时器的文章:
    https://blog.csdn.net/qq_35387940/article/details/82800403

    那当然还有一篇稍微高级点的,动态调度:

    https://mp.csdn.net/console/editor/html/107038022 

     

     

    现在这篇是比较传统一点的,手动配置的方式:
    定时任务配置包括  :    

    jobDetail 任务实例     定时任务执行的具体内容等 -相关业务代码    

    trigger 触发器     设置相关的运行周期等    -绑定任务实例      (这篇文章会介绍包括两种触发器,简单的以及设置cron的)

    scheduler 调度器     决定哪些定时任务会执行  -绑定触发器 

     

     

    OK,接下来我们开始。

    首先是导入Quartz定时器会用到的相关依赖包:

            <!-- scheduled所属资源为spring-context-support,在Spring中对Quartz的支持,是集成在spring-context-support包中。
             org.springframework.scheduling.quartz
          -->
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
            </dependency>
            <!-- Quartz坐标 -->
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.1</version>
                <!-- Quartz默认需要slf4j支持。springboot中,提供了更高版本的slf4j -->
                <exclusions>
                    <exclusion>
                        <artifactId>slf4j-api</artifactId>
                        <groupId>org.slf4j</groupId>
                    </exclusion>
                </exclusions>
            </dependency>
    

    然后看下我们这次的实践里整体需要弄得几个文件:

    创建第一个定时任务的实例,TaskJobOne.class  :   (注意这里的@EnableScheduling 别忘记了)

    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.stereotype.Component;
    import java.util.Date;
    import static java.lang.Thread.sleep;
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/3/9
     * @Description :
     **/
    @Component
    @EnableScheduling
    public class TaskJobOne {
    
    
        public  void testJobOneMethod() throws InterruptedException {
            System.out.println("1  定时任务1正在执行......"+new Date());
            sleep(1000);
    
            System.out.println("1  定时任务1业务代码执行完毕......"+new Date());
        }
    }

     然后是创建多个,也就是第二个定时任务的实例,TaskJobTwo.class: (注意这里的@EnableScheduling 别忘记了)

    import org.springframework.scheduling.annotation.EnableScheduling;
    import org.springframework.stereotype.Component;
    import java.util.Date;
    import static java.lang.Thread.sleep;
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/3/9
     * @Description :
     **/
    
    @Component
    @EnableScheduling
    public class TaskJobTwo {
    
    
        public  void testJobTwoMethod() throws InterruptedException {
            System.out.println("2  定时任务2正在执行......" + new Date());
            sleep(1000);
    
            System.out.println("2  定时任务2业务代码执行完毕......"+new Date());
        }
        
    }

     

    然后是给这些任务实例绑定触发器,然后将触发器加入到调度工厂里:

    创建 QuartzConfiguration.class:

    (注意看每一步的注释,或者看后面我的简要要点描述!)

    import com.demo.elegant.quartz.taskOne.TaskJobOne;
    import com.demo.elegant.quartz.taskTwo.TaskJobTwo;
    import org.quartz.JobDetail;
    import org.quartz.Trigger;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
    import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;
    import java.util.Date;
    
    /**
     * @Author : JCccc
     * @CreateTime : 2020/3/9
     * @Description :
     **/
    
    @Configuration
    public class QuartzConfiguration {
    
    
    
    
    /*
    定时任务配置包括  :
        jobDetail 任务实例
        定时任务执行的具体内容等 -相关业务代码
        trigger 触发器
        设置相关的运行周期等    -绑定任务实例
        scheduler 调度器
        决定哪些定时任务会执行  -绑定触发器
    */
    
        /**
         * 定时任务 1
         */
    
        // 配置定时任务1的任务实例
        @Bean(name = "firstJobDetail")
    
        public MethodInvokingJobDetailFactoryBean firstJobDetail(TaskJobOne taskJobOne) {
            MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
            // 是否并发执行
            jobDetail.setConcurrent(false);
            // 为需要执行的实体类对应的对象
            jobDetail.setTargetObject(taskJobOne);
            // 需要执行的方法
            jobDetail.setTargetMethod("testJobOneMethod");
            return jobDetail;
        }
    
    
        // 配置触发器1
        @Bean(name = "firstTrigger")
        public SimpleTriggerFactoryBean firstTrigger(JobDetail firstJobDetail) {
            SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
            trigger.setJobDetail(firstJobDetail);
            // 设置任务启动延迟
            trigger.setStartDelay(0);
            // 设置定时任务启动时间
            trigger.setStartTime(new Date());
            // 每5秒执行一次
            trigger.setRepeatInterval(5000);
            return trigger;
        }
    
    
        /**
         * 定时任务 2
         *
         * @param taskJobTwo
         * @return
         */
    
        // 配置定时任务2的任务实例
        @Bean(name = "secondJobDetail")
        public MethodInvokingJobDetailFactoryBean secondJobDetail(TaskJobTwo taskJobTwo) {
            MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
            // 是否并发执行
            jobDetail.setConcurrent(true);
            // 为需要执行的实体类对应的对象
            jobDetail.setTargetObject(taskJobTwo);
            // 需要执行的方法
            jobDetail.setTargetMethod("testJobTwoMethod");
            return jobDetail;
        }
    
        // 配置触发器2
        @Bean(name = "secondTrigger")
        public CronTriggerFactoryBean secondTrigger(JobDetail secondJobDetail) {
            CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
            trigger.setJobDetail(secondJobDetail);
            // 设置定时任务启动时间
            trigger.setStartTime(new Date());
            // cron表达式
            trigger.setCronExpression("*/7 * * * * ?");
            return trigger;
        }
    
    
        // 配置Scheduler
        @Bean(name = "scheduler")
        public SchedulerFactoryBean schedulerFactory(Trigger firstTrigger, Trigger secondTrigger) {
            SchedulerFactoryBean bean = new SchedulerFactoryBean();
            // 延时启动,应用启动1秒后
            bean.setStartupDelay(1);
            // 注册触发器
            bean.setTriggers(firstTrigger, secondTrigger);
            return bean;
        }
    
    
    }
    

     

     

    要点描述1:
    将我们的实例配置成为定时任务实例

    要点描述2:  

    绑定触发器 简单触发器:

    要点描述3:

    绑定可以使用cron表达式的触发器,这次实践里面我们的任务2就是:

     

    要点描述4:

    将配置好的触发器加入调度工厂:

     

     

    运行一下,可以看到2个定时任务都正常运行:

    如果需要继续添加其他的定时任务,那么就是创建实例,然后在配置文件里面依次进行相关配置绑定即可。

     

    就到此。 

    展开全文
  • java定时执行多任务quartz定时执行多任务
  • 5.由于QuartzConfiguration中使用@Configuratios注解 故不能使用注解的方式注入bean, 写util从ApplicationContext中获取 import org.springframework.beans.BeansException; import org.springframework....

    https://blog.csdn.net/liushuiziyouliu/article/details/81455649

    版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
    本文链接: https://blog.csdn.net/liushuiziyouliu/article/details/81455649

    1.pom.xml

    
     
    1. <dependency>
    2. <groupId>org.quartz-scheduler </groupId>
    3. <artifactId>quartz </artifactId>
    4. <version>${quartz-version} </version>
    5. </dependency>
    6. <dependency>
    7. <groupId>org.springframework </groupId>
    8. <artifactId>spring-context-support </artifactId>
    9. <version>${spring-context-version} </version>
    10. </dependency>
    11. <spring-context-version>4.0.6.RELEASE </spring-context-version>
    12. <quartz-version>2.2.1 </quartz-version>

    2.  QuartzConfiguration

    
     
    1. import com.ppdai.baihang.job.FirstJob;
    2. import com.ppdai.baihang.job.SecondJob;
    3. import com.ppdai.baihang.utils.SpringUtil;
    4. import org.quartz.JobDetail;
    5. import org.quartz.Trigger;
    6. import org.springframework.context. annotation.Bean;
    7. import org.springframework.context. annotation.Configuration;
    8. import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
    9. import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
    10. import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    11. import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;
    12. @Configuration
    13. public class QuartzConfiguration {
    14. // 配置触发器1
    15. @Bean(name = "firstTrigger")
    16. public SimpleTriggerFactoryBean firstTrigger(JobDetail firstJobDetail) {
    17. SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
    18. trigger.setJobDetail(firstJobDetail);
    19. // 设置任务启动延迟
    20. trigger.setStartDelay( 0);
    21. // 每5秒执行一次
    22. trigger.setRepeatInterval( 5000);
    23. return trigger;
    24. }
    25. // 配置定时任务1
    26. @Bean(name = "firstJobDetail")
    27. public MethodInvokingJobDetailFactoryBean firstJobDetail() {
    28. FirstJob firstJob = (FirstJob) SpringUtil.getBean(FirstJob. class);
    29. MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
    30. // 是否并发执行
    31. jobDetail.setConcurrent( false);
    32. // 为需要执行的实体类对应的对象
    33. jobDetail.setTargetObject(firstJob);
    34. // 需要执行的方法
    35. jobDetail.setTargetMethod( "task");
    36. return jobDetail;
    37. }
    38. // 配置触发器2
    39. @Bean(name = "secondTrigger")
    40. public CronTriggerFactoryBean secondTrigger(JobDetail secondJobDetail) {
    41. CronTriggerFactoryBean trigger = new CronTriggerFactoryBean();
    42. trigger.setJobDetail(secondJobDetail);
    43. // cron表达式
    44. trigger.setCronExpression( "*/5 * * * * ?");
    45. return trigger;
    46. }
    47. // 配置定时任务2
    48. @Bean(name = "secondJobDetail")
    49. public MethodInvokingJobDetailFactoryBean secondJobDetail() {
    50. SecondJob secondJob = (SecondJob) SpringUtil.getBean(SecondJob. class);
    51. MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
    52. // 是否并发执行
    53. jobDetail.setConcurrent( false);
    54. // 为需要执行的实体类对应的对象
    55. jobDetail.setTargetObject(secondJob);
    56. // 需要执行的方法
    57. jobDetail.setTargetMethod( "task");
    58. return jobDetail;
    59. }
    60. // 配置Scheduler
    61. @Bean(name = "scheduler")
    62. public SchedulerFactoryBean schedulerFactory(Trigger firstTrigger, Trigger secondTrigger) {
    63. SchedulerFactoryBean bean = new SchedulerFactoryBean();
    64. // 延时启动,应用启动1秒后
    65. bean.setStartupDelay( 1);
    66. // 注册触发器
    67. bean.setTriggers(firstTrigger, secondTrigger);
    68. return bean;
    69. }
    70. }

    3.FirstJob

    
     
    1. import org.springframework.scheduling.annotation.EnableScheduling;
    2. import org.springframework.stereotype.Component;
    3. @EnableScheduling
    4. @Component
    5. public class FirstJob{
    6. public void task(){
    7. System.out.println( "任务1执行....");
    8. }
    9. }

    4.SecondJob

    
     
    1. import org.springframework.scheduling.annotation.EnableScheduling;
    2. import org.springframework.stereotype.Component;
    3. @EnableScheduling
    4. @Component
    5. public class SecondJob{
    6. public void task(){
    7. System.out.println( "任务2执行....");
    8. }
    9. }

    5.由于QuartzConfiguration中使用@Configuratios注解  故不能使用注解的方式注入bean, 写个util从ApplicationContext中获取

    
     
    1. import org.springframework.beans.BeansException;
    2. import org.springframework.context.ApplicationContext;
    3. import org.springframework.context.ApplicationContextAware;
    4. import org.springframework.stereotype.Component;
    5. @Component
    6. public class SpringUtil implements ApplicationContextAware {
    7. private static ApplicationContext applicationContext;
    8. @Override
    9. public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    10. if (SpringUtil.applicationContext == null) {
    11. SpringUtil.applicationContext = applicationContext;
    12. }
    13. }
    14. //获取applicationContext
    15. public static ApplicationContext getApplicationContext() {
    16. return applicationContext;
    17. }
    18. //通过name获取 Bean.
    19. public static Object getBean(String name) {
    20. return getApplicationContext().getBean(name);
    21. }
    22. //通过class获取Bean.
    23. public static <T> T getBean(Class<T> clazz) {
    24. return getApplicationContext().getBean(clazz);
    25. }
    26. //通过name,以及Clazz返回指定的Bean
    27. public static <T> T getBean(String name, Class<T> clazz) {
    28. return getApplicationContext().getBean(name, clazz);
    29. }
    30. }

     

    展开全文
  • SpringBoot+Quartz实现多个定时任务

    千次阅读 2018-09-14 18:12:54
    通过Timer和Spring的scheduler实现定时任务可能会出现一旦定时任务中断后续的定时任务无法正常执行的问题,Quartz能够很好的解决这一问题。 项目使用Maven管理,因此在使用之前需要在pom文件中添加依赖,如下:  ...

    通过Timer和Spring的scheduler实现定时任务可能会出现一旦定时任务中断后续的定时任务无法正常执行的问题,Quartz能够很好的解决这一问题。

    项目使用Maven管理,因此在使用之前需要在pom文件中添加依赖,如下:

        <dependency>
          <groupId>org.quartz-scheduler</groupId>
          <artifactId>quartz</artifactId>
          <version>2.0.1</version>
        </dependency>
        
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context-support</artifactId>
          <version>4.0.6.RELEASE</version>
        </dependency>

    不要忘记spring-context-support。

    紧接着需要添加Quartz配置类,我把代码粘贴了下来,如下:

    其中需要import的部分内容:

    import org.quartz.JobDetail;
    import org.quartz.Trigger;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
    import org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean;
    import org.springframework.scheduling.quartz.SchedulerFactoryBean;
    import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

    -----------------------------------------------下边是配置类的实现-------------------------------------------------------

    @Configuration
    public class QuartzConfig<CornTriggerFactoryBean> {
        
        //指定了触发规则
        @Bean(name = "firstTrigger")
        public CornTriggerFactoryBean  uploadTaskTrigger(JobDetail firstJobDetail){
            CronTriggerFactoryBean  trigger = new CronTriggerFactoryBean();
            trigger.setJobDetail(firstJobDetail);
            trigger.setCronExpression("0 10 10 * * ?");//每天两点上传数据        
            
            
            return (CornTriggerFactoryBean) trigger;
        }
        
        
        @Bean(name = "firstJobDetail")
        public MethodInvokingJobDetailFactoryBean  uploadTaskDetail(){//指定了具体需要执行的类  具体的方法就是我们需要实现的excuteInternal
            
            UploadTask uploadTask = (UploadTask)SpringUtil.getBean(UploadTask.class);
            MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
            

            // 是否并发执行
            jobDetail.setConcurrent(false);
            // 为需要执行的实体类对应的对象
            jobDetail.setTargetObject(uploadTask);
            // 需要执行的方法
            jobDetail.setTargetMethod("task");
            return jobDetail;
            
            //return JobBuilder.newJob(UploadTask.class).withIdentity("uploadTask").storeDurably().build();
            
        }


       
        //第二个定时任务的触发规则
        @Bean(name = "secondTrigger")
        public SimpleTriggerFactoryBean submitFailDataTaskTrigger(JobDetail secondJobDetail){
            
            SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
            trigger.setJobDetail(secondJobDetail);
            // 设置任务启动延迟
            trigger.setStartDelay(0);
            // 每5分钟执行一次
            trigger.setRepeatInterval(300000);//300000
            return trigger;

        }
        
        
        //第二个定时任务
        @Bean(name = "secondJobDetail")
        public MethodInvokingJobDetailFactoryBean SubmitFailedDataTaskDetail(){
            
            SubmitFailedDataTask submitFailedDataTask = (SubmitFailedDataTask)SpringUtil.getBean(SubmitFailedDataTask.class);
            

            MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
            // 是否并发执行
            jobDetail.setConcurrent(false);
            // 为需要执行的实体类对应的对象
            jobDetail.setTargetObject(submitFailedDataTask);
            // 需要执行的方法
            jobDetail.setTargetMethod("task");
            return jobDetail;

            //return JobBuilder.newJob(SubmitFailedDataTask.class).withIdentity("submitFailedDataTask").storeDurably().build();
        }
        

          // 配置Scheduler
          @Bean(name = "scheduler")
          public SchedulerFactoryBean schedulerFactory(Trigger firstTrigger, Trigger secondTrigger) {
            SchedulerFactoryBean bean = new SchedulerFactoryBean();
            // 延时启动,应用启动1秒后
            bean.setStartupDelay(1);
            // 注册触发器
            bean.setTriggers(firstTrigger, secondTrigger);
            return bean;
          }

    }

    其中,在配置Scheduler中注册两个触发器,然后项目启动1秒之后就会启动定时任务轮训,到了代码设置的corn表达式满足时,就会触发相应的定时任务。

    需要注意的是上边拿到要执行的两个Task的时候定义了Util工具类,也就是SpringUtil工具类,代码如下:

    其中需要import的内容如下:

    import org.springframework.beans.BeansException;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.ApplicationContextAware;
    import org.springframework.stereotype.Component;

    实现类方法如下:

    @Component
    public class SpringUtil implements ApplicationContextAware{

        

        private static ApplicationContext applicationContext;
        
        @Override
        public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            
            if (SpringUtil.applicationContext == null) {
                SpringUtil.applicationContext = applicationContext;
              }

        }
        
         //获取applicationContext
          public static ApplicationContext getApplicationContext() {
            return applicationContext;
          }
         
          //通过name获取 Bean.
          public static Object getBean(String name) {
            return getApplicationContext().getBean(name);
          }
         
          //通过class获取Bean.
          public static <T> T getBean(Class<T> clazz) {
            return getApplicationContext().getBean(clazz);
          }
         
          //通过name,以及Clazz返回指定的Bean
          public static <T> T getBean(String name, Class<T> clazz) {
            return getApplicationContext().getBean(name, clazz);
          }
    }

    然后去实现UploadTask和SubmitFailedDataTask两个定时任务就可以了

    需要在任务实现类中实现task()方法

    @DisallowConcurrentExecution
    @EnableScheduling
    @Component
    public class UploadTask{

    public void task(){ //task方法中实现主要逻辑就可以了。

    }

    }

    最重要的是要在启动类中添加@EnableScheduling注解。

    当前还是有一些比较疑惑的地方,后续也会整理一下,将来用得到的时候会方便一些。

     

    展开全文
  • Quartz任务定时器之多任务定时执行

    万次阅读 2018-08-29 23:31:27
    1.项目结构图: 2.创建QuartzTask01.... //编写一个定时执行业务逻辑的类 public class QuartzTask01 { static int i=1; public void run (){ Date date = new Date(); SimpleDateFormat simpleDateFormat...

    1.项目结构图:

    这里写图片描述

    2.创建QuartzTask01.java

     //编写一个定时执行业务逻辑的类
    public class QuartzTask01 {
        static int i=1;
        public void run (){
            Date date = new Date();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println("张无忌第"+i+"次练功时间==========="+simpleDateFormat.format(date));
            ++i;
        }
    }

    3.创建QuartzTask02.java

    /编写一个定时执行业务逻辑的类
    public class QuartzTask02 extends QuartzJobBean {
    
        private String name;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        //定时任务业务逻辑写在以下方法中
        @Override
        protected void executeInternal(JobExecutionContext arg0)
                throws JobExecutionException {
            Date date = new Date();
            SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(name + " 每次晨练时间===========" +simpleDateFormat.format(date));
            }
    }

    4.创建多任务applicationContext01.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">
    
        <!--1.定义QuartzTask01-->
        <bean name="task01" class="com.wjl.QuartzTask01"/>
        <!--2.定义JobDetailFactoryBean-->
        <bean name="task02" class="org.springframework.scheduling.quartz.JobDetailFactoryBean">
            <property name="jobClass" value="com.wjl.QuartzTask02"/>
            <property name="jobDataAsMap">
                <map>
                    <entry key="name" value="张三丰"/>
                </map>
            </property>
        </bean>
        <!--3.定义CronTriggerFactoryBean-->
        <bean id="cronTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean" >
            <property name="jobDetail" ref="task02"/>
            <!--  定义第二个任务的执行周期  每隔30秒钟执行一次 -->
            <property name="cronExpression" value="/30 * * * * ?"/>
            <!-- cronExpression表达式定义Job的执行规则。 -->
        </bean>
    
    
        <!--4.定义MethodInvokingJobDetailFactoryBean-->
        <bean name="methodInvokingJobDetailFactoryBean" class="org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean">
            <property name="targetObject" ref="task01"/>
            <property name="targetMethod" value="run"/>
            <!-- concurrent 指定这个methodInvokingJobDetailFactoryBean(多个同时执行)能否同时执行,默认为true。-->
            <property name="concurrent" value="false"/>
        </bean>
        <!-- 5.每个定时任务类都需要一个CronTriggerFactoryBean-->
        <bean id="repeatTrigger" class="org.springframework.scheduling.quartz.CronTriggerFactoryBean">
            <property name="jobDetail" ref="methodInvokingJobDetailFactoryBean"/>
            <!-- 定义第二个任务的执行周期  每隔10秒钟执行一次-->
            <property name="cronExpression" value="/10 * * * * ?"/>
        </bean>
    
        <!--6.最终把所有触发器添加到SchedulerFactoryBean-->
        <bean id="scheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
            <property name="triggers">
                <list>
                    <!--引入多个触发器-->
                    <ref bean="repeatTrigger"/>
                    <ref bean="cronTrigger"/>
                </list>
            </property>
        </bean>
    </beans>

    5.pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.kaina</groupId>
        <artifactId>DemoQuartz</artifactId>
        <version>1.0-SNAPSHOT</version>
        <dependencies>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>4.1.6.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.quartz-scheduler</groupId>
                <artifactId>quartz</artifactId>
                <version>2.2.1</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context-support</artifactId>
                <version>4.1.6.RELEASE</version>
            </dependency>
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-orm</artifactId>
                <version>4.1.6.RELEASE</version>
            </dependency>
    
            <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-api -->
            <dependency>
                <groupId>org.slf4j</groupId>
                <artifactId>slf4j-api</artifactId>
                <version>1.7.25</version>
            </dependency>
            </dependencies>
    </project>

    6.Main01测试

    public class Main01 {
        public static void main(String[] args) {
            //初始化容器时,执行Myjob
            new ClassPathXmlApplicationContext("classpath:applicationContext01.xml");
        }
    }
    
    张无忌第1次练功时间===========2018-08-29 23:30:10
    张无忌第2次练功时间===========2018-08-29 23:30:20
    张无忌第3次练功时间===========2018-08-29 23:30:30
    张三丰 每次晨练时间===========2018-08-29 23:30:30
    张无忌第4次练功时间===========2018-08-29 23:30:40
    张无忌第5次练功时间===========2018-08-29 23:30:50
    张三丰 每次晨练时间===========2018-08-29 23:31:00
    张无忌第6次练功时间===========2018-08-29 23:31:00

    7.cron表达式(参考此博客内容——在线Cron表达式生成器

    cron的表达式是字符串,实际上是由七子表达式,描述个别细节的时间表。这些子表达式意义如下:

    1. Seconds (秒)
    2. Minutes (分)
    3. Hours (时)
    4. Day-of-Month (天)
    5. Month (月)
    6. Day-of-Week (周)
    7. Year (年 可选字段)

    例 “0 0 12 ? * WED” 在每星期三下午12:00 执行;
    同时(“WED”)可以替换成 “MON-FRI”, “MON, WED, FRI”甚至”MON-WED,SAT”。

    注意, cron 表达式规则

    每一个字段都有一套可以指定有效值,如
    Seconds (秒) :可以用数字0-59 表示;

    Minutes(分) :可以用数字0-59 表示;

    Hours(时) :可以用数字0-23表示;

    Day-of-Month(天) :可以用数字1-31 中的任一一个值,但要注意一些特别的月份;

    Month(月) :可以用0-11 或用字符串 “JAN, FEB, MAR, APR, MAY, JUN, JUL, AUG, SEP, OCT, NOV and DEC” 表示;

    Day-of-Week(每周)可以用数字1-7表示(1 = 星期日)或用字符口串“SUN, MON, TUE, WED, THU, FRI and SAT”表示;

    “/”:为特别单位,表示为“每”如“0/15”表示每隔15分钟执行一次,“0”表示为从“0”分开始, “3/20”表示表示每隔20分钟执行一次,“3”表示从第3分钟开始执行;

    “?”:表示每月的某一天,或第周的某一天;

    “L”:用于每月,或每周,表示为每月的最后一天,或每个月的最后星期几如“6L”表示“每月的最后一个星期五”;

    “W”:表示为最近工作日,如“15W”放在每月(day-of-month)字段上表示为“到本月15日最近的工作日”;

    “#”:是用来指定“的”每月第n个工作日,例 在每周(day-of-week)这个字段中内容为”6#3” or “FRI#3” 则表示“每月第三个星期五”;

    “*” 代表整个时间段。

    常见的 cron 表达式

    这里写图片描述

    每隔5秒执行一次:*/5 * * * * ?
    
    每隔1分钟执行一次:0 */1 * * * ?
    
    每天23点执行一次:0 0 23 * * ?
    
    每天凌晨1点执行一次:0 0 1 * * ?
    
    每月1号凌晨1点执行一次:0 0 1 1 * ?
    
    每月最后一天23点执行一次:0 0 23 L * ?
    
    每周星期天凌晨1点实行一次:0 0 1 ? * L
    
    在26分、29分、33分执行一次:0 26,29,33 * * * ?
    
    每天的0点、13点、18点、21点都执行一次:0 0 0,13,18,21 * * ?

    8.实例源码下载

    注:实例源码下载

    展开全文
  • 应用quartz实现了任务并发执行,定时时间从数据库获取,并且能够在更改数据库执行时间后重新执行定时任务,实现了quartz定时任务的动态管理。本次为了实现功能,代码并未作优化,仅作参考借鉴之用。
  • NULL 博文链接:https://medbricom.iteye.com/blog/1782765
  • 使用spring+quartz配置多个定时任务

    千次阅读 2018-08-30 16:20:53
    首先引入 quartz jar包; 创建java类: package com.tcwl.vsmp.loanmgt.message; import com.tcwl.vsmp.external.constant.SmsConstant; import com.tcwl.vsmp.external.service.sms.SmsProxy; import java....
  • quartz多个定时任务实现方式

    千次阅读 2019-05-30 09:24:33
    1、pom.xml <!-- quartz 定时任务 --> <dependency> <groupId>org.quartz-scheduler</groupId> <artifactId>quartz</artifactId> </de...
  • 一、简单定时任务 1、启动类添加@EnableScheduling @SpringBootApplication @EnableScheduling public class DemoApplication { public static void main(String[] args) { SpringApplication.run...
  • 如果要设置多个任务,直接根据注释说明添加第三个任务即可,已经验证过,可以实现,因为刚开始接触Quartz,运行过程中会遇到什么问题目前不清楚,仅是多任务同时定时同时执行的实现 build.gradle中配置 compile '...
  • 主要给大家介绍了关于Spring Boot中配置定时任务、线程池与线程池执行的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用Spring Boot具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • SpringBoot配置多个Quartz定时任务

    千次阅读 2021-01-07 17:03:21
    很久之前使用过数据库的定时任务,如今换用了后端框架中的定时器,本篇介绍的就是Quartz,当然网上教程很,在这里就简单配2个定时任务来保存回忆 一、导入依赖 来引入一些jar包,这里是采用maven引入,其实引入了...
  • 附件中实现了对quartz的动态添加、修改和删除定时任务,方便通过页面动态控制执行定时任务
  • 1、若是部署多台机器,到了时间点,只有一台会执行,其他不会执行。 2、若多个节点其中一个scheduler执行job失败,将会被另外一个scheduler执行
  • 主要介绍了.NET Core使用Quartz执行调度任务进阶,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 我的项目是采用的idea+gradle+springboot项目构建,下面是springboot实现定时任务所需要的jar包 //定时任务使用 compile group: 'org.quartz-scheduler', name: 'quartz', version: '2.3.0' compile group: 'org....
  • C#实现的自定义定时任务 可定时运行 任务运行
  • spring quartz 部分定时任务执行问题定位修复方案

    千次阅读 多人点赞 2021-01-19 09:05:32
    Quartz部分定时任务执行问题分析过程及修复方案 背景: 2021年1月7号上线迁移需求之后,出现最为明显的 众帮文件上传 其他部分定时任务也不执行的情况 执行时间并没有按照约定时间去执行 分析1 怀疑是代码问题? ...
  • 1.话不说,先看一下项目的整体结构 2.看完后,第一步建好项目后就是导入依赖,打开pom.xml,添加如下依赖 <!-- mybatis启动器 --> <dependency> <groupId>org.mybatis.spring.boot</...
  • spring boot整合quartz实现多个定时任务

    千次阅读 2017-11-15 18:22:24
    最近收到了很多封邮件,都是想知道spring boot整合quartz如何实现多个定时任务的,由于本人生产上并没有使用到多个定时任务,这里给个实现的思路。 1、新建两个定时任务,如下: public class ScheduledJob ...
  • 1.c#中使用quartz执行个定时任务(任务中使用了Parallel.For线程)执行2个小时就会暂停一段时间? ``` //计算日期是星期一 if (tc.DayOfWeek == DayOfWeek.Monday) { ...
  • 主要介绍了Java应用机器部署解决大量定时任务问题,两台服务器同时部署了同一套代码, 代码中写有spring自带的定时任务,但是每次执行定时任务时只需要一台机器去执行,需要的朋友可以参考下
  • 但如果要改变任务的执行时间、频率,废弃任务等就需要改变配置甚至代码需要重启服务器,这里介绍一下如何通过quartz与spring的组合实现动态的改变定时任务的状态的一实现。 该jar包提供java项目源码,数据库文件...
  • java使用quartz定时执行任务

    千次阅读 2019-03-30 14:47:52
    项目中需要有一个定时任务,在每年一月一日查询人员表中的信息,根据身份证号码,修改用户年龄。项目使用架构为Spring,Spring MVC,Mybaits。所以引入了Quartz做定时任务。 1.引入相关jar <!-- 定时任务quartz...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,144
精华内容 5,657
关键字:

quartz执行多个定时任务