Spring Boot 中实现定时任务的常用方式--Quartz

一、Quartz的介绍以及Quartz的使用思路

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。

• job - 任务 - 你要做什么事？
• Trigger - 触发器 - 你什么时候去做？
• Scheduler - 任务调度 - 你什么时候需要去做什么事？

二、Quartz的简单使用

1.导入依赖

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

2.创建任务类

package com.fync.quartz;

import java.text.SimpleDateFormat;
import java.util.Date;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
/**
 * 创建要被定执行的任务类
 *
 */
public class MyJob implements Job{

    public void execute(JobExecutionContext context)
            throws JobExecutionException {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        System.out.println(sdf.format(new Date()));
    }

}

3.创建任务调度及执行

package com.fync.quartz;

import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.SimpleScheduleBuilder;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;

/**
 * 创建任务调度，并执行
 */
public class MainScheduler {
    
    //创建调度器
    public static Scheduler getScheduler() throws SchedulerException{
        SchedulerFactory schedulerFactory = new StdSchedulerFactory();
        return schedulerFactory.getScheduler();
    }
    
    
    public static void schedulerJob() throws SchedulerException{
        //创建任务
        JobDetail jobDetail = JobBuilder.newJob(MyJob.class).withIdentity("job1", "group1").build();
        //创建触发器 每3秒钟执行一次
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity("trigger1", "group3")
                            .withSchedule(SimpleScheduleBuilder.simpleSchedule().withIntervalInSeconds(3).repeatForever())
                            .build();
        Scheduler scheduler = getScheduler();
        //将任务及其触发器放入调度器
        scheduler.scheduleJob(jobDetail, trigger);
        //调度器开始调度任务
        scheduler.start();
        
    }
    
    public static void main(String[] args) throws SchedulerException {
        MainScheduler mainScheduler = new MainScheduler();
        mainScheduler.schedulerJob();
    }

}

三、整合springBoot

1、导入依赖

 <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--定时器依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-quartz</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>5.1.5.RELEASE</version>
        </dependency>
    </dependencies>

2.配置类

package com.config;
import com.JobScheduled.QuartzDemo;
import org.quartz.SimpleTrigger;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

/**
 * Quartz配置类
 */
@Configuration
public class QuartzConfig {
    
    //    1.创建Job对象
    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean() {
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
//        关联自己的类
        factoryBean.setJobClass(QuartzDemo.class);
        return factoryBean;
    }
    
    //    2.创建Trigger对象(简易版)
    @Bean
    public SimpleTriggerFactoryBean simpleTriggerFactoryBean( JobDetailFactoryBean jobDetailFactoryBean) {
        SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
//        关联jobDetail对象
        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());
//        该参数表示一个执行的毫秒数
        factoryBean.setRepeatInterval(2000);
//        设置重复次数
        factoryBean.setRepeatCount(5);
        
        return factoryBean;
    }

//    3.创建Scheduler对象
    
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactoryBean){
        
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        
        factoryBean.setTriggers(simpleTriggerFactoryBean.getObject());
        
        return factoryBean;
    }
}

3.定时任务类

package com.JobScheduled;

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * Job类
 */
public class QuartzDemo implements Job {
    
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("Quartz定时任务");
    }
}

4、开启定时任务

@SpringBootApplication
//开启定时任务
@EnableScheduling
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
    
}

四：多任务

/**
     * 第一个任务
     */
    //    1.创建Job对象
    @Bean(name = "oneJobDetail")
    public MethodInvokingJobDetailFactoryBean OneJobDetail(OneJob oneJob) {
        MethodInvokingJobDetailFactoryBean jobDetail = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        jobDetail.setConcurrent(true);
        // 为需要执行的实体类对应的对象
        jobDetail.setTargetObject(oneJob);
        // 需要执行的方法
        jobDetail.setTargetMethod("task");
        return jobDetail;
    }

    //    2.创建Trigger对象(简易版)
    @Bean(name = "oneTrigger")
    public SimpleTriggerFactoryBean OneSimpleTrigger(JobDetail oneJobDetail) {
        SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
        // 设置任务启动延迟
        trigger.setStartDelay(0);
//        关联jobDetail对象
        trigger.setJobDetail(oneJobDetail);
//        该参数表示一个执行的毫秒数
        trigger.setRepeatInterval(2000);
//        设置重复次数(-1=无限次)
        trigger.setRepeatCount(2);
        return trigger;
    }

    /**
     * 第二个任务
     */
    @Bean(name = "twoJobDetail")
    public MethodInvokingJobDetailFactoryBean twoJobDetail(TwoJob twoJob) {
        MethodInvokingJobDetailFactoryBean jobdetail = new MethodInvokingJobDetailFactoryBean();
        jobdetail.setConcurrent(true);
        jobdetail.setTargetObject(twoJob);
        jobdetail.setTargetMethod("task");
        return jobdetail;
    }

    //    2.创建Trigger对象(简易版)
    @Bean(name = "twoTrigger")
    public SimpleTriggerFactoryBean twoSimpleTrigger(JobDetail twoJobDetail) {
        SimpleTriggerFactoryBean trigger = new SimpleTriggerFactoryBean();
        trigger.setJobDetail(twoJobDetail);
        trigger.setRepeatInterval(2000);
        trigger.setRepeatCount(3);
        return trigger;
    }

//    3.创建Scheduler对象

    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(Trigger oneTrigger, Trigger twoTrigger) {
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        factoryBean.setTriggers(oneTrigger, twoTrigger);
        return factoryBean;
    }

任务类@Component装配上即可

• 第一种实现：
• 1.任务类继承job 实现execute方法
• 2.将任务类扔进 JobDetailFactoryBean（不够灵活）
• 第二种实现：
• 1.任务类 @Component 装配
• 2.将任务类扔进 MethodInvokingJobDetailFactoryBean
• 相比第一种更方便，定位更准确，针对方法体，易于多任务并发执行

  ---

总结：一般复杂的任务定时调度，才会考虑Quartz，去做数据持久化，以上只是简单的实现Quartz，
定时任务简单的情况下，建议使用spring3.0自带的定时：@Scheduled

参考：Spring Boot 中实现定时任务的常用方式@Scheduled

SpringBoot 整合 Quartz 实现 JAVA 定时任务的动态配置