springboot整合quartz

maven依赖。第三个好像jpa的依赖里就包含了。所以如果有用jpa可以不用单独引入了。

    <dependency>
      <groupId>org.quartz-scheduler</groupId>
      <artifactId>quartz</artifactId>
      <version>2.2.3</version>
    </dependency>
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context-support</artifactId>
      <version>4.3.3.RELEASE</version>
    </dependency>
    <dependency>
       <groupId>org.springframework</groupId>
       <artifactId>spring-tx</artifactId>
       <version>5.0.0.RELEASE</version>
    </dependency>

Scheduler配置，SpringBoot2.x以上版本spring-boot-autoconfigure包中包含了QuartzAutoConfiguration，所以如果是SpringBoot2.x可以不用写这个类。

package cn.com.swvip.config;

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

import java.io.IOException;

/**
 * Created by hsuyung on 2018/7/18.
 */
@Configuration
public class SchedulerConfig {

    @Bean(name="SchedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean() throws IOException {
        SchedulerFactoryBean factory = new SchedulerFactoryBean();
        return factory;
    }

}

SpringContextUtils工具类，在后面的Job实现类中用来实例化对象， 如果是SpringBoot2.x可以不用写这个类。

package cn.com.swvip.config;

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * Created by hsuyung on 2018/7/18.
 */
@Component
public class SpringContextUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext= applicationContext;
    }

    public static <T> T getBeanByClass(Class c){
        return applicationContext.getBean((Class<T>) c);
    }
}

BaseJobManager类，设置定时最主要的部分。注释写很清楚了。

package cn.com.swvip.schedule;

import org.quartz.*;

import javax.annotation.Resource;

/**
 * Created by huangping on 24/10/2016.
 */
public abstract class BaseJobManager {

    private final String JOB_NAME = "BaseJob";
    private final String GROUP_NAME = "SwvipJobGroup";

    @Resource
    private Scheduler scheduler;

    public abstract String getJobName();

    public abstract Class <? extends Job> getJobClass();

    /**
     * 根据crontab设置任务
     * @param cron
     * @return 设置结果
     */
    public int setupJob(String cron) {

        int result = 0;

        try {
            TriggerKey triggerKey = TriggerKey.triggerKey(getJobName(), GROUP_NAME);

            //获取trigger，这里我们使用cron的方式，还有比较常用的如SimpleTrigger
            CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);

            //不存在，创建一个
            if (trigger == null) {
                JobDetail jobDetail = JobBuilder.newJob(getJobClass())
                        .withIdentity(getJobName(), GROUP_NAME).build();

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

                //按新的cronExpression表达式构建一个新的trigger
                trigger = TriggerBuilder.newTrigger().withIdentity(getJobName(), GROUP_NAME)
                        .withSchedule(scheduleBuilder).build();
                scheduler.scheduleJob(jobDetail, trigger);
            } else {
                // Trigger已存在，那么更新相应的定时设置
                //表达式调度构建器
                CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(cron);

                //按新的cronExpression表达式重新构建trigger
                trigger = trigger.getTriggerBuilder().withIdentity(triggerKey)
                        .withSchedule(scheduleBuilder).build();

                //按新的trigger重新设置job执行
                scheduler.rescheduleJob(triggerKey, trigger);
            }
        } catch (SchedulerException e) {
            result = -1;
            e.printStackTrace();
        }

        return result;
    }
}

 LimitTimeSaleEndJobManager

package cn.com.swvip.schedule;

import org.quartz.Job;
import org.springframework.context.annotation.DependsOn;
import org.springframework.stereotype.Component;

/**
 * Created by zhangxt on 18-7-23
 */
@Component
@DependsOn({"springContextUtils"})
public class LimitTimeSaleEndJobManager extends BaseJobManager{
    @Override
    public String getJobName() {
        return this.getClass().getSimpleName();
    }

    @Override
    public Class<? extends Job> getJobClass() {
        return LimitTimeSaleEndJob.class;
    }
}

 LimitTimeSaleEndJob继承Job。到设定的时间执行execute里的代码。

需要注意的地方是，如果是SpringBoot2.x以前版本，用注解的方式无法注入对象， 所以用上面写的SpringContextUtils类来实例化对象（代码中注释语句）。

package cn.com.swvip.schedule;

import cn.com.swvip.config.SpringContextUtils;
import cn.com.swvip.service.LimitTimeSaleEndService;
import org.quartz.DisallowConcurrentExecution;
import org.quartz.Job;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;

import java.util.Date;

/**
 * Created by zhangxt on 18-7-23
 */
@DisallowConcurrentExecution
public class LimitTimeSaleEndJob implements Job {
    //private LimitTimeSaleEndService limitTimeSaleEndService = SpringContextUtils.getBeanByClass(LimitTimeSaleEndService.class);

    @Resource
    LimitTimeSaleEndService limitTimeSaleEndService；
    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        Date date = new Date();
        limitTimeSaleEndService.run(date);

    }
}

LimitTimeSaleEndService和LimitTimeSaleEndServiceImpl 就不贴代码了，定时执行的业务代码，当然可以直接写在execute方法里，为了代码层次我们放到service里面。

调用

String str = "0 0 0 2 8 ? 2018"; //cron
limitTimeSaleEndJobManager.setupJob(str);