【springboot-01】整合quartz

/**
 * 分布式定时任务quartz配置
 * Created by chenjunyi on 2018/6/6.
 */
@Configuration
public class QuartzConfiguration {

    /**
     * quartz的JobFactory，根据注册的JobClass从spring应用上下文中获取job实例
     */
    public static class AutoSpringBeanJobFactory extends AdaptableJobFactory implements SchedulerContextAware {

        /** spring应用上下文 */
        private ApplicationContext applicationContext;

        /** scheduler上下文 */
        private SchedulerContext   schedulerContext;

        /** 需要忽略的属性 */
        private String[]           ignoredUnknownProperties = null;

        private void setApplicationContext(ApplicationContext applicationContext) {
            this.applicationContext = applicationContext;
        }

        @Override
        public void setSchedulerContext(SchedulerContext schedulerContext) {
            this.schedulerContext = schedulerContext;
        }

        private void setIgnoredUnknownProperties(String... ignoredUnknownProperties) {
            this.ignoredUnknownProperties = ignoredUnknownProperties;
        }

        @Override
        protected Object createJobInstance(final TriggerFiredBundle bundle) throws Exception {
            //获取定时任务的clazz，并从spring上下文中获取实例
            Class<? extends Job> clazz = bundle.getJobDetail().getJobClass();
            Job job = applicationContext.getBean(clazz);

            if (isEligibleForPropertyPopulation(job)) {
                //非继承自QuartzJobBean的Job，设置job属性
                BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(job);
                MutablePropertyValues pvs = new MutablePropertyValues();
                if (this.schedulerContext != null) {
                    pvs.addPropertyValues(this.schedulerContext);
                }
                pvs.addPropertyValues(bundle.getJobDetail().getJobDataMap());
                pvs.addPropertyValues(bundle.getTrigger().getJobDataMap());
                if (this.ignoredUnknownProperties != null) {
                    for (String propName : this.ignoredUnknownProperties) {
                        if (pvs.contains(propName) && !bw.isWritableProperty(propName)) {
                            pvs.removePropertyValue(propName);
                        }
                    }
                    bw.setPropertyValues(pvs);
                } else {
                    bw.setPropertyValues(pvs, true);
                }
            }
            return job;
        }

        private boolean isEligibleForPropertyPopulation(Object jobObject) {
            return (!(jobObject instanceof QuartzJobBean));
        }

    }

    /**
     * 配置任务工厂实例
     * @param applicationContext spring上下文实例
     * @return 任务工厂实例
     */
    @Bean
    public JobFactory jobFactory(ApplicationContext applicationContext) {
        AutoSpringBeanJobFactory jobFactory = new AutoSpringBeanJobFactory();
        jobFactory.setApplicationContext(applicationContext);
        return jobFactory;
    }

    /**
     * 配置任务调度器，使用项目数据源作为quartz数据源
     * @param jobFactory 自定义配置任务工厂
     * @param dataSource 数据源实例
     * @return 任务调度器
     */
    @Bean
    public SchedulerFactoryBean schedulerFactoryBean(JobFactory jobFactory, DataSource dataSource) {
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        //将spring管理job自定义工厂交由调度器维护
        schedulerFactoryBean.setJobFactory(jobFactory);
        //设置覆盖已存在的任务（配置已失效，因为改写了原有的注册方式，JOB注册时便已自动进行替换）
        schedulerFactoryBean.setOverwriteExistingJobs(true);
        //项目启动完成后，等待50秒后开始执行调度器初始化（需要小于JOB的间隔时间）
        schedulerFactoryBean.setStartupDelay(50);
        //设置调度器自动运行
        schedulerFactoryBean.setAutoStartup(true);
        //设置数据源，使用与项目统一数据源
        schedulerFactoryBean.setDataSource(dataSource);
        //设置定时调度器命名空间
        schedulerFactoryBean.setSchedulerName("MY-QUARTZ-SCHEDULER");
        //设置存储在quartz上文中的Spring应用上下文key
        schedulerFactoryBean.setApplicationContextSchedulerContextKey("applicationContext");
        //设置属性
        Properties properties = new Properties();
        //设置调度器实例名
        properties.setProperty("org.quartz.scheduler.instanceName", "SCHEDULER-INSTANCE");
        //设置调度器实例ID，在cluster中使用，AUTO标识自动生成
        properties.setProperty("org.quartz.scheduler.instanceId", "AUTO");
        //禁用rmi配置
        properties.setProperty("org.quartz.scheduler.rmi.export", "false");
        //禁用rmi配置
        properties.setProperty("org.quartz.scheduler.rmi.proxy", "false");
        //quartz线程池实现类
        properties.setProperty("org.quartz.threadPool.class", "org.quartz.simpl.SimpleThreadPool");
        //quartz线程池线程数
        properties.setProperty("org.quartz.threadPool.threadCount", "10");
        //quartz线程池线程优先级
        properties.setProperty("org.quartz.threadPool.threadPriority", "5");
        //quartz线程池是否自动加载数据库内的定时任务
        properties.setProperty("org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread", "true");
        //Job错过执行时间的阈值
        properties.setProperty("org.quartz.jobStore.misfireThreshold", "60000");
        //Job持久化方式配置
        properties.setProperty("org.quartz.jobStore.class", "org.quartz.impl.jdbcjobstore.JobStoreTX");
        //Job的JDBC持久化驱动，此处配置为MySql
        properties.setProperty("org.quartz.jobStore.driverDelegateClass", "org.quartz.impl.jdbcjobstore.StdJDBCDelegate");
        //配置是否使用
        properties.setProperty("org.quartz.jobStore.useProperties", "false");
        //持久化的quartz表结构前缀
        properties.setProperty("org.quartz.jobStore.tablePrefix", "QRTZ_");
        //是否是集群quartz
        properties.setProperty("org.quartz.jobStore.isClustered", "true");
        //集群quartz中节点有效性检查时间间隔
        properties.setProperty("org.quartz.jobStore.clusterCheckinInterval", "20000");
        //错过执行时间的Job最大持有数
        properties.setProperty("org.quartz.jobStore.maxMisfiresToHandleAtATime", "1");
        schedulerFactoryBean.setQuartzProperties(properties);
        //返回结果
        return schedulerFactoryBean;
    }

}

/**
 * 抽象定时任务，完成向quartz注册的功能
 * Created by chenjunyi on 2018/6/6.
 */
@Slf4j
public abstract class AbstractScheduler implements InterruptableJob {

    @Autowired
    private Scheduler scheduler;

    /**
     * 向定时任务调度器注册
     * @throws SchedulerException 注册时发生异常
     */
    @PostConstruct
    protected void register() throws SchedulerException {
        //任务和触发器名称（若不进行设置，则quartz默认使用UUID，因此每次启动应用都会注册一个新任务）
        String jobName = this.getClass().getSimpleName() + "Job";
        String triggerName = this.getClass().getSimpleName() + "Trigger";
        //设置定时任务
        JobDetail jobDetail = JobBuilder.newJob(this.getClass()).withIdentity(jobName).build();
        //创建任务触发器
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(getCron());
        Trigger trigger = TriggerBuilder.newTrigger().withIdentity(triggerName).withSchedule(scheduleBuilder).build();
        //将触发器与任务绑定到调度器内
        Set<Trigger> triggers = new HashSet<>();
        triggers.add(trigger);
        scheduler.scheduleJob(jobDetail, triggers, true);
        log.info(">>>>>注册[Trigger={}, Job={}]的定时任务成功", triggerName, jobName);
    }

    /**
     * 获取cron表达式
     * @return cron表达式
     */
    protected abstract String getCron();

}

/**
 * 示例定时任务
 * Created by chenjunyi on 2018/6/5.
 */
@Service
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class DemoScheduler extends AbstractScheduler {

    @Value("${env.cron.demoScheduler}")
    private String      cron;

    @Autowired
    private DemoService demoService;

    @Override
    public void interrupt() throws UnableToInterruptJobException {

    }

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        demoService.sayHello();
    }

    @Override
    protected String getCron() {
        return this.cron;
    }

}