quartz在项目中的定时任务实现

quartz简介

Quartz是一个完全由java编写的开源作业调度框架。不要让作业调度这个术语吓着你。尽管Quartz框架整合了许多额外功能， 但还是相对而言比较简单的。简创建一个实现org.quartz.Job接口的java类。Job接口包含唯一的方法：

public void execute(JobExecutionContext context)
throws JobExecutionException;

在你的Job接口实现类里面，添加一些逻辑到execute()方法。一旦你配置好Job实现类并设定好调度时间表，Quartz将密切注意剩余时间。当调度程序确定该是通知你的作业的时候，Quartz框架将调用你Job实现类（作业类）上的execute()方法并允许做它该做的事情。无需报告任何东西给调度器或调用任何特定的东西。仅仅执行任务和结束任务即可。如果配置你的作业在随后再次被调用，Quartz框架将在恰当的时间再次调用它（简介来源）。

quartz管理类

定时任务的启动主要包含以下五步：

1. 创建一个JobDetail实例
2. 定义一个Trigger（触发器）
3. 创建scheduler
4. 将trigger和jobdetail加入scheduler中
5. 启动scheduler

在quartz使用之前，需要在pom.xml里面添加如下dependency：

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-quartz</artifactId>
		</dependency>

以下是quartz定时任务的工具类代码：

import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.Job;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.TriggerBuilder;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;

public class QuartzManageKit {
	
	public void startJob(Class<TestJob> clazz,String groupName,String planName,String cron) {
		try {
            // 1. 创建一个JobDetail实例
            JobDetail jobDetail = JobBuilder.newJob(clazz) // 定义Job类为传递过来实现了job的类，这是真正的执行逻辑所在
                    .withIdentity(groupName) // 定义name/group
                    .build();

            // 2. 定义一个Trigger，执行的时间间隔由参数决定
            CronTrigger trigger = (CronTrigger) TriggerBuilder.newTrigger()
                    .withIdentity(planName, groupName)// 定义名字和组
                    .withSchedule(    //定义任务调度的时间间隔和次数
                            CronScheduleBuilder
                            .cronSchedule(cron)
                            )
                    .build();

            // 3. 创建scheduler
            SchedulerFactory sfact = new StdSchedulerFactory();
            Scheduler scheduler = sfact.getScheduler();

            // 4. 将trigger和jobdetail加入这个调度
            scheduler.scheduleJob(jobDetail, trigger);

            // 5. 启动scheduler
            scheduler.start();

        } catch (Exception e) {
            e.printStackTrace();
        }
	}

}

除了工具类，quartz还需要一个AdaptableJobFactory的继承类，否则Job的作业类中无法注入由Spring容器所管理的Bean。具体的AdaptableJobFactory继承类代码如下：

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;

@Component
public class MyJobFactory extends AdaptableJobFactory {

	@Autowired
	private AutowireCapableBeanFactory capableBeanFactory;

	protected Object createJobInstance(TriggerFiredBundle bundle) throws Exception {
		Object jobInstance = super.createJobInstance(bundle);
		capableBeanFactory.autowireBean(jobInstance);
		return jobInstance;
	}

}

监听器的选择与说明

本次示例使用的监听器是实现ApplicationListener的方式。
ApplicationListener是通过指定泛型，确定其监听器执行的方式和时机，在相应的调用时机回调实现该接口的类。
本次示例选用ContextRefreshedEvent事件泛型，即在context初始化或者改变的时候调用当前实现ApplicationListener监听器中的onApplicationEvent方法。以下是监听器的具体实现代码：

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Transactional;

import com.es.quartz.MyJobFactory;
import com.es.quartz.QuartzManageKit;
import com.es.quartz.TestJob;

@Configuration
@Component
@Transactional
public class StartQuartzJobListener implements ApplicationListener<ContextRefreshedEvent> {

		private static final Logger logger = LoggerFactory.getLogger(StartQuartzJobListener.class);

		/* quartz */

		@Autowired
		private MyJobFactory myJobFactory;

		/** 
		 * 初始启动quartz
		 */
		@Override 
		public void onApplicationEvent(ContextRefreshedEvent event) {
			logger.debug("定时任务监听器启动");
			try {
				QuartzManageKit quartz = new QuartzManageKit();
				quartz.startJob(TestJob.class, "TestJob ", "TestJob ", "0/10 * * * * ? ");
			} catch (Exception e) {
				e.printStackTrace();   
			}
		} 
		/**
		 * @title:修改默认的jobFactory 支持Job中注入
		 */
		@Bean
		public SchedulerFactoryBean schedulerFactoryBean () throws Exception {
			SchedulerFactoryBean factoryBean = new SchedulerFactoryBean();
			factoryBean.setOverwriteExistingJobs(true);
			//延时启动20秒
			factoryBean.setStartupDelay(20);
			factoryBean.setJobFactory(myJobFactory);
			return factoryBean;
		}

}

其中startJob类中的参数传递给工具类需要执行的任务类、任务组名称、任务名称和定时任务的执行时间。

当前的定时任务触发器我选择的CronTrigger ，即需要执行的时间需要用crontab表达式控制。
crontab表达式从左到右依次表示：秒 分 时 日 月 周
示例：

crontab表达式	描述
0 0 10 * * ?	每天早上10点执行任务
0 30 10 1 * ?	每月1号早上10：30执行任务

所以 0/10 * * * * ? 表示的是每10秒执行一次定时任务，即在每十秒，quartz就会调用一次实现了Job类的TestJob中的execute()方法。

Job的实现

Quartz框架在需要执行定时任务的时候，会调用你Job实现类（作业类）上的execute()方法实现方法中的业务逻辑。

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

public class TestJob implements Job{
	@Override
	public void execute(JobExecutionContext context) throws JobExecutionException {
		System.out.println("TestJob.execute("+ new Date().toLocaleString() +")");
	}
	
}

项目启动

这时，所有的准备工作都已做好，只需要启动当前的项目即可触发监听器的监听规则，启动定时任务开始执行job实现类的业务。
本次示例使用springboot启动，具体实现如下：

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {

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

}

当然，以上方法使用主方法启动也可以，具体实现方式如下：

public class JobMain {

    public static void main(String[] args) {
    	QuartzManageKit quartz = new QuartzManageKit();
    	quartz.startJob(TestJob.class, "testJob", "testJob", "0/10 * * * * ?");
    }
    
}

执行结果展示

启动项目或主方法之后，即可在控制台看到如下打印。如此，定时任务已经实现。