Quartz实现数据库动态配置定时任务

项目实战

或许实现的方式跟之前的代码有点不一样的

1.定时任务的配置信息

@Configuration
public class ScheduleConfigration {

    @Autowired
    private ScheduleInfoAction scheduleInfoAction;

    @Autowired
    private ChannelSyncTask ChannelSyncTask;

    /**
     * 用于5分钟轮训检查cron修改（基本不需要修改）
     * @return
     */
    @Bean(name = "jobDetail")
    public MethodInvokingJobDetailFactoryBean jobDetail(){
        MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean = new MethodInvokingJobDetailFactoryBean();
        methodInvokingJobDetailFactoryBean.setConcurrent(false);
        methodInvokingJobDetailFactoryBean.setTargetObject(scheduleInfoAction);
        methodInvokingJobDetailFactoryBean.setTargetMethod("reScheduleJob");
        return methodInvokingJobDetailFactoryBean;
    }

    /**
     * 用于5分钟轮训检查cron修改（基本不需要修改）
     * @return
     */
    @Bean(name = "cronTrigger")
    public CronTriggerFactoryBean cronTrigger(){
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(jobDetail().getObject());
        // 设置默认刷新cron
        cronTriggerFactoryBean.setCronExpression(Properties.getString("refresh.default.cron"));
        return cronTriggerFactoryBean;
    }

    /**
     * dycChannel 任务，需要添加新的定时任务，需要重复配置JobDetail,CronTrigger
     * @return
     */
    @Bean(name = "channelSyncJobCronJobDetail")
    public MethodInvokingJobDetailFactoryBean channelSyncJobCronJobDetail(){
        MethodInvokingJobDetailFactoryBean methodInvokingJobDetailFactoryBean = new MethodInvokingJobDetailFactoryBean();
        methodInvokingJobDetailFactoryBean.setConcurrent(false);
        methodInvokingJobDetailFactoryBean.setTargetObject(channelSyncTask);
        methodInvokingJobDetailFactoryBean.setTargetMethod("doTask");
        return methodInvokingJobDetailFactoryBean;
    }

    @Bean(name = "channelSyncJobCronTrigger")
    public CronTriggerFactoryBean channelSyncJobCronTrigger(){
        CronTriggerFactoryBean cronTriggerFactoryBean = new CronTriggerFactoryBean();
        cronTriggerFactoryBean.setJobDetail(channelSyncJobCronJobDetail().getObject());
        cronTriggerFactoryBean.setCronExpression("0 0 1 * * ?");
        return cronTriggerFactoryBean;
    }

    /**
     * repeat code JobDetail and CronTrigger ...
     **/

    /**
     * 调度工厂
     * @return
     */
    @Bean(name = "schedulerFactory")
    public SchedulerFactoryBean schedulerFactoryBean(){
        SchedulerFactoryBean schedulerFactoryBean = new SchedulerFactoryBean();
        //在添加新的触发器时，增加相应的触发器
        schedulerFactoryBean.setTriggers(cronTrigger().getObject(),
                channelSyncJobCronTrigger().getObject()
        );
        return schedulerFactoryBean;
    }
}

2.刷新的定时任务

@Component
public class ScheduleInfoAction{
    private Logger logger = LoggerFactory.getLogger(ScheduleInfoAction.class);

    private Scheduler scheduler;

    public void reScheduleJob() throws SchedulerException {
        scheduler = (Scheduler) SpringContextUtils.getBean("schedulerFactory");
        // 数据库取任务列表
        List<String> jobs = yunyingDao.getJobCodesFromDB(null);

        if (jobs != null && !jobs.isEmpty()) {
            for (String job : jobs) {
                TriggerKey triggerKey = new TriggerKey(job + "CronTrigger", Scheduler.DEFAULT_GROUP);
                CronTriggerImpl trigger = (CronTriggerImpl) scheduler.getTrigger(triggerKey);

                String dbCronExpression = getCronExpressionFromDB(job);
                String originConExpression;
                if (StringUtils.isNotBlank(dbCronExpression)){
                    if (trigger != null){
                        originConExpression = trigger.getCronExpression();
                        if(!dbCronExpression.equalsIgnoreCase(originConExpression)){
                            try{
                                trigger.setCronExpression(dbCronExpression);
                                scheduler.rescheduleJob(triggerKey, trigger);
                                logger.info("jobCode:{}, dbCron:{}, originCron:{}",
                                    job,dbCronExpression,originConExpression);
                            } catch (Exception e) {
                                logger.error("jobCode:{}, dbCron:{}, originCron:{}, refresh Cron Error:{}" ,
                                    job,dbCronExpression, originConExpression, e);
                            }
                        }
                    }else {
                        trigger = (CronTriggerImpl)SpringContextUtils.getBean(job + "CronTrigger");
                        if (trigger != null){
                            scheduler.scheduleJob(trigger);
                            logger.info("scheduleJob:{}", job);
                        }
                    }
                }else {
                    if (trigger != null){
                        scheduler.unscheduleJob(triggerKey);
                        logger.info("unscheduleJob:{}", job);
                    }
                }
            }
        }
    }
    // 数据库取最新的Cron值
    private String getCronExpressionFromDB(String jobName){
        return yunyingDao.getCronByCode(jobName);
    }
}

3.设置定时任务

1）基础抽象类的实现，（由于可能处于分布式环境中，需要使用zookeeper的分布式锁）

public abstract class BaseTask {

    private Logger logger = LoggerFactory.getLogger(BaseTask.class);

    public abstract void execute();

    public void doTask(){
        String clazzName = this.getClass().getSimpleName();
        String className = clazzName.substring(0,1).toLowerCase() + clazzName.substring(1);
        String lockPath = "/oper/schedule/" + className + "/lock";

        ZooKeeperClient zkClient = (ZooKeeperClient)SpringContextUtils.getBean("zkClient");
        CronTriggerImpl cronTrigger = (CronTriggerImpl)SpringContextUtils
                .getBean(className.replace("Task","Job") + "CronTrigger");

        logger.info("lock path:{},zkClient:{},trigger cron:{}", lockPath, zkClient,
                cronTrigger.getCronExpression());

        Boolean isGetLocker = false;
        InterProcessMutex lock = new InterProcessMutex(zkClient.getClient(), lockPath);
        try {
            if (lock.acquire(2000, TimeUnit.MILLISECONDS)){
                isGetLocker = true;
                execute();
            }
        } catch (Exception e) {
            logger.error("BaseTask 执行锁任务时抛错：", e);
        }finally {
            try {
                if(isGetLocker){
                    lock.release();
                }
            } catch (Exception e) {
                logger.error("释放锁出错",e);
            }
        }
    }
}

需要执行的定时任务的代码实现继承BaseTask，并实现业务代码。

不过，这里我们中间又使用了Groovy代码，由于Groovy代码在这里可以直接对数据库进行操作，所以这里继承BaseTask 的定时任务，我们是调用Groovy Class 的方法。

2）定时任务的实现

@Component
public class DycChannelSyncTask extends BaseTask{

    private Logger logger = LoggerFactory.getLogger(DycChannelSyncTask.class);

    public void execute() {
        logger.info("渠道信息开始执行任务:"
            + TimeUtils.formatTime(new Date(), TimeUtils.FORMAT_YYYYMMDDHHMMSS));
        //进行数据抽取存储，这里调的是groovy的方法
        channelSyncJob.doJob();
        logger.info("渠道信息任务执行完成:"
            + TimeUtils.formatTime(new Date(), TimeUtils.FORMAT_YYYYMMDDHHMMSS));
    }
}

4.需要引入的Maven

		<!-- 定时任务 -->
		<dependency>
		    <groupId>org.quartz-scheduler</groupId>
		    <artifactId>quartz</artifactId>
		    <version>2.2.1</version>
		</dependency>

		<!-- groovy要用到的，数据库连接，zookeeper要用到的（我这的是封装好的） -->
		<dependency>
		    <groupId>org.codehaus.groovy</groupId>
		    <artifactId>groovy-all</artifactId>
		    <version>2.4.6</version>
		</dependency>

		<dependency>
		    <groupId>mysql</groupId>
		    <artifactId>mysql-connector-java</artifactId>
		    <version>5.1.31</version>
		</dependency>

		<!-- zookeeper -->
		<dependency>
			<groupId>org.apache.zookeeper</groupId>
			<artifactId>zookeeper</artifactId>
			<exclusions>
				<exclusion>
					<groupId>org.slf4j</groupId>
					<artifactId>slf4j-log4j12</artifactId>
				</exclusion>
				<exclusion>
					<groupId>log4j</groupId>
					<artifactId>log4j</artifactId>
				</exclusion>
			</exclusions>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-framework</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.curator</groupId>
			<artifactId>curator-recipes</artifactId>
		</dependency>

5.数据库中定时任务的表结构

CREATE TABLE `tb_job_config` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `jobCode` varchar(32) DEFAULT NULL COMMENT '商户',
  `jobName` varchar(32) DEFAULT NULL COMMENT '渠道编号',
  `cron` varchar(128) DEFAULT NULL,
  `jobDetail` longtext COMMENT '渠道名称',
  `status` smallint(1) DEFAULT NULL COMMENT '1、有效 2 无效',
  PRIMARY KEY (`id`),
  UNIQUE KEY `merchantNo_channelCode_unique` (`jobCode`,`jobName`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=164 DEFAULT CHARSET=utf8 COMMENT='任务调度配置表';
INSERT INTO `tb_job_config` (`id`, `jobCode`, `jobName`, `cron`, `jobDetail`, `status`)
VALUES ('139', 'channelUserSyncJob', '鼎有财渠道用户同步', '0 0 0/1 * * ? ', '{\"intervalHours\":\"2\"}', '1');

// 定时任务执行完，记录一下任务执行情况，有助于排查问题等等
CREATE TABLE `tb_job_execute_log` (
  `id` bigint(64) NOT NULL AUTO_INCREMENT,
  `jobCode` varchar(255) DEFAULT NULL COMMENT '任务编号',
  `totalNum` bigint(64) DEFAULT NULL COMMENT '记录总数',
  `successNum` bigint(64) DEFAULT NULL COMMENT '记录成功数',
  `errorNum` bigint(64) DEFAULT NULL COMMENT '记录错误数',
  `recordTime` datetime DEFAULT CURRENT_TIMESTAMP COMMENT '记录时间',
  PRIMARY KEY (`id`),
  KEY `Index_jobCode` (`jobCode`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=52810 DEFAULT CHARSET=utf8 COMMENT='任务执行情况记录表';

另外注意的是数据库中命名的Job，要与实际代码中的命名规则保持一致。

我觉得使用之前的Job，获取我们这边的代码可以简化很多。