Springboot1.5学习12——Spring Boot定时任务支持(Quartz)

使用quartz步骤很简单,概括来说,分为三步;

1)job - 任务 - 你要做什么事?

2)Trigger - 触发器 - 你什么时候去做?

3)Scheduler - 任务调度 - 你什么时候需要去做什么事?

例如:

public class QuartzMain {
	public static void main(String[] args) throws Exception {
		// 1.创建 Job 对象: 你要做什么事?
		JobDetail job = JobBuilder.newJob(QuartzDemo .class).build();

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

		// 3.创建 Scheduler 对象: 在什么时间做什么事?
		Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
		scheduler.scheduleJob(job, trigger);
		//启动
		scheduler.start();
	}
}

注意:QuartzDemo 就是我们自定义的job任务

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

1. boot整合quartz操作步骤

1.1 引入依赖

咱们需要引入三个坐标,如下;



	org.quartz-scheduler
	quartz
	2.2.1
	
		
			slf4j-api
			org.slf4j
		
	



	org.springframework
	spring-context-support



	org.springframework
	spring-tx

1.2 定义Job任务类

/**Job类
 * @author Administrator
 *
 */
public class MyTask implements Job{

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

1.3 定义quartz配置类

package com.bjc.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.quartz.JobDetailFactoryBean;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.scheduling.quartz.SimpleTriggerFactoryBean;

import com.bjc.scheduled.MyTask;

/**quartz的配置类
 * @author Administrator
 *
 */
@Configuration
public class Quartzconfig {
	/**
	 * 1. 创建Job对象
	 * */
	@Bean
	public JobDetailFactoryBean jobDetailFactoryBean() {
		JobDetailFactoryBean factory = new JobDetailFactoryBean();
		// 关联Job任务类
		factory.setJobClass(MyTask.class);
		return factory;
	}
	
	/**
	 *     2. 创建简单的trigger对象
	 * */
	@Bean
	public SimpleTriggerFactoryBean simpleFactory(JobDetailFactoryBean factory) {
		SimpleTriggerFactoryBean simple = new SimpleTriggerFactoryBean();
		// 2.1 关联JobDetail对象
		simple.setJobDetail(factory.getObject());
		
		// 2.2 设置触发时间  参数表示一个执行的毫秒数
		simple.setRepeatInterval(2000);
		
		// 可选操作
		// 设置重复次数
		simple.setRepeatCount(10);
		return simple;
	}
	
	/**
	 *    3. 创建scheduler对象
	 * */
	@Bean
	public SchedulerFactoryBean schedulerFactoryBean(SimpleTriggerFactoryBean triggerFactory) {
		SchedulerFactoryBean factory = new SchedulerFactoryBean();
		// 1. 关联trigger
		factory.setTriggers(triggerFactory.getObject());
		
		return factory;
	}
	
}

1.4 开启定时任务——@EnableScheduling

在启动类上加上注解@EnableScheduling

如图:

Springboot1.5学习12——Spring Boot定时任务支持(Quartz)_第1张图片

运行启动类,定时任务就启动了。

2. 使用cron定时器

上例中使用的是简单的定时器,要实现cron定时器很简单

1)将配置对象的第二步替换成下面的代码即可,例如;

@Bean
public CronTriggerFactoryBean cronTrigger(JobDetailFactoryBean factory) {
	CronTriggerFactoryBean cron = new CronTriggerFactoryBean();
	// 2.1 关联jobDetail
	cron.setJobDetail(factory.getObject());
	// 2.2 设置触发时间
	cron.setCronExpression("0/2 * * * * ?");
	
	return cron;
}

2)将第三步中的参数替换成CronTriggerFactoryBean

运行程序,定时器正常运行

Springboot1.5学习12——Spring Boot定时任务支持(Quartz)_第2张图片

3. Job类对象注入

我们编写一个service类,在任务类注入该service,如图:

Springboot1.5学习12——Spring Boot定时任务支持(Quartz)_第3张图片

运行,发现报了空指针异常,

这是为什么了?为什么这里service没有注入进去了?这是因为在我们的quartz配置对象中,在setJobClass实例化我们的job任务的时候,使用的是一个适配器类AdaptableJobFactory,在这里有一个方法

protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
	return bundle.getJobDetail().getJobClass().newInstance();
}

我们可以看到,这个方法很简单,就是拿我们传递过来的字节码通过反射的机制创建的对象,这也就意味着,现在我们的任务类并没有被spring管理,也就是说spring的IOC容器并没有管理我们的任务类,所以就无法完成注入了,所以导致null异常的出现。因为spring的注入要求注入的对象与被注入的对象均在springIOC容器中存在。那么,我们怎么将我们的人物类交给spring容器管理了?我们可以自定义一个适配器工厂类,继承AdaptableJobFactory,重写createJobInstance方法,然后使用AutowireCapableBeanFactory将创建的对象对象手动注入到spring容器中,例如:

package com.bjc.scheduled;

import javax.annotation.Resource;

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

// 加上@Component注解,让该适配器对象实例化
@Component("myAdaptableJobFactory")
public class MyAdaptableJobFactory extends AdaptableJobFactory{
	
	// 该对象可以将一个对象添加到Spring的IOC容器中,并且完成该对象的属性注入
	@Resource
	private AutowireCapableBeanFactory autowireCapableBeanFactory;
	
	/**
	 *  该方法需要将实例化的任务对象手动的添加到IOC容器中,并完成对象的注入
	 */
	@Override
	protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
		Job newInstance = bundle.getJobDetail().getJobClass().newInstance();
		// 将创建的对象添加到SpringIOC容器中,并完成属性注入
		autowireCapableBeanFactory.autowireBean(newInstance);
		// 返回对象
		return newInstance;
	}
	
}

重写了适配器工厂类,怎么使用了?SchedulerFactoryBean对象允许重新设置一个工厂类,例如:

/**
 *    3. 创建scheduler对象
 * */
@Bean
public SchedulerFactoryBean schedulerFactoryBean(CronTriggerFactoryBean triggerFactory,MyAdaptableJobFactory myAdaptableJobFactory) {
	SchedulerFactoryBean factory = new SchedulerFactoryBean();
	// 1. 关联trigger
	factory.setTriggers(triggerFactory.getObject());
	// 2. 重新设置工厂类
	factory.setJobFactory(myAdaptableJobFactory);
	return factory;
}

注意:schedulerFactoryBean方法新增一个参数,参数就是我们自定义的适配器工厂类,然后通过setJobFactory将该参数对象设置进去。

你可能感兴趣的:(#,springboot初探)