springboot整合quartz最简单的应用(定时任务)

1.话不多说，先看一下项目的整体结构

2.看完后，第一步建好项目后就是导入依赖，打开pom.xml,添加如下依赖

		<!-- mybatis启动器 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.2</version>
        </dependency>
        <!--Quartz坐标-->
        <dependency>
            <groupId>org.quartz-scheduler</groupId>
            <artifactId>quartz</artifactId>
        </dependency>
        <!--定时任务需要依赖context模块-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
        </dependency>

3.从项目结构中可以看出，一共就三个主要的类，两个配置，一个job工作类
我们先写 MyAdaptableJobFactory.class

import org.quartz.spi.TriggerFiredBundle;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
import org.springframework.scheduling.quartz.AdaptableJobFactory;
import org.springframework.stereotype.Component;

/**
 * AdaptableJobFactory：作用采用反射机制创建Job实例
 * 需要重写方法：1：采用反射机制创建Job实例  2：需要将job实例手动放入到IOC容器中
 */
@Component
public class MyAdaptableJobFactory extends AdaptableJobFactory{
	//将对象添加到IOC容器中，并完成该对象的注入
	@Autowired
	AutowireCapableBeanFactory autowireCapableBeanFactory;
	
	//1：采用反射机制创建Job实例  2：需要将job实例手动放入到IOC容器中
	@Override
	protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
		Object job=super.createJobInstance(bundle);
		//job实例手动放入到Spring IOC容器中.并完成注入
		autowireCapableBeanFactory.autowireBean(job);
		return job;
	}

4.然后我们在写一个最关键的类 QuartzConfig.class

import com.yl.springbootmybatisquartz.quartz.HelloJob;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.CronTriggerFactoryBean;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;


/**
 * Quartz的配置类，创建job,trigger.scheduler的对象
 * @author yl
 */
@Configuration
public class QuartzConfig {
	//1:创建Job对象
	@Bean
	public JobDetailFactoryBean getJobDetailFactoryBean() {
		JobDetailFactoryBean  jobDetailFactory=new JobDetailFactoryBean();
		//关联自己的job
		jobDetailFactory.setJobClass(HelloJob.class);//这里的HelloJob是自己定义的工作类，名字自取
		return jobDetailFactory;
	}
	//2:corn trigger对象创建
	@Bean
	public CronTriggerFactoryBean getCronTriggerFactoryBean(JobDetailFactoryBean j) {
		CronTriggerFactoryBean factory=new CronTriggerFactoryBean();
		//关联jobDetail对象
		factory.setJobDetail(j.getObject());
		//设置触发时间cron表达式
		factory.setCronExpression("0/1 * * * * ?");
		return factory;
	}
	//3:创建Scheduler对象
	@Bean
	public SchedulerFactoryBean getSchedulerFactoryBean(
			CronTriggerFactoryBean t,MyAdaptableJobFactory myAdaptableJobFactory) {
		SchedulerFactoryBean factory=new SchedulerFactoryBean();
		//关联trigger对象
		factory.setTriggers(t.getObject());
		//重新设置job实例化工厂
		factory.setJobFactory(myAdaptableJobFactory);
		return factory;
	}
}

5.接着在写一个自己的job工作类，名字可以自己取。我这里测试就叫 HelloJob.class

import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

/**
 * @author yl
 */
public class HelloJob implements Job{
    //执行定时任务的方法
	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		System.out.println("hello, world");
	}
}

5.最后一步，就是修改一下我们的启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.scheduling.annotation.EnableScheduling;

//exclude = DataSourceAutoConfiguration.class
//设置不配置数据库,(连数据库的话就去掉,我这里测试就不连了)
@SpringBootApplication(exclude = DataSourceAutoConfiguration.class)
@EnableScheduling//开启定时任务注解
public class SpringbootQuartzApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootQuartzApplication.class, args);
    }
}

有啥问题欢迎评论，谢谢大家支持！