SpringBoot整合Quartz 定时任务框架

SpringBoot整合Quartz 定时任务框架

1.Quartz介绍以及Quartz的使用思路

参考文档：https://blog.csdn.net/noaman_wgs/article/details/80984873

1.1.Quartz的介绍

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

1.2.Quartz的使用思路

• 1）job 任务 你要做什么事？
• 2）Trigger 触发器 你什么时候去做？
• 3）Scheduling 任务调度 你什么时候需要去做什么事？

2.Quartz的基本使用方式

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

3.编写要执行的Job

/*
*定时任务类
* */
public class QuartzDemo implements Job {
    /*
     *任务被触发时所执行的方法
     * */
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时器被触发："+new Date());
    }
}

4.Schedule，执行任务：

//测试定时任务
public static void main(String[] args) throws Exception{
    //1.创建Job对象：你要做什么事？
    //创建JobDetail实例，并与PrintWordsJob类绑定(Job执行内容)
    JobDetail job=JobBuilder.newJob(QuartzDemo.class).build();

    /*
		* 简单的trigger触发时间：通过Quartz提供一个方法来完成简单的重复调用
		* Cron Trigger:按照Cron的表达式来给定触发的时间
		* */
    //2.创建Trigger对象：在什么时间做？
    Trigger trigger = TriggerBuilder.newTrigger().withSchedule(SimpleScheduleBuilder.repeatSecondlyForever())
				.build();
    
	/*使用 Cron表达式触发*/
	Trigger trigger = TriggerBuilder.newTrigger().withSchedule(CronScheduleBuilder.cronSchedule("0/2 * * * * ?"))
				.build();

    //3.创建Scheduler对象：在什么时间做什么事？
    Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
    scheduler.scheduleJob(job,trigger);

    //4.启动
    scheduler.start();
}

5.SpringBoot整合Quartz

1.导入坐标

<!--quartz-->
<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>

<!--添加坐标-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context-support</artifactId>
</dependency>

<!--Spring tx 事务jar-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-tx</artifactId>
</dependency>

2.编写Quartz定时任务类

/*
*定时任务类
* */
public class QuartzDemo implements Job {
    /*
     *任务被触发时所执行的方法
     * */
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时器被触发："+new Date());
    }
}

3.编写Quartz配置类

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

    /*
    * 1.创建Job对象
    * */
    @Bean
    public JobDetailFactoryBean getJobDetailFactoryBean(){
        JobDetailFactoryBean factory= new JobDetailFactoryBean();
        //关联自己的定时任务类
        factory.setJobClass(QuartzDemo.class);
        return factory;
    }

    /*
     * 2.创建Trigger对象
     * 简单的Trigger
     * */
    @Bean
    public SimpleTriggerFactoryBean getSimpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
        SimpleTriggerFactoryBean factoryBean = new SimpleTriggerFactoryBean();
        //关联JobDetail对象
        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        //该参数表示一个执行的毫秒数：
        factoryBean.setRepeatInterval(2000);
        //设置重复次数
        factoryBean.setRepeatCount(5);
        return factoryBean;
    }

    /*
     * 3.创建Scheduler对象
     * */
    @Bean
    public SchedulerFactoryBean getSchedulerFactoryBean(SimpleTriggerFactoryBean simpleTriggerFactoryBean){
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //关联Trigger对象
        factory.setTriggers(simpleTriggerFactoryBean.getObject());
        return factory;
    }
}

4.启动类中开启定时任务

@EnableScheduling

5.Cron Trigger 配置

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

    /*
    * 1.创建Job对象
    * */
    @Bean
    public JobDetailFactoryBean getJobDetailFactoryBean(){
        JobDetailFactoryBean factory= new JobDetailFactoryBean();
        //关联自己的定时任务类
        factory.setJobClass(QuartzDemo.class);
        return factory;
    }

    /*
     * 2.创建CronTrigger对象
     * */
    @Bean
    public CronTriggerFactoryBean getCronTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
        CronTriggerFactoryBean factoryBean = new CronTriggerFactoryBean();
        //关联JobDetail对象
        factoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        //设置触发时间
        factoryBean.setCronExpression("0/2 * * * * ?");
        return factoryBean;
    }

    /*
     * 3.创建Scheduler对象
     * */
    @Bean
    public SchedulerFactoryBean getSchedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean){
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //关联Trigger对象
        factory.setTriggers(cronTriggerFactoryBean.getObject());
        return factory;
    }
}

6.Job类注入对象

1.注入对象

/*
*定时任务类
* */
public class QuartzDemo implements Job {

    @Autowired
    private UserService userService;

    /*
     *任务被触发时所执行的方法
     * */
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时器被触发："+new Date());
        //调用业务类
        this.userService.addUsers();
    }
}

2.注入时会产生异常

org.quartz.SchedulerException: Job threw an unhandled exception.
	at org.quartz.core.JobRunShell.run(JobRunShell.java:213) ~[quartz-2.2.1.jar:na]
	at org.quartz.simpl.SimpleThreadPool$WorkerThread.run(SimpleThreadPool.java:573) [quartz-2.2.1.jar:na]
Caused by: java.lang.NullPointerException: null
	at com.baizhi.scheduled.QuartzDemo.execute(QuartzDemo.java:26) ~[classes/:na]
	at org.quartz.core.JobRunShell.run(JobRunShell.java:202) ~[quartz-2.2.1.jar:na]
	... 1 common frames omitted

3.编写一个MyAdaptableJobFactory解决该问题

@Component("myAdaptableJobFactory")
public class MyAdaptableJobFactory extends AdaptableJobFactory {

    //可以将一个对象添加到Spring IOC容器中，并且完成该对象的注入
    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    //该方法需要将实例化的任务对象手动的添加到Spring IOC容器中并且完成对象的注入
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object obj = super.createJobInstance(bundle);

        //将obj对象添加到Spring IOC 容器中，并完成注入
         this.autowireCapableBeanFactory.autowireBean(obj);
        return obj;
    }
}

4.修改QuartzConfig类

/*
 * 3.创建Scheduler对象
 * */
@Bean
public SchedulerFactoryBean getSchedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean,MyAdaptableJobFactory myAdaptableJobFactory){
    SchedulerFactoryBean factory = new SchedulerFactoryBean();
    //关联Trigger对象
    factory.setTriggers(cronTriggerFactoryBean.getObject());
    //注入myAdaptableJobFactory对象调用createJobInstance完成对象实例化
    factory.setJobFactory(myAdaptableJobFactory);
    return factory;
}