Springboot 使用Quartz定时器执行多个定时任务配置篇

Dear 丶 2023-07-12 14:40 76阅读 0赞

首先在开篇前，先放一个Springboot简单使用定时器的文章：  
[https://blog.csdn.net/qq\_35387940/article/details/82800403][https_blog.csdn.net_qq_35387940_article_details_82800403]

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

[https://mp.csdn.net/console/editor/html/107038022][https_mp.csdn.net_console_editor_html_107038022]

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

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

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

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

OK，接下来我们开始。

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

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

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

![20200309114900260.png][]

创建第一个定时任务的实例，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：  
将我们的实例配置成为定时任务实例

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70][]

要点描述2：

绑定触发器 简单触发器：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 1][]

要点描述3：

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 2][]

要点描述4：

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 3][]

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 4][]

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

就到此。

[https_blog.csdn.net_qq_35387940_article_details_82800403]: https://blog.csdn.net/qq_35387940/article/details/82800403
[https_mp.csdn.net_console_editor_html_107038022]: https://mp.csdn.net/console/editor/html/107038022
[20200309114900260.png]: https://img-blog.csdnimg.cn/20200309114900260.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/2020030912020759.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200309120407509.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200309120549941.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200309130616357.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200309130653814.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM1Mzg3OTQw,size_16,color_FFFFFF,t_70