Quartz实现分布式可动态配置的定时任务

关键词：

1. 定时任务

2. 分布式

3. 可动态配置触发时间

一般通过Quartz实现定时任务很简单。如果实现分布式定时任务需要结合分布式框架选择master节点触发也可以实现。但我们有个实际需求是，页面可动态配置定时任务触发周期（比如，假如下班前如果把先决条件完成了，正常可以18:00触发完成批量任务，假如完不成，需要将任务设置到很晚，等到先决条件完成再触发）。这个时候需要满足1,2,3都要满足。这样实现起来就有一定难度了。

下面来看看我是怎样实现的，如有更好的实现方案，欢迎在评论区提出，谢谢！

1. Quartz实现定时任务

我通过一个工具类来实现，如下：　

import java.text.SimpleDateFormat
import java.util.Date

import org.quartz.{CronScheduleBuilder, CronTrigger, JobBuilder, JobKey, TriggerBuilder, TriggerKey, _}
import org.quartz.impl.StdSchedulerFactory

import scala.collection.JavaConverters._

/**
  * 定时任务管理类
  *
  * @author BarryWang create at 2018/5/11 14:22
  * @version 0.0.1
  */
object QuartzManager {
  private val stdSchedulerFactory = new StdSchedulerFactory
  private val JOB_GROUP_NAME = "JOB_GROUP_NAME"
  private val TRIGGER_GROUP_NAME = "TRIGGER_NAME"

  /**
    * 根据指定格式(yyyy-MM-dd HH:mm:ss)时间字符串添加定时任务，使用默认的任务组名，触发器名，触发器组名
    * @param jobName  任务名
    * @param time     时间设置，参考quartz说明文档
    * @param jobClass 任务类名
    */
  def addJobByTime(jobName: String, time: String, jobClass: Class[_ <: Job]) : Unit = {
    QuartzManager.addJobByTime(jobName, time, jobClass, Map("1"->"otherData"))
  }

  /**
    * 根据指定时间(java.util.Date)添加定时任务，使用默认的任务组名，触发器名，触发器组名
    *
    * @param jobName 任务名
    * @param date 日期
    * @param jobClass 任务类名
    */
  def addJobByDate(jobName: String, date: Date, jobClass: Class[_ <: Job]): Unit = {
    QuartzManager.addJobByDate(jobName, date, jobClass, Map("1"->"otherData"))
  }

  /**
    * 根据指定cron表达式添加定时任务，使用默认的任务组名，触发器名，触发器组名
    *
    * @param jobName 任务名
    * @param jobClass 任务类名
    * @param cron cron表达式
    */
  def addJobByCron(jobName: String, cron : String, jobClass: Class[_ <: Job]): Unit = {
    QuartzManager.addJobByCron(jobName, cron, jobClass, Map("1"->"otherData"))
  }

  /**
    * 函数描述: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
    * @param jobName    任务名
    * @param time       时间字符串, 格式为(yyyy-MM-dd HH:mm:ss)
    * @param jobClass   任务类名
    * @param paramsMap  定时器需要额外数据
    */
  def addJobByTime(jobName: String, time: String, jobClass: Class[_ <: Job], paramsMap: Map[_ <: String, _ <: AnyRef]): Unit = {
    addJobByTime(jobName, time, "yyyy-MM-dd HH:mm:ss", jobClass, paramsMap)
  }

  /**
    * 函数描述: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
    * @param jobName    任务名
    * @param time       时间设置，参考quartz说明文档
    * @param jobClass   任务类名
    * @param paramsMap  定时器需要额外数据
    */
  def addJobByTime(jobName: String, time: String, timePattern: String, jobClass: Class[_ <: Job], paramsMap: Map[_ <: String, _ <: AnyRef]): Unit = {
    val df = new SimpleDateFormat(timePattern)
    val cron = getCron(df.parse(time))
    addJobByCron(jobName, cron, jobClass, paramsMap)
  }

  /**
    * Description: 添加一个定时任务，使用默认的任务组名，触发器名，触发器组名
    *
    * @param jobName 任务名
    * @param date 日期
    * @param cls 任务
    * @param paramsMap  定时器需要额外数据
    */
  def addJobByDate(jobName: String, date: Date, cls: Class[_ <: Job], paramsMap: Map[_ <: String, _ <: AnyRef]): Unit = {
      val cron = getCron(date)
      addJobByCron(jobName, cron, cls, paramsMap)
  }

  /**
    * 函数描述: 根据cron表达式添加定时任务(默认触发器组名及任务组名)
    * @param jobId            任务ID
    * @param cron             时间设置 表达式，参考quartz说明文档
    * @param jobClass         任务的类
    * @param paramsMap        可变参数需要进行传参的值
    */
  def addJobByCron(jobId: String, cron: String, jobClass: Class[_ <: Job], paramsMap: Map[_ <: String, _ <: AnyRef]): Unit = {
    addJob(jobId, cron, jobClass, paramsMap, JOB_GROUP_NAME, TRIGGER_GROUP_NAME)
  }

  /**
    * 函数描述: 根据cron表达式添加定时任务
    * @param jobId            任务ID
    * @param cron             时间设置 表达式，参考quartz说明文档
    * @param jobClass         任务的类类型  eg:TimedMassJob.class
    * @param paramsMap        可变参数需要进行传参的值
    * @param jobGroupName     任务组名
    * @param triggerGroupName 触发器组名
    */
  def addJob(jobId: String, cron: String, jobClass: Class[_ <: Job], paramsMap: Map[_ <: String, _ <: AnyRef],
             jobGroupName: String, triggerGroupName: String): Unit = {
      val scheduler = stdSchedulerFactory.getScheduler
      // 任务名，任务组，任务执行类
      val jobDetail = JobBuilder.newJob(jobClass).withIdentity(jobId, jobGroupName).build
       //设置参数
      jobDetail.getJobDataMap.putAll(paramsMap.asJava)

      val triggerBuilder = TriggerBuilder.newTrigger
      // 触发器名,触发器组
      //默认设置触发器名与任务ID相同
      val triggerName = jobId
      triggerBuilder.withIdentity(triggerName, triggerGroupName)
      triggerBuilder.startNow
      // 触发器时间设定
      triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(cron))
      // 创建Trigger对象
      val trigger = triggerBuilder.build.asInstanceOf[CronTrigger]
      // 调度容器设置JobDetail和Trigger
      scheduler.scheduleJob(jobDetail, trigger)
      // 启动
      if (!scheduler.isShutdown) scheduler.start()
  }

  /**
    * 函数描述: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
    * @param cron 时间字符串
    */
  def modifyJobTime(jobId: String, cron: String, jobClass: Class[_ <: Job]): Unit = {
    modifyJobTime(jobId, cron, jobClass, Map("1"->"otherData"), JOB_GROUP_NAME, TRIGGER_GROUP_NAME)
  }

  /**
    * 函数描述: 修改一个任务的触发时间(使用默认的任务组名，触发器名，触发器组名)
    * @param cron 时间字符串
    */
  def modifyJobTime(jobId: String, cron: String, jobClass: Class[_ <: Job], paramsMap: Map[_ <: String, _ <: AnyRef]): Unit = {
    modifyJobTime(jobId, cron, jobClass, paramsMap, JOB_GROUP_NAME, TRIGGER_GROUP_NAME)
  }

  /**
    * 函数描述: 修改一个任务的触发时间
    * @param jobId 任务ID
    * @param cron cron表达式
    * @param jobClass 任务类名
    * @param paramsMap 其他参数
    * @param jobGroupName 任务组名
    * @param triggerGroupName 触发器组
    */
  def modifyJobTime(jobId: String, cron: String, jobClass: Class[_ <: Job], paramsMap: Map[_ <: String, _ <: AnyRef],
                    jobGroupName: String, triggerGroupName: String): Unit = {
    val scheduler = stdSchedulerFactory.getScheduler()
    //默认设置触发器名与任务ID相同
    val triggerName = jobId
    val triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName)
    var trigger = scheduler.getTrigger(triggerKey).asInstanceOf[CronTrigger]
    if (trigger != null) {
      removeJob(jobId)
    }
    addJob(jobId, cron, jobClass, paramsMap, jobGroupName, triggerGroupName)
  }

  /**
    * 函数描述: 移除一个任务(使用默认的任务组名，触发器名，触发器组名)
    * @param jobId 任务名称
    */
  def removeJob(jobId: String): Unit = {
    val scheduler = stdSchedulerFactory.getScheduler
    //默认设置触发器名与任务ID相同
    val triggerName = jobId
    val triggerKey = TriggerKey.triggerKey(triggerName, TRIGGER_GROUP_NAME)
    // 停止触发器
    scheduler.pauseTrigger(triggerKey)
    // 移除触发器
    scheduler.unscheduleJob(triggerKey)
    // 删除任务
    scheduler.deleteJob(JobKey.jobKey(jobId , JOB_GROUP_NAME))
  }

  /**
    * 函数描述: 移除一个任务
    * @param jobId 任务ID
    * @param jobGroupName 任务组
    * @param triggerName 触发器名称
    * @param triggerGroupName 触发器组名
    */
  def removeJob(jobId: String, jobGroupName: String, triggerName: String, triggerGroupName: String): Unit = {
    val scheduler = stdSchedulerFactory.getScheduler
    val triggerKey = TriggerKey.triggerKey(triggerName, triggerGroupName)
    // 停止触发器
    scheduler.pauseTrigger(triggerKey)
    // 移除触发器
    scheduler.unscheduleJob(triggerKey)
    // 删除任务
    scheduler.deleteJob(JobKey.jobKey(jobId , jobGroupName))
  }

  /**
    * 函数描述:启动所有定时任务
    */
  def startJobs(): Unit = {
      stdSchedulerFactory.getScheduler.start()
  }

  /**
    * 函数描述:关闭所有定时任务
    *
    */
  def shutdownJobs(): Unit = {
      val sched = stdSchedulerFactory.getScheduler
      if (!sched.isShutdown) sched.shutdown()
  }

  /**
    * 根据时间获取Cron表达式
    * @param date 日期
    * @return
    */
  def getCron(date: Date): String = {
    val dateFormat = "ss mm HH dd MM ? yyyy"
    formatDateByPattern(date, dateFormat)
  }

  /**
    * 日期格式转换
    * @param date 日期
    * @param dateFormat 格式
    * @return
    */
  def formatDateByPattern(date : Date, dateFormat : String): String = {
    val sdf = new SimpleDateFormat(dateFormat)
    sdf.format(date)
  }
}

　　

2.分布式定时任务实现
　　分布式定时任务：即在分布式服务的环境下，启动定时任务。分布式定时任务需要解决的问题是：同一定时任务，同一时间点，只能在一台服务器上启动。
为了解决分布式定时任务的问题，有两种方案可以解决：
1）执行定时任务是添加分布式锁
  分布式锁实现请参考：

分布式锁的三种实现方式

2）执行定时任务选取一台服务作为master节点执行该定时任务
我们需要框架层面解决定时任务触发时，选举一台服务器作为master节点。
实现思路如下：
1. 服务启动注册服务时，为服务编号；
2．从注册服务中随机选中一台服务器作为master节点；
3. 服务挂掉或添加时重新选举。

代码如下：　

import java.util.HashMap;
import java.util.Map;

/**
 * Created by tangliu on 2016/7/13.
 */
public class MasterHelper {

    public static Map<String, Boolean> isMaster = new HashMap<>();

    /**
     * 根据serviceName, versionName，判断当前服务是否集群中的master
     *  todo 服务版本号是否作为master判断的依据??
     * @param servieName
     * @param versionName
     * @return
     */
    public static boolean isMaster(String servieName, String versionName) {

        String key = generateKey(servieName, versionName);

        if (!isMaster.containsKey(key))
            return false;
        else
            return isMaster.get(key);

    }

    public static String generateKey(String serviceName, String versionName) {
        return serviceName + ":" + versionName;
    }
}

竞选master:
/**
 * 监听服务节点下面的子节点（临时节点，实例信息）变化
 */
public void watchInstanceChange(RegisterContext context) {
    String watchPath = context.getServicePath();
    try {
        List<String> children = zk.getChildren(watchPath, event -> {
            LOGGER.warn("ServerZk::watchInstanceChange zkEvent:" + event);
            //Children发生变化，则重新获取最新的services列表
            if (event.getType() == Watcher.Event.EventType.NodeChildrenChanged) {
                LOGGER.info("容器状态:{}, {}子节点发生变化，重新获取子节点...", ContainerFactory.getContainer().status(), event.getPath());
                if (ContainerFactory.getContainer().status() == Container.STATUS_SHUTTING
                        || ContainerFactory.getContainer().status() == Container.STATUS_DOWN) {
                    LOGGER.warn("Container is shutting down");
                    return;
                }
                watchInstanceChange(context);
            }
        });
        boolean _isMaster = false;
        if (children.size() > 0) {
            _isMaster = checkIsMaster(children, MasterHelper.generateKey(context.getService(), context.getVersion()), context.getInstanceInfo());
        }
        //masterChange响应
        LifecycleProcessorFactory.getLifecycleProcessor().onLifecycleEvent(
                new LifeCycleEvent(LifeCycleEvent.LifeCycleEventEnum.MASTER_CHANGE,
                        context.getService(), _isMaster));
    } catch (KeeperException | InterruptedException e) {
        LOGGER.error(e.getMessage(), e);
        create(context.getServicePath() + "/" + context.getInstanceInfo(), context, true);
    }
}

//-----竞选master---
private static Map<String, Boolean> isMaster = MasterHelper.isMaster;

/**
 * @param children     当前方法下的实例列表，        eg 127.0.0.1:9081:1.0.0,192.168.1.12:9081:1.0.0
 * @param serviceKey   当前服务信息                eg com.github.user.UserService:1.0.0
 * @param instanceInfo 当前服务节点实例信息         eg  192.168.10.17:9081:1.0.0
 */
public boolean checkIsMaster(List<String> children, String serviceKey, String instanceInfo) {
    if (children.size() <= 0) {
        return false;
    }

    boolean _isMaster = false;

    /**
     * 排序规则
     * a: 192.168.100.1:9081:1.0.0:0000000022
     * b: 192.168.100.1:9081:1.0.0:0000000014
     * 根据 lastIndexOf :  之后的数字进行排序，由小到大，每次取zk临时有序节点中的序列最小的节点作为master
     */
    try {
        Collections.sort(children, (o1, o2) -> {
            Integer int1 = Integer.valueOf(o1.substring(o1.lastIndexOf(":") + 1));
            Integer int2 = Integer.valueOf(o2.substring(o2.lastIndexOf(":") + 1));
            return int1 - int2;
        });

        String firstNode = children.get(0);
        LOGGER.info("serviceInfo firstNode {}", firstNode);

        String firstInfo = firstNode.replace(firstNode.substring(firstNode.lastIndexOf(":")), "");

        if (firstInfo.equals(instanceInfo)) {
            isMaster.put(serviceKey, true);
            _isMaster = true;
            LOGGER.info("({})竞选master成功, master({})", serviceKey, CURRENT_CONTAINER_ADDR);
        } else {
            isMaster.put(serviceKey, false);
            _isMaster = false;
            LOGGER.info("({})竞选master失败，当前节点为({})", serviceKey);
        }
    } catch (NumberFormatException e) {
        LOGGER.error("临时节点格式不正确,请使用新版，正确格式为 etc. 192.168.100.1:9081:1.0.0:0000000022");
    }

    return _isMaster;
}

　　

分布式环境判断是否是master：

if (!MasterHelper.isMaster("com.today.api.financetask.service.FinanceScheduledService", "1.0.0")) {
  //excute the task
}

　　

3. 动态配置定时任务触发时间
实现定时任务可动态配置，需要通过数据库表保存最新一次修改的cron表达式来实现：
建表如下：

CREATE TABLE t_scheduled_task  (
      job_name  varchar(50)    NOT NULL     COMMENT 'job名称'
    ,  job_id  varchar(40)    NOT NULL     COMMENT 'job ID'
    ,  job_cron  varchar(50)    NOT NULL     COMMENT 'Job cron表达式'
    ,  job_type  int         COMMENT 'Job类型'
    ,  is_start  tinyint(2)   DEFAULT 1 NOT NULL     COMMENT '是否已启动,0:否(no);1:是(yes)'
    ,  remark  varchar(256)         COMMENT '备注'
    ,  updated_at  timestamp   DEFAULT CURRENT_TIMESTAMP NOT NULL     COMMENT '更新时间'
    ,  created_at  timestamp   DEFAULT CURRENT_TIMESTAMP NOT NULL     COMMENT '创建时间'
    ,  has_deleted  tinyint(2)   DEFAULT 0 NOT NULL     COMMENT '是否已删除,0:否(no);1:是(yes)'
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='定时任务配置表';
CREATE  UNIQUE INDEX uk_t_scheduled_task ON t_scheduled_task ( job_id);

建表后需要页面调用接口实现先停掉上次的定时任务，再根据最新修改的触发时间新建一个新的定时任务：
如下：

//页面设置每天触发的时间，格式：HH:mm
val cron = convertHourMinuteToCron(processTime)
//修改定时任务时间, 保存入库
ScheduledTaskQuerySql.isExists(jobId) match {
  case true => ScheduledTaskActionSql.updateTaskCron(jobId, cron)
  case false => ScheduledTaskActionSql.insertTScheduledTask(
    TScheduledTask( report.name,
                    jobId,
                    cron,
                    None,
                    TScheduledTaskIsStartEnum.YES.id,
                    None,
                    null,
                    null,
                    TScheduledTaskHasDeletedEnum.NO.id))
}
//关掉老的定时任务，添加新的定时任务
QuartzManager.modifyJobTime(jobId, cron, classOf[DailyGenIncomeDetailJob])

　　

/**
  * 每天定时触发-转换时分格式(hh:mm)为cron表达式
  * @param hourMibuteStr
  * @return
  */
def convertHourMinuteToCron(hourMibuteStr : String) : String = {
  val splitHm = hourMibuteStr.split(":")
  s"0 ${splitHm(1).trim.toInt} ${splitHm(0).trim.toInt} * * ?"
}

/**
  * 每天定时触发-转换时分格式(hh:hh:mm)为cron表达式
  * @param dayStr
  * @return
  */
def convertDayToCron(dayStr : String) : String = {
  val splitHm = dayStr.split(":")
  s"0 ${splitHm(1).trim.toInt} ${splitHm(0).trim.toInt} * * ?"
}

　　

定义Job及父类:

Job定义

import java.util.Calendar

import com.today.api.checkaccount.scala.enums.FlatFormTypeEnum
import com.today.api.checkaccount.scala.request.ReconciliationRequest
import com.today.api.checkaccount.scala.CheckAccountServiceClient
import com.today.service.financetask.job.define.{AbstractJob, JobEnum}
import org.quartz.JobExecutionContext

class CheckAccountJob extends AbstractJob{
  /**
    * get the api information
    *
    * @return (interface name, interface version, JobEnum)
    */
  override def getJobAndApiInfo(context: JobExecutionContext): (String, String, JobEnum) = {
    ("com.today.api.financetask.service.CloseAccountScheduleService", "1.0.0",  JobEnum.CHECK_ACCOUNT_PROCESS)
  }

  /**
    * start up the scheduled task
    *
    * @param context JobExecutionContext
    */
  override def run(context: JobExecutionContext): Unit = {
    val cal = Calendar.getInstance
    cal.add(Calendar.DATE, -1)
    new CheckAccountServiceClient().appReconciliation(new ReconciliationRequest(FlatFormTypeEnum.TODAY_APP,None))

  }
}

公共父类

import java.io.{PrintWriter, StringWriter}

import com.github.dapeng.core.helper.MasterHelper
import com.today.api.financetask.scala.enums.TScheduledTaskLogEnum
import com.today.service.financetask.action.sql.ScheduledTaskLogSql
import com.today.service.financetask.util.{AppContextHolder, Debug}
import org.quartz.{Job, JobExecutionContext}
import org.slf4j.LoggerFactory
import org.springframework.transaction.TransactionStatus
import org.springframework.transaction.support.TransactionTemplate

import scala.util.{Failure, Success, Try}

/**
  * the abstract class for job
  */
trait AbstractJob extends Job{
  /** 日志 */
  val logger = LoggerFactory.getLogger(getClass)

  /**
    * execute the job
    * @param context
    */
  override def execute(context: JobExecutionContext): Unit = {
    val jobAndApiInfo = getJobAndApiInfo(context)
    if (!MasterHelper.isMaster(jobAndApiInfo._1, jobAndApiInfo._2)) {
      logger.info(s"Can't select master to run the job ${jobAndApiInfo._3.jobId}: ${jobAndApiInfo._3.jobName}")
      return
    }

    val logId = ScheduledTaskLogSql.insertScheduledTaskLog(jobAndApiInfo._3)
    context.put("logId", logId)
    logger.info(s"Starting the job ${jobAndApiInfo._3.jobId}: ${jobAndApiInfo._3.jobName} ...")

    /**
      * 事物处理
      */
    val transactionTemplate: TransactionTemplate = AppContextHolder.getBean("transactionTemplate")
    transactionTemplate.execute((status: TransactionStatus) =>{
      Debug.reset()
      Try(Debug.trace(s"${jobAndApiInfo._3.jobId}:${jobAndApiInfo._3.jobName}")(run(context))) match
      {
        case Success(x) => {
          logger.info(s"Successfully execute the job ${jobAndApiInfo._3.jobId}: ${jobAndApiInfo._3.jobName}")
          successLog(logId)
        }
        case Failure(e) => {
          logger.error(s"Failure execute the job ${jobAndApiInfo._3.jobId}: ${jobAndApiInfo._3.jobName}", e)
          failureLog(logId, status, e)
        }
      }
      Debug.info()
    })
  }

  /**
    * get the api information
    * @return (interface name, interface version, JobEnum)
    */
  def getJobAndApiInfo(context: JobExecutionContext) : (String, String, JobEnum)

  /**
    * start up the scheduled task
    * @param context JobExecutionContext
    */
  def run(context: JobExecutionContext)

  /**
    * 成功日志记录
    * @param logId
    */
  def successLog(logId: Long): Unit ={
    ScheduledTaskLogSql.updateExportReportRecord(logId, TScheduledTaskLogEnum.SUCCESS, "Success")
  }

  /**
    * 失败日志记录
    * @param logId
    */
  def failureLog(logId: Long, status: TransactionStatus, e: Throwable): Unit ={
    status.setRollbackOnly()
    ScheduledTaskLogSql.updateExportReportRecord(logId, TScheduledTaskLogEnum.FAILURE, getExceptionStack(e))
  }

  /**
    *
    * 功能说明:在日志文件中 ，打印异常堆栈
    * @param e : Throwable
    * @return : String
    */
  def getExceptionStack(e: Throwable): String = {
    val errorsWriter = new StringWriter
    e.printStackTrace(new PrintWriter(errorsWriter))
    errorsWriter.toString
  }
}

4. 重启服务器，启动所有定时任务
重启定时任务，需要重启所有定时任务
这个过程需要将所有定时任务及触发周期保存到数据库，重启后，读取数据库启动恢复所有定时任务
代码如下(Spring框架下启动服务自动会启动ApplicationListener.onApplicationEvent(event: ContextRefreshedEvent))：

import com.today.api.financetask.scala.enums.{TReportTypeEnum, TScheduledTaskIsStartEnum}
import com.today.api.financetask.scala.request.QueryAutoConfigRequest
import com.today.service.financetask.job._
import com.today.service.financetask.job.define.JobEnum
import com.today.service.financetask.query.sql.{AutoConfigQuerySql, ScheduledTaskQuerySql}
import com.today.service.financetask.util.QuartzManager
import org.slf4j.LoggerFactory
import org.springframework.context.ApplicationListener
import org.springframework.context.event.ContextRefreshedEvent
import org.springframework.stereotype.Service

/**
  *  类功能描述: 定时器监听器, 服务启动时启动定时器
  *
  * @author BarryWang create at 2018/5/11 12:04
  * @version 0.0.1
  */
@Service
class ScheduleStartListener extends ApplicationListener[ContextRefreshedEvent] {
  /** 日志 */
  val logger = LoggerFactory.getLogger(getClass)
  /**
    * 启动加载执行定时任务
    */
  override def onApplicationEvent(event: ContextRefreshedEvent): Unit = {
    logger.info("=======服务器重启定时任务启动start=======")
    //1. 恢复日次处理定时任务
    recoveryDayTimeProcessJob()
    //2. 恢复每天营收明细报表生成定时任务
    recoveryImcomeDetailGenJob()
    logger.info("=======服务器重启定时任务启动end=======")
  }

  /**
    * 恢复日次处理定时任务
    */
  private def recoveryDayTimeProcessJob(): Unit ={
    try {
      ScheduledTaskQuerySql.queryByJobId(JobEnum.DAY_TIME_PROCESS.jobId) match {
        case Some(x) =>
          if(x.isStart == TScheduledTaskIsStartEnum.YES.id)
            QuartzManager.addJobByCron(JobEnum.DAY_TIME_PROCESS.jobId, x.jobCron, classOf[DayTimeProcessJob])
          else
            logger.info("定时任务：" + JobEnum.DAY_TIME_PROCESS.jobName  + "is_start标志为0，不启动")
        case None =>
          QuartzManager.addJobByCron(JobEnum.DAY_TIME_PROCESS.jobId, "0 30 2 * * ?", classOf[DayTimeProcessJob])
      }
    } catch {
      case e : Exception => logger.error(JobEnum.DAY_TIME_PROCESS.jobName + "启动失败， 失败原因：", e)
    }

  }

  /**
    * 恢复营收明细报表生成定时任务
    */
  private def recoveryImcomeDetailGenJob(): Unit = {
    val jobName = TReportTypeEnum.INCOMEDETAIL_REPORT.name
    try {
      val jobId = TReportTypeEnum.INCOMEDETAIL_REPORT.id.toString
      ScheduledTaskQuerySql.queryByJobId(jobId) match {
        case Some(x) =>
          if (x.isStart == TScheduledTaskIsStartEnum.YES.id)
            QuartzManager.addJobByCron(jobId, x.jobCron, classOf[DailyGenIncomeDetailJob])
          else
            logger.info("定时任务：" + jobName  + "is_start标志为0，不启动")
        case None =>
          QuartzManager.addJobByCron(jobId, "0 10 0 * * ?", classOf[DailyGenIncomeDetailJob])
      }
    }catch {
      case e : Exception => logger.error(jobName + "启动失败， 失败原因：", e)
    }
  }
}

　　

大家也看到上面代码会使用使用JobEnum的枚举来定义不同定时任务信息。

如下就是使用Scala枚举定义定时信息如下：

case class JobEnum(val jobId: String, val jobName: String) extends Enumeration

/**
  * 所有Job 枚举定义在此类, 不能重复
  * jobId不能重复
  * @author BarryWang create at 2018/5/12 10:45
  * @version 0.0.1
  */
object JobEnum {
  val DAY_TIME_PROCESS = JobEnum("DAY_TIME_PROCESS", "日次处理定时任务")

  val INVOICE_SYNC_PROCESS = JobEnum("INVOICE_SYNC_PROCESS", "采购系统同步单据数据定时任务")

  val RETIREMENT_SYNC_PROCESS = JobEnum("RETIREMENT_SYNC_PROCESS", "采购系统同步报废单据数据定时任务")

  val CLOSE_ACCOUNT_STATE_PROCESS = JobEnum("CLOSE_ACCOUNT_STATE_PROCESS","更新关账状态定时任务")

  val PURCHASE_ORDER_2_SYNC_PROCESS = JobEnum("PURCHASE_ORDER_2_SYNC_PROCESS","采购系统同步PO2数据定时任务")

  val SEND_EMAIL_PROCESS = JobEnum("SEND_EMAIL_PROCESS","计划付款通知和已付款通知定时任务")

  val CLOSE_ACCOUNT_BASE_DATA_PROCESS = JobEnum("CLOSE_ACCOUNT_BASE_DATA_PROCESS","关账基础数据同步定时任务")
}

这是可动态配置的分布式定时任务第一版已实现，但还是还是有优化的地方：

１．枚举里面只有jobId及jobName,为了启动服务时不需要每个定时任务都写一个恢复方法，可以将枚举里面定时任务信息多添加jobClass及cron表达式，这样以后添加新定时任务只需要维护枚举信息就可以；

２．每个Job子类里面都需要实现 override def getJobAndApiInfo(context: JobExecutionContext): (String, String, JobEnum) 方法，这个也可以省掉；

３．新添加定时任务完全可以制定一个Job子类，其他操作自动维护进去；

1,2请参考: Scala 定义复杂枚举 是实现，这种方式虽然做了简化，只需要定义Job子类及对应JobEnum。但理想状态所有定时任务信息只需要维护在Job子类就行了

3通过使用反射实现将所有定时任务信息只需要维护在Job子类，请参考: Java Scala获取注解的类信息

至此整个实现分布式环境下实现动态可配置的定时任务过程已完成