SpringBoot整合Quartz==>适用于单任务多任务

上一篇文章简单的介绍了一下Quartz的控制台运行，有兴趣的可以看看https://blog.csdn.net/yali_aini/article/details/85273209

这里我会介绍一下 SpringBoot整合Quartz，多任务和单任务的。

其实多任务和单任务没什么区别，按照我这种写法。

tx包，和 context 包不加，可能会报错！

1.pom配置

        <!-- quartz 坐标 -->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
            <version>2.2.1</version>
        </dependency>
        
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-tx -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.0.8.RELEASE</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-context-support -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>4.3.13.RELEASE</version>
        </dependency>

2.任务编写

此处演示多类，多方法。

JobGetAll

@Configuration
public class JobGetAll {

    @Autowired
    private MsgService msgService;

    public void getAll(){
        List<Msg> list = msgService.getAll();
        System.out.println("=================>"+ list.size() );
        System.out.println( list.get(list.size()-1) +"======>任务二" );
    }

    public void insert(){
        Msg msg = new Msg("100", "pkusoft", "与人为善，不与人为恶，狗除外。", new Date());
        msgService.insertSelective(msg);
        System.out.println("存储成功============>任务一");
    }

}

JobUser

@Configuration
public class JobUser {

    @Autowired
    private UserInfoService userInfoService;

    public void getUser(){
        Userinfo info = userInfoService.selectByUid("1");
        System.out.println(info+"======>任务三");
    }

}

3.任务集成（重点）

import com.zzq.config.quartz.job.JobGetAll;
import com.zzq.config.quartz.job.JobUser;
import org.quartz.Trigger;
import org.springframework.beans.factory.annotation.Qualifier;
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;

/**
 * 配置类
 */
@Configuration
public class QuartzConfig {

    // 定义方法，做什么
    @Bean(name = "job1")
    public MethodInvokingJobDetailFactoryBean job1(JobGetAll jobGetAll){
        MethodInvokingJobDetailFactoryBean factoryBean = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        factoryBean.setConcurrent(true);
        // 使用哪个对象
        factoryBean.setTargetObject(jobGetAll);
        // 使用哪个方法
        factoryBean.setTargetMethod("getAll");

        return  factoryBean;
    }

    // 定义什么时候做，使用 cron 表达式
    @Bean(name = "cron1")
    public CronTriggerFactoryBean cron1(@Qualifier("job1")MethodInvokingJobDetailFactoryBean job1){
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        // 设置job对象
        factoryBean.setJobDetail( job1.getObject() );
        // 设置执行时间
        factoryBean.setCronExpression("0/5 * * * * ?");
        return  factoryBean;
    }



    // 定义方法，做什么
    @Bean(name = "job2")
    public MethodInvokingJobDetailFactoryBean job2(JobGetAll jobGetAll){
        MethodInvokingJobDetailFactoryBean factoryBean = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        factoryBean.setConcurrent(true);
        // 使用哪个对象
        factoryBean.setTargetObject(jobGetAll);
        // 使用哪个方法
        factoryBean.setTargetMethod("insert");

        return  factoryBean;
    }

    // 定义什么时候做，使用 cron 表达式
    @Bean(name = "cron2")
    public CronTriggerFactoryBean cron2(@Qualifier("job2")MethodInvokingJobDetailFactoryBean job2){
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        // 设置job对象
        factoryBean.setJobDetail( job2.getObject() );
        // 设置执行时间
        factoryBean.setCronExpression("0/10 * * * * ?");
        return  factoryBean;
    }


    // 定义方法，做什么
    @Bean(name = "job3")
    public MethodInvokingJobDetailFactoryBean job3(JobUser jobUser){
        MethodInvokingJobDetailFactoryBean factoryBean = new MethodInvokingJobDetailFactoryBean();
        // 是否并发执行
        factoryBean.setConcurrent(true);
        // 使用哪个对象
        factoryBean.setTargetObject(jobUser);
        // 使用哪个方法
        factoryBean.setTargetMethod("getUser");

        return  factoryBean;
    }

    // 定义什么时候做，使用 cron 表达式
    @Bean(name = "cron3")
    public CronTriggerFactoryBean cron3(@Qualifier("job3")MethodInvokingJobDetailFactoryBean job3){
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        // 获取 job对象
        factoryBean.setJobDetail( job3.getObject() );
        // 设置 时间表达式
        factoryBean.setCronExpression("0/10 * * * * ?");
        return  factoryBean;
    }



    // 定义 任务，传入 triggers
    @Bean
    public SchedulerFactoryBean scheduler1(Trigger ... triggers){
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        // 设置 triggers
        factoryBean.setTriggers( triggers );
        // 自动运行
        factoryBean.setAutoStartup(true);

        return factoryBean;
    }

}

4.运行效果