SpringBoot整合Quartz

1、SpringBoot1.5版本

（1）引入依赖

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

（2）编写job任务类，实现execute方法

@Slf4j
public class SyncBmiJob implements Job {

    @Resource
    private LargeAnalysisScaleService largeAnalysisScaleService;

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        log.info("执行定时任务");
        Map<String, Object> map = largeAnalysisScaleService.getMap(new QueryWrapper<LargeAnalysisScaleEntity>()
                .eq("open_id", "**********"));

        log.info(map.toString());
    }

}

（3）自定义适配器工厂类（用于解决service无法注入的问题）

@Component
public class MyAdaptableJobFactory extends AdaptableJobFactory {

    @Resource
    private AutowireCapableBeanFactory autowireCapableBeanFactory;

    @Override
    protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
        Job jobInstance = bundle.getJobDetail().getJobClass().newInstance();
        autowireCapableBeanFactory.autowireBean(jobInstance);
        return jobInstance;
    }
}

（4）编写定时任务配置类

@Configuration
public class QuartzConfig {

    /**
     * BMI数据同步(创建job对象)
     *
     * @return
     */
    @Bean
    public JobDetailFactoryBean syncBmiJobDetail() {
        JobDetailFactoryBean factoryBean = new JobDetailFactoryBean();
        factoryBean.setJobClass(SyncBmiJob.class);
        return factoryBean;
    }

    /**
     * BMI数据同步触发器(创建cron trigger)
     *
     * @param factoryBean
     * @return
     */
    @Bean
    public CronTriggerFactoryBean syncBmiJobTrigger(JobDetailFactoryBean factoryBean) {
        CronTriggerFactoryBean cron = new CronTriggerFactoryBean();
        // 关联jobDetail
        cron.setJobDetail(factoryBean.getObject());

        // 设置触发时间(每10秒触发一次)
        cron.setCronExpression("0/10 * * * * ?");
        return cron;
    }

    /**
     * 创建scheduler对象
     * 
     * @param triggerFactoryBean
     * @param myAdaptableJobFactory
     * @return
     */
    @Bean
    public SchedulerFactoryBean syncBmiSchedule(CronTriggerFactoryBean triggerFactoryBean, MyAdaptableJobFactory myAdaptableJobFactory) {
        SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
        // 关联trigger
        factoryBean.setTriggers(triggerFactoryBean.getObject());

        // 重新设置工厂类
        factoryBean.setJobFactory(myAdaptableJobFactory);
        return factoryBean;
    }
}

（5）开启定时任务

启动类上加上注解@EnableScheduling

2、SpringBoot2.0及以上版本

（1）引入依赖

<!-- quartz任务调度 -->
<dependency>
	<groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-quartz</artifactId>
</dependency>

（2）编写job任务类，重写executeInternal方法

@Component
@Slf4j
public class IssueUserJob extends QuartzJobBean {

    @Resource
    private StaffService staffService;
    @Resource
    private EmployeeService employeeService;

    @Override
    protected void executeInternal(JobExecutionContext context) {
    	log.info("执行定时任务");
    }
}

（3）编写定时任务配置类

@Configuration
public class QuartzConfig {
    private static final String USER_JOB_GROUP_NAME = "USER_JOB_GROUP_NAME";
    private static final String USER_TRIGGER_GROUP_NAME = "USER_TRIGGER_GROUP_NAME";

    /**
     * 员工信息下发(任务详情)
     * @return
     */
    @Bean
    public JobDetail issueUserJobDetail() {
        return JobBuilder.newJob(IssueUserJob.class)
                .withIdentity("issueUserJobDetail", USER_JOB_GROUP_NAME)
                .storeDurably()
                .build();
    }

    /**
     * 员工信息下发(触发器)
     * @return
     */
    @Bean
    public Trigger issueUserJobTrigger() {
        // 每10分钟执行一次
        CronScheduleBuilder cronScheduleBuilder = CronScheduleBuilder.cronSchedule("0 0/10 * * * ? ");

        //创建触发器
        return TriggerBuilder.newTrigger()
                .forJob(issueUserJobDetail()) //关联JobDetail
                .withIdentity("issueUserJobTrigger", USER_TRIGGER_GROUP_NAME)
                .withSchedule(cronScheduleBuilder) //关联调度器
                .build();
    }
}