quartz初步认识。

项目需要，动态的配置定时任务。因此，使用quartz 来完成定时任务功能。

网上入门基础，教程，都有很多，我只说一下我的理解和思路。

例子，链接：http://download.csdn.net/detail/u012246342/9853008

1、什么是任务（任务类）

定时任务，肯定，离不开任务。什么是任务？

任务就是一个实现了 Job 接口，并且重写了execute 方法，或者继承自QuartzJobBean 并重写executeInternal(根本上，等于继承自job接口) 的类。

这个类，可以理解为，任务执行类。启动定时任务，就是设置时间，定时启动，这个类中的execute(executeInternal) 方法。

代码如图下：

import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

import quartz.cn.digitalpublishing.model.ScheduleJob;
import quartz.cn.digitalpublishing.vo.ScheduleJobVo;

/**
 * author : fengjing
 * createTime : 2016-08-04
 * description : 异步任务工厂
 * version : 1.0
 */
public class AsyncJobFactory extends QuartzJobBean {

    /* 日志对象 */
    private static final Logger LOG = LoggerFactory.getLogger(AsyncJobFactory.class);
    @Override
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        LOG.info("AsyncJobFactory execute");
        ScheduleJob scheduleJob = (ScheduleJob) context.getMergedJobDataMap().get(ScheduleJobVo.JOB_PARAM_KEY);
        System.out.println("jobName:" + scheduleJob.getJobName() + "  " + scheduleJob);
    }
}

代码中，executeInternal 方法，就是每次启动定时任务，需要执行的方法。这个类，就是一个任务类。

其他的，就是从头开始配置了。这里有个例子，链接：http://download.csdn.net/detail/u012246342/9853008

1、spring.xml 配置。

2、ScheduleJobInit 的 init 方法设置，项目启动后执行。

3、ScheduleUtils 的createScheduleJob 的方法，在启动后，创建定时任务。

其中，ScheduleJob 类，属于，任务计划模型，包括一系列任务执行需要的参数。

2、如何在quartz 中，访问controller ，或者，在定时任务中，访问网络请求。

首先，启动一个定时任务，就等于执行一次execute 方法。所以，在任务工厂类的executeInternal 中，通过 httpclient 访问你所需要执行的 url就可以了。

代码如下：

import java.io.IOException;

import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.JobDataMap;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import org.quartz.PersistJobDataAfterExecution;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.scheduling.quartz.QuartzJobBean;

import quartz.cn.digitalpublishing.model.ScheduleJob;
import quartz.cn.digitalpublishing.vo.ScheduleJobVo;

/**
 * author : fengjing
 * createTime : 2016-08-04
 * description : 同步任务工厂
 * version : 1.0
 */
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class SyncJobFactory extends QuartzJobBean {

    /* 日志对象 */
    private static final Logger LOG = LoggerFactory.getLogger(SyncJobFactory.class);

    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {
        LOG.info("SyncJobFactory execute");
        JobDataMap mergedJobDataMap = context.getMergedJobDataMap();
        ScheduleJob scheduleJob = (ScheduleJob) mergedJobDataMap.get(ScheduleJobVo.JOB_PARAM_KEY);
        
        System.out.println("jobName:" + scheduleJob.getJobName() + "  " + scheduleJob);
        
        String url = scheduleJob.getUrl();
        CloseableHttpClient httpclient = HttpClients.createDefault();
        HttpGet httpGet = new HttpGet(url);
        CloseableHttpResponse response;
        try {
            response = httpclient.execute(httpGet);
            System.out.println(response.getStatusLine());
            HttpEntity entity = response.getEntity();
            EntityUtils.consume(entity);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3、给quartz定时任务，传递参数的问题。

如图下：

quartz初步认识。

代码如下：

/**
     * 创建定时任务
     *
     * @param scheduler the scheduler
     * @param jobName the job name
     * @param jobGroup the job group
     * @param cronExpression the cron expression
     * @param isSync the is sync
     * @param param the param
     */
    public static void createScheduleJob(Scheduler scheduler, String jobName, String jobGroup, String cronExpression, boolean isSync, Object param)throws Exception {
        //同步或异步
        Class<? extends Job> jobClass = isSync ? AsyncJobFactory.class : SyncJobFactory.class;

        //构建job信息
        JobDetail jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobName, jobGroup).build();

        //表达式调度构建器
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cronExpression);

        //按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(jobName, jobGroup).withSchedule(scheduleBuilder).build();

        String jobTrigger = trigger.getKey().getName();

        ScheduleJob scheduleJob = (ScheduleJob)param;
        scheduleJob.setJobTrigger(jobTrigger);

        //放入参数，运行时的方法可以获取
        jobDetail.getJobDataMap().put(ScheduleJobVo.JOB_PARAM_KEY, scheduleJob);

        try {
        	Boolean is = scheduler.isStarted();
            scheduler.scheduleJob(jobDetail, trigger);
            
        } catch (SchedulerException e) {
            LOG.error("创建定时任务失败", e);
            e.printStackTrace();
            throw new Exception("创建定时任务失败");
        }
    }

所以，现在可以看懂，代码片段1 ，和代码片段 2 中的

ScheduleJob scheduleJob = (ScheduleJob) mergedJobDataMap.get(ScheduleJobVo.JOB_PARAM_KEY);

是从哪来的了吧。

如果还有任何关于 quartz 的疑问，欢迎加：Quartz任务调度器交流77383408。

相关推荐