Quartz任务调度以及在Job类中无法Autowired其他类问题

一、Quartz概述

Quartz是OpenSymphony开源组织在Job scheduling领域又一个开源项目，它可以与J2EE与J2SE应用程序相结合也可以单独使用。Quartz可以用来创建简单或为运行十个，百个，甚至是好几万个Jobs这样复杂的程序。Jobs可以做成标准的Java组件或 EJBs。Quartz的最新版本为Quartz 2.3.2。Quartz是一个完全由java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能， 但就其简易形式看，你会发现它易用得简直让人受不了！简单地创建一个实现org.quartz.Job接口的java类。Job接口包含唯一的方法：public void execute(JobExecutionContext context)throws JobExecutionException;在你的Job接口实现类里面，添加一些逻辑到execute()方法。一旦你配置好Job实现类并设定好调度时间表，Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候，Quartz框架将调用你Job实现类（作业类）上的execute()方法并允许做它该做的事情。无需报告任何东西给调度器或调用任何特定的东西。仅仅执行任务和结束任务即可。如果配置你的作业在随后再次被调用，Quartz框架将在恰当的时间再次调用它。

二、SpringBoot与Quartz整合

依赖引入

		<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>5.2.1.RELEASE</version>
        </dependency>

由quartz的设计思想而知，quartz的任务调度离不开三个组件，分别是Job（任务，具体某一时刻要执行的业务逻辑）、Trigger（触发器，声明执行的时刻，可以用cron表达式）、Scheduled（根据Trigger的触发时间来执行Job）。

声明Job类

public class UserServiceJob implements Job{

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时任务执行" + new Date());
    }
}

这个类实现了Job接口，重接接口的execute，execute方法体中的代码就是定时被执行的代码。

声明一个配置类

@Configuration
public class QuartzConfig {


    @Bean
    public JobDetailFactoryBean jobDetailFactoryBean(){
        JobDetailFactoryBean jobDetailFactoryBean = new JobDetailFactoryBean();
        jobDetailFactoryBean.setJobClass(UserServiceJob.class);
        return jobDetailFactoryBean;
    }

    /**创建Trigger对象，
    	SimpleTriggerFactoryBean
    */
    @Bean
    public SimpleTriggerFactoryBean simpleTriggerFactoryBean(JobDetailFactoryBean jobDetailFactoryBean){
        SimpleTriggerFactoryBean simpleTriggerFactoryBean = new SimpleTriggerFactoryBean();
        simpleTriggerFactoryBean.setJobDetail(jobDetailFactoryBean.getObject());
        simpleTriggerFactoryBean.setRepeatInterval(2000); //每2000毫秒执行一次
        simpleTriggerFactoryBean.setRepeatCount(5); //执行5次
        return simpleTriggerFactoryBean;
    }


    //创建调度器
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean){
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setTriggers(cronTriggerFactoryBean.getObject());
        return schedulerFactoryBean;
    }

*SimpleTriggerFactoryBean是一个简易的触发器配置规则，其主要方法如下：

主启动类标注@EnableScheduling注解

启动日志：根据时间看出，确实是每隔两秒执行一次

三、异常出现

定义一个service类

@Service
public class UserService {

    public void addUser(){
        System.out.println("添加用户成功");
    }
}

在Job类中注入

public class UserServiceJob implements Job{

    @Autowired
    private UserService userService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        System.out.println("定时任务执行" + new Date());
        userService.addUser();
    }
}

再次启动程序查看日志

结果报了空指针异常，也就是userService为null

原因：
在jobDetailFactoryBean.setJobClass(UserServiceJob.class);
是通过反射创建UserServiceJob对象的，并没有经过Spring去管理Spring框架注入对象要求注入的对象和被注入的对象都要实例化，所以不仅要创建对象还要加入Spring容器中。

解决
定义一个类继承AdaptableJobFactory，重写其protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception{}方法，在创建对象后，加入spring容器中再返回。

@Component("quartzAdaptableFactory")
public class QuartzAdaptableFactory extends AdaptableJobFactory {

    @Autowired
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    /**
     * 由于该方法只是通过反射创建了一个实例对象，并没有加入Spring的容器中
     * 所以我们要手动加入Spring容器
     * @param bundle
     * @return
     * @throws Exception
     */
    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Object ob = super.createJobInstance(bundle);
        autowireCapableBeanFactory.autowireBean(ob); //注入到容器中
        return ob;
    }

}

同时修改调度器的配置

    //创建调度器,重设JobFactory
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean cronTriggerFactoryBean,QuartzAdaptableFactory quartzAdaptableFactory){
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        schedulerFactoryBean.setJobFactory(quartzAdaptableFactory);
        schedulerFactoryBean.setTriggers(cronTriggerFactoryBean.getObject());
        return schedulerFactoryBean;
    }

重启查看日志：

四、cron表达式的写法

 /**
     *  0/2 表示每隔2秒执行一次
     *
     */
    //@Scheduled(cron = "0/2 * * * * ?")
    public void task(){
        System.out.println("定时任务执行");
    }

    /**
     * 8月20日 9：24分后每两秒执行一次
     */
    //@Scheduled(cron = "0/2 24 9 20 8 ?")
    public void task1(){
        System.out.println("定时任务执行" + new Date().toString());
    }

    /**
     * 8月20日 9：26分0秒执行一次
     */
    //@Scheduled(cron = "0 26 9 20 8 ?")
    public void task2(){
        System.out.println("定时任务执行" + new Date().toString());
    }

    /**
     * 一般cron表达式第四位或第六位有一位是 ?，
     * 第四位的取值取决于第五位，第五位代表月份，第四位代表每月的几号，而第六位是每周的周几
     * 注意，0代表周日，1代表周一
     * cron = "0 29 9 ? 8 5" 8月份每周周四的9:29分执行
     */
    //@Scheduled(cron = "0 31 9 ? 8 5")
    public void task3(){
        System.out.println("定时任务执行" + new Date().toString());
    }

    /**
     * cron = "0 30/2 9 * 8 ?" 8月的每天9:30分开始 每隔两分钟执行一次
     */
    //@Scheduled(cron = "0 30/2 9 * 8 ?")
    public void task9(){
        System.out.println("定时任务执行" + new Date().toString());
    }

    /**
     * 范围区间
     * 8月份每天9：35分的10秒-20秒执行，执行10次
     */
    //@Scheduled(cron = "10-20 35 9 * 8 ?")
    public void task4(){
        System.out.println("定时任务执行" + new Date().toString());
    }

    /**
     * 列表值
     * 8月份每天9：37分的10秒、12秒、16秒执行，执行3次
     */
    //@Scheduled(cron = "10,12,16 37 9 * 8 ?")
    public void task5(){
        System.out.println("定时任务执行" + new Date().toString());
    }

在线生成cron表达式：https://cron.qqe2.com/