springboot整合quartz

网上示例挺多的，主要注意以下几点吧：

1、quartz的主要核心就是由Scheduler类根据Triegger的任务时刻执行Job任务

2、springboot整合quartz主要核心就是能够让quartz能够在spring的管理范围内依赖注入，要不然直接写quartz多好，省时省力

一、基础配置

这一步主要是用来配置quartz框架的job工厂交由spring负责，可以依赖注入spring容器中的相关bean

先看一下基本的配置类情况吧

红框中的两个类主要就是为了将quartz框架中生成Job类实例交由spring的工厂类去生成，同时将所有quartz的配置使用原生的quartz.properties文件进行

两个类可以当做固定写法套用即可

QuartzConfiguration.java

import java.io.IOException;
import java.util.Properties;

import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.spi.JobFactory;
import org.springframework.beans.factory.config.PropertiesFactoryBean;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;
import org.springframework.scheduling.Trigger;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
/**
 * 配置相关的scheduler属性
 */
@Configuration
public class QuartzConfiguration {


	@Bean
    public JobFactory jobFactory(ApplicationContext applicationContext) {
        AutowiringSpringBeanJobFactory jobFactory = new AutowiringSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }

    //SchedulerFactoryBean
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory)
            throws IOException{
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        //把bean交给spring管理，这样Job就可以使用spring产生的bean
        factory.setJobFactory(jobFactory);
        factory.setQuartzProperties(quartzProperties());
        return factory;
    }
    @Bean
    public Scheduler scheduler(SchedulerFactoryBean jobFactory)
    		throws IOException{
    	Scheduler scheduler = jobFactory.getObject();
    	return scheduler;
    }

    /**
     * quartz的属性配置
     * @return
     * @throws IOException
     */
    @Bean
    public Properties quartzProperties() throws IOException {
        PropertiesFactoryBean propertiesFactoryBean = new PropertiesFactoryBean();

        propertiesFactoryBean.setLocation(new ClassPathResource("/quartz.properties"));

        propertiesFactoryBean.afterPropertiesSet();

        return propertiesFactoryBean.getObject();
    }



}

AutowiringSpringBeanJobFactory.java

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.scheduling.quartz.SpringBeanJobFactory;
/**
 * 用来保证job被spring容器托管，能够依赖注入
 */
public class AutowiringSpringBeanJobFactory extends SpringBeanJobFactory implements ApplicationContextAware {

    private transient AutowireCapableBeanFactory beanFactory;

    @Override
    public void setApplicationContext(final ApplicationContext context) {
        beanFactory = context.getAutowireCapableBeanFactory();
    }

    @Override
    protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
        final Object job = super.createJobInstance(bundle);
        beanFactory.autowireBean(job);
        return job;
    }
}

二、任务配置

接下来就是进行相关的job配置了，实现org.quartz.Job，依赖注入要用的相关属性或者实例bean，进行任务执行

最后就是进行任务初始化调度执行了，我这边用JobConfiguration类实现了，你们也可以使用其他方法或者将多个任务分开放在不同的类里面。

 

import java.util.Calendar;

import javax.annotation.PostConstruct;

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.TriggerBuilder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class JobConfiguration {

	@Autowired
	private Scheduler scheduler;

	@Value("${spring.screenshoot.cron}")
	private String pictureShotCron;
	@Value("${spring.dailydelete.cron}")
	private String pictureDailyDeleteCron;

	@PostConstruct
	public void init() {
		pictureShotTask();
		pictureDailyDeleteTask();
	}

	public void pictureShotTask() {
		//构建jobdetail
		JobDetail jobDetail = JobBuilder.newJob(PictureCatchTask.class).withIdentity("pictureShotJob","pictureGroup").build();

		//构建trigger
		//构建cron调度器
		CronScheduleBuilder cronSchedule = CronScheduleBuilder.cronSchedule(pictureShotCron).withMisfireHandlingInstructionDoNothing();
		//构建cron触发器
		//从整分钟开始
		Calendar ca = Calendar.getInstance();
		ca.set(Calendar.MINUTE, 0);
		ca.set(Calendar.SECOND, 0);
		System.out.println(ca.getTime());
		CronTrigger trigger = TriggerBuilder.newTrigger()
				.withIdentity("pictureShotTrigger","pictureGroup")
				.startAt(ca.getTime())
				.withSchedule(cronSchedule).build();
		//组合运行
		try {
			scheduler.scheduleJob(jobDetail, trigger);
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

	public void pictureDailyDeleteTask() {
		//构建jobdetail
		JobDetail jobDetail = JobBuilder.newJob(PictureDailyDeleteTask.class).withIdentity("pictureDailyDeleteTask","pictureGroup").build();

		//构建trigger
		//构建cron调度器
		CronScheduleBuilder cronSchedule = CronScheduleBuilder.cronSchedule(pictureDailyDeleteCron).withMisfireHandlingInstructionDoNothing();
		//构建cron触发器
		//从整分钟开始
		Calendar ca = Calendar.getInstance();
		ca.set(Calendar.MINUTE, 0);
		ca.set(Calendar.SECOND, 0);
		System.out.println(ca.getTime());
		CronTrigger trigger = TriggerBuilder.newTrigger()
				.withIdentity("pictureDailyDeleteTrigger","pictureGroup")
				.startAt(ca.getTime())
				.withSchedule(cronSchedule).build();
		//组合运行
		try {
			scheduler.scheduleJob(jobDetail, trigger);
		} catch (SchedulerException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}


}

最后全权交给相父处理即可啊！

三、参考链接

附上一个主要的参考链接：https://www.jianshu.com/p/a99b80021be6

一个延伸链接：https://www.cnblogs.com/marshwinter/p/13522068.html