Quartz使用(6) - Quartz项目实战

本片博文将阐述项目工作中使用Quartz的情况，包含项目背景、项目框架、Quartz集群部署等方面，重点讲述如何在实际项目中使用Quartz。

1. 背景

因项目需求，需要定时调用数据下载接口，并将数据存储至诸如mongo、redis、elasticsearch等数据库或缓存中。具体涉及到的需求如下：

a. 调用接口的任务均从mongo数据库读取;

b. 任务的个数随着业务量的增加而增加;

c. 每个调用任务的定时执行时间可能不同，且定时执行时间在mongo中可配置;

d. 任务的执行需要动态更新，如检测到某一任务的定时时间发生变化，则任务的执行也需要实时修改

e. mongo、redis、elasticsearch等数据库中所存储的字段也由mongo进行配置;

f. 任务执行需要实时性较高、可靠性较强、可扩展性较高等

综上需求，调研了一番，发现任务调度框架Quartz可满足项目需求。

2. 框架

基于项目的需求，结合任务调度框架Quartz，大体的流程框架如下图所示：

1) 首先构建从mongo加载任务

2) 将任务的配置信息初始化至Quartz

3) 通过Quartz的Job任务实现定时调用下载接口任务

4) 将下载的数据依据配置，存储至数据库中

5) 定时检测任务通过定时扫描mongo数据库，查看相关任务信息的配置是否发生变化，如果发生变化，则进行动态更新

6) 为了实现高可用性、可扩展性，可以直接使用Quartz原生的集群特性。

3. 核心代码

核心代码将会涵盖上述流程图中的相关环节，为了项目的保密性，相关信息也会隐藏。

3.1 任务主流程　　

import com.quartz.conf.Configuration;
import com.quartz.conf.OcpConfHelper;
import com.quartz.module.TaskInfo;
import org.apache.log4j.PropertyConfigurator;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.impl.StdSchedulerFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

public class SchedulerRunner {
    static Logger logger = LoggerFactory.getLogger(SchedulerRunner.class);

    public static void main(String[] args) {

        // 加载日志配置文件
        PropertyConfigurator.configure("./conf/log4j.properties");

        // 加载quartz配置文件
        System.setProperty("org.quartz.properties", "./conf/quartz.properties");

        // 执行任务解析与调度
        run();
    }

    public static void run(){
        // 获取配置信息表
        List<TaskInfo> taskInfos = GenerateTaskInfo.generateTaskInfoFromMysql();
        if(taskInfos.size() == 0){
            logger.info("there is no tasks from mongoInfo");
            return;
        }

        // 过滤下线任务
        taskInfos = GenerateTaskInfo.filterTask(taskInfos);
        if(taskInfos.size() == 0){
            logger.info("all tasks if offline, no need to run");
            return;
        }

        Scheduler scheduler = null;
        try {
            scheduler = StdSchedulerFactory.getDefaultScheduler();
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

        if(scheduler == null){
            logger.error("create scheduler failed");
            return;
        }

        if(isSchedulerClear()){
            clearSchedulerJob(scheduler);
        }

        // 加入任务调度
        for(TaskInfo task : taskInfos){
            SchedulerFactory.addJob2Scheduler(task, scheduler);
        }

        // 加入动态更新任务
        SchedulerFactory.addDynamicUpdateJob2Scheduler(scheduler);

        // 开启任务
        try {
            scheduler.start();
        } catch (SchedulerException e) {
            logger.error("start scheduler error!");
        }
    }

    public static void clearSchedulerJob(Scheduler scheduler){
        try {
            scheduler.clear();
        } catch (SchedulerException e) {
            logger.error("clear  scheduler error!");
        }
    }

    /**
     * 基于配置文件中的信息，加载调度器开始运行时的清洗标识
     * @return
     */
    private static boolean isSchedulerClear(){
        Configuration conf = OcpConfHelper.getInstance().getOcpConf();
        return conf.getBooleanValue("cleanSchedulerFlag", "true");
    }
}

3.2 封装任务对象

import java.util.List;
import java.util.Map;

public class TaskInfo {

    protected String categoryId; // 业务Id
    protected String categoryName; // 业务名称
    protected String sourceId; // 信源Id
    protected String sourceName; // 信源名称
    protected int sourceStatus; // 信源状态
    protected String pipelineConf; // 信源pipeline配置信息
    protected List<String> dbStoreTypes; // 业务的存储类型
    protected String esConfInfo; // ES存储配置
    protected String dbConfInfo; // DB存储配置
    protected String cronInfo; // 定时任务信息
    protected int sourceType; // 实时更新还是离线更新
    protected List<String> indexBuildEles; // 更新索引的信息
    protected List<String> idBuildEles; // id的构建因素
    protected String indexType; // 全量或增量
    protected String categoryLevel1; // 一级分类
    protected String zhName; // 中文信息
    protected Map<String,String> outputType; //输出参数名及其类型
    protected String providerName;
    protected String functionName; //category_function名称

    public String getProviderName() {
        return providerName;
    }

    public void setProviderName(String providerName) {
        this.providerName = providerName;
    }

    public String getCategoryId() {
        return categoryId;
    }

    public void setCategoryId(String categoryId) {
        this.categoryId = categoryId;
    }

    public String getCategoryName() {
        return categoryName;
    }

    public void setCategoryName(String categoryName) {
        this.categoryName = categoryName;
    }

    public String getSourceId() {
        return sourceId;
    }

    public void setSourceId(String sourceId) {
        this.sourceId = sourceId;
    }

    public String getSourceName() {
        return sourceName;
    }

    public void setSourceName(String sourceName) {
        this.sourceName = sourceName;
    }

    public int getSourceStatus() {
        return sourceStatus;
    }

    public void setSourceStatus(int sourceStatus) {
        this.sourceStatus = sourceStatus;
    }

    public String getPipelineConf() {
        return pipelineConf;
    }

    public void setPipelineConf(String pipelineConf) {
        this.pipelineConf = pipelineConf;
    }

    public String getEsConfInfo() {
        return esConfInfo;
    }

    public void setEsConfInfo(String esConfInfo) {
        this.esConfInfo = esConfInfo;
    }

    public String getDbConfInfo() {
        return dbConfInfo;
    }

    public void setDbConfInfo(String dbConfInfo) {
        this.dbConfInfo = dbConfInfo;
    }

    public String getCronInfo() {
        return cronInfo;
    }

    public void setCronInfo(String cronInfo) {
        this.cronInfo = cronInfo;
    }

    public int getSourceType() {
        return sourceType;
    }

    public void setSourceType(int sourceType) {
        this.sourceType = sourceType;
    }

    public List<String> getIdBuildEles() {
        return idBuildEles;
    }

    public void setIdBuildEles(List<String> idBuildEles) {
        this.idBuildEles = idBuildEles;
    }

    public List<String> getIndexBuildEles() {
        return indexBuildEles;
    }

    public void setIndexBuildEles(List<String> indexBuildEles) {
        this.indexBuildEles = indexBuildEles;
    }

    public String getIndexType() {
        return indexType;
    }

    public void setIndexType(String indexType) {
        this.indexType = indexType;
    }

    public String getCategoryLevel1() {
        return categoryLevel1;
    }

    public void setCategoryLevel1(String categoryLevel1) {
        this.categoryLevel1 = categoryLevel1;
    }

    public String getZhName() {
        return zhName;
    }

    public void setZhName(String zhName) {
        this.zhName = zhName;
    }

    public TaskInfo(){}

    public List<String> getDbStoreTypes() {
        return dbStoreTypes;
    }

    public void setDbStoreTypes(List<String> dbStoreTypes) {
        this.dbStoreTypes = dbStoreTypes;
    }

    public Map<String, String> getOutputType() {
        return outputType;
    }

    public void setOutputType(Map<String, String> outputType) {
        this.outputType = outputType;
    }

    public String getFunctionName() {
        return functionName;
    }

    public void setFunctionName(String functionName) {
        this.functionName = functionName;
    }

    /**
     * 是否有相同的定时信息
     * @param taskInfo
     * @return
     */
    public boolean hasSameCronInfo(TaskInfo taskInfo){
        if(taskInfo == null) return false;
        return this.getCronInfo().equalsIgnoreCase(taskInfo.getCronInfo());
    }

    @Override
    public String toString() {
        return "TaskInfo{" +
                "categoryId='" + categoryId + '\'' +
                ", categoryName='" + categoryName + '\'' +
                ", sourceId='" + sourceId + '\'' +
                ", sourceName='" + sourceName + '\'' +
                ", sourceStatus=" + sourceStatus +
                ", pipelineConf='" + pipelineConf + '\'' +
                ", dbStoreTypes=" + dbStoreTypes +
                ", esConfInfo='" + esConfInfo + '\'' +
                ", dbConfInfo='" + dbConfInfo + '\'' +
                ", cronInfo='" + cronInfo + '\'' +
                ", sourceType=" + sourceType +
                ", indexBuildEles=" + indexBuildEles +
                ", idBuildEles=" + idBuildEles +
                ", indexType='" + indexType + '\'' +
                ", categoryLevel1='" + categoryLevel1 + '\'' +
                ", zhName='" + zhName + '\'' +
                ", outputType='" + outputType + '\'' +
                ", providerName='" + providerName + '\'' +
                ", functionName='" + functionName + '\'' +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        TaskInfo taskInfo = (TaskInfo) o;

        if (sourceStatus != taskInfo.sourceStatus) return false;
        if (sourceType != taskInfo.sourceType) return false;
        if (categoryName != null ? !categoryName.equals(taskInfo.categoryName) : taskInfo.categoryName != null)
            return false;
        if (sourceName != null ? !sourceName.equals(taskInfo.sourceName) : taskInfo.sourceName != null) return false;
        if (providerName != null ? !providerName.equals(taskInfo.providerName) : taskInfo.providerName != null) return false;
        if (pipelineConf != null ? !pipelineConf.equals(taskInfo.pipelineConf) : taskInfo.pipelineConf != null)
            return false;
        if (dbStoreTypes != null ? !dbStoreTypes.equals(taskInfo.dbStoreTypes) : taskInfo.dbStoreTypes != null)
            return false;
        if (esConfInfo != null ? !esConfInfo.equals(taskInfo.esConfInfo) : taskInfo.esConfInfo != null) return false;
        if (dbConfInfo != null ? !dbConfInfo.equals(taskInfo.dbConfInfo) : taskInfo.dbConfInfo != null) return false;
        if (cronInfo != null ? !cronInfo.equals(taskInfo.cronInfo) : taskInfo.cronInfo != null) return false;
        if (indexBuildEles != null ? !indexBuildEles.equals(taskInfo.indexBuildEles) : taskInfo.indexBuildEles != null)
            return false;
        if (idBuildEles != null ? !idBuildEles.equals(taskInfo.idBuildEles) : taskInfo.idBuildEles != null)
            return false;
        if (indexType != null ? !indexType.equals(taskInfo.indexType) : taskInfo.indexType != null) return false;
        if (categoryLevel1 != null ? !categoryLevel1.equals(taskInfo.categoryLevel1) : taskInfo.categoryLevel1 != null)
            return false;
        if (outputType != null ? !outputType.equals(taskInfo.outputType) : taskInfo.outputType != null)
            return false;
        if (functionName != null ? !functionName.equals(taskInfo.functionName) : taskInfo.functionName != null)
            return false;
        return zhName != null ? zhName.equals(taskInfo.zhName) : taskInfo.zhName == null;

    }

    @Override
    public int hashCode() {
        int result = categoryName != null ? categoryName.hashCode() : 0;
        result = 31 * result + (sourceName != null ? sourceName.hashCode() : 0);
        result = 31 * result + (providerName != null ? providerName.hashCode() : 0);
        result = 31 * result + sourceStatus;
        result = 31 * result + (pipelineConf != null ? pipelineConf.hashCode() : 0);
        result = 31 * result + (dbStoreTypes != null ? dbStoreTypes.hashCode() : 0);
        result = 31 * result + (esConfInfo != null ? esConfInfo.hashCode() : 0);
        result = 31 * result + (dbConfInfo != null ? dbConfInfo.hashCode() : 0);
        result = 31 * result + (cronInfo != null ? cronInfo.hashCode() : 0);
        result = 31 * result + sourceType;
        result = 31 * result + (indexBuildEles != null ? indexBuildEles.hashCode() : 0);
        result = 31 * result + (idBuildEles != null ? idBuildEles.hashCode() : 0);
        result = 31 * result + (indexType != null ? indexType.hashCode() : 0);
        result = 31 * result + (categoryLevel1 != null ? categoryLevel1.hashCode() : 0);
        result = 31 * result + (zhName != null ? zhName.hashCode() : 0);
        result = 31 * result + (outputType != null ? outputType.hashCode() : 0);
        result = 31 * result + (functionName != null ? functionName.hashCode() : 0);
        return result;
    }
}

3.3 任务的构造及初始化

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.gson.Gson;
import com.quartz.consts.SourceType;
import com.quartz.consts.Sql;
import com.quartz.consts.StatusType;
import com.quartz.module.TaskInfo;
import com.quartz.util.MongoUtil;
import com.quartz.util.MySqlUtil;
import com.quartz.util.TimeUtil;
import com.mongodb.BasicDBObject;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import org.bson.types.ObjectId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.sql.Connection;
import java.util.*;

/**
 * 获取调度任务的相关信息
 * Created by songwang4 on 2017/6/7.
 */
public class GenerateTaskInfo {

    static Logger logger = LoggerFactory.getLogger(GenerateTaskInfo.class);

    static DBCollection sourceColl = MongoUtil.createOcpSourceDB();
    static DBCollection categoryColl = MongoUtil.createOcpCategoryDB();

    /**
     * 从数据库中读取任务相关信息
     *
     * @return
     */
    public static List<TaskInfo> generateTaskInfoFromMongo() {
        // 将任务信息进行封装
        List<TaskInfo> tasks = Lists.newArrayList();
        TaskInfo task = null;

        DBCursor sourceCur = sourceColl.find();
        DBObject sourceObj = null;
        DBObject categoryObj = null;
        while (sourceCur.hasNext()) {
            sourceObj = sourceCur.next();
            task = new TaskInfo();

            String sourceName = sourceObj.get("sourceName").toString();
            String categoryName = sourceObj.get("category").toString();
            // 基于业务名查找对应的业务表信息
            categoryObj = categoryColl.findOne(new BasicDBObject("catName", categoryName));
            if (categoryObj == null) {
                logger.error("no category found through source: " + sourceName);
                continue;
            }

            task.setCategoryId(categoryObj.get("_id").toString()); // 业务Id
            task.setCategoryName(categoryName); // 业务名

            List<String> dbStoreTypes = Lists.newArrayList();
            if (categoryObj.containsField("storeType")) {
                try {
                    JSONArray storeTypeArr = JSON.parseArray(categoryObj.get("storeType").toString());
                    for (int i = 0; i < storeTypeArr.size(); i++) {
                        dbStoreTypes.add(storeTypeArr.getString(i));
                    }
                } catch (Exception e) {
                }
            }
            task.setDbStoreTypes(dbStoreTypes); // 存储类型

            task.setCategoryLevel1(categoryObj.get("parent").toString()); // 一级业务分类
            task.setZhName(sourceObj.get("zhName").toString());

            task.setDbConfInfo(categoryObj.containsField("db") ? categoryObj.get("db").toString() : categoryName); // DB配置
            task.setEsConfInfo(categoryObj.containsField("es") ? categoryObj.get("es").toString() : categoryName); // ES配置

            task.setIndexBuildEles(extractBuilderEles(categoryObj, "isIndex", "itemName")); // 构建ES索引信息
            task.setIdBuildEles(extractBuilderEles(categoryObj, "isGK", "itemName")); // 构建id的信息元素

            task.setSourceId(sourceObj.get("_id").toString()); // 信源Id
            task.setSourceName(sourceName); // 信源名称

            int status = StatusType.OFFLINE;
            if (sourceObj.containsField("status")) {
                String statusType = sourceObj.get("status").toString();
                if (statusType.equals(StatusType.STR_ONLINE)) {
                    status = StatusType.ONLINE;
                }
            }
            task.setSourceStatus(status); // 信源的上下线状态

            int sourceType = SourceType.REAL_TIME_PROCESS;
            if (sourceObj.containsField("type")) {
                String strStatusType = sourceObj.get("type").toString();
                if (strStatusType.equals(SourceType.STR_OFF_LINE_PROCESS)) {
                    sourceType = SourceType.OFF_LINE_PROCESS;
                }
            }
            task.setSourceType(sourceType); // 离线或实时处理

            task.setIndexType(sourceObj.containsField("indexType") ?
                    sourceObj.get("indexType").toString() : ""); // 增量或全量标识

            // 定时时间配置
            task.setCronInfo(sourceObj.containsField("timerInfo") ?
                    sourceObj.get("timerInfo").toString() : "");
            if (task.getCronInfo().trim().length() == 0) {
                task.setCronInfo(generateCronInfo(sourceObj));
            }

            task.setPipelineConf(sourceObj.containsField("mappingWorkflow") ?
                    sourceObj.get("mappingWorkflow").toString() : ""); // pipeline配置信息

            tasks.add(task);
        }
        sourceCur.close();
        return tasks;
    }

    /**
     * 构建生成id或es的信息元素
     *
     * @param categoryObj
     * @param queryField
     * @param retureField
     * @return
     */
    public static List<String> extractBuilderEles(DBObject categoryObj, String queryField, String retureField) {
        List<String> builerEles = Lists.newArrayList();
        JSONArray dataItemArr = null;
        try {
            dataItemArr = JSON.parseArray(categoryObj.get("dataItems").toString());
        } catch (JSONException e) {
        }
        if (dataItemArr != null && dataItemArr.size() > 0) {
            JSONObject dataItemJson = null;
            for (int i = 0; i < dataItemArr.size(); i++) {
                dataItemJson = dataItemArr.getJSONObject(i);
                if (dataItemJson.containsKey(queryField) && dataItemJson.getBoolean(queryField)) {
                    builerEles.add(dataItemJson.getString(retureField).trim());
                }
            }
        }
        return builerEles;
    }

    /**
     * 基于业务表中的信息构造定时任务表达式
     *
     * @param sourceObj
     * @return
     */
    public static String generateCronInfo(DBObject sourceObj) {
        String updateTimeType = "";
        String updateTimeCycle = "";
        if (sourceObj.containsField("updateType")) {
            updateTimeType = sourceObj.get("updateType").toString();
        }
        if (sourceObj.containsField("updateCycle")) {
            updateTimeCycle = sourceObj.get("updateCycle").toString();
        }
        if (updateTimeType.trim().length() == 0 || updateTimeCycle.trim().length() == 0) {
            return "";
        }

        StringBuilder sb = new StringBuilder();
        Date date = null;
        if (updateTimeType.equalsIgnoreCase("YEAR")) {
            date = TimeUtil.parseDate(updateTimeCycle, "MM-dd HH:mm");
            if (date == null) {
                try {
                    sb.append(TimeUtil.extractFixedTimeByDay(Integer.parseInt(updateTimeCycle), 0, 0));
                } catch (NumberFormatException e) {
                }
            } else {
                sb.append("0 ").append(TimeUtil.extractFixedTime(date, Calendar.MINUTE)).append(" ")
                        .append(TimeUtil.extractFixedTime(date, Calendar.HOUR_OF_DAY)).append(" ")
                        .append(TimeUtil.extractFixedTime(date, Calendar.DATE)).append(" ")
                        .append(TimeUtil.extractFixedTime(date, Calendar.MONTH) + 1).append(" ? *");
            }
        }

        if (updateTimeType.equalsIgnoreCase("MONTH")) {
            date = TimeUtil.parseDate(updateTimeCycle, "dd HH:mm");
            if (date == null) return "";
            sb.append("0 ").append(TimeUtil.extractFixedTime(date, Calendar.MINUTE)).append(" ")
                    .append(TimeUtil.extractFixedTime(date, Calendar.HOUR_OF_DAY)).append(" ")
                    .append(TimeUtil.extractFixedTime(date, Calendar.DATE)).append(" * ?");
        }

        if (updateTimeType.equalsIgnoreCase("DAY")) {
            date = TimeUtil.parseDate(updateTimeCycle, "HH:mm");
            if (date == null) return "";
            sb.append("0 ").append(TimeUtil.extractFixedTime(date, Calendar.MINUTE)).append(" ")
                    .append(TimeUtil.extractFixedTime(date, Calendar.HOUR_OF_DAY)).append(" * * ?");
        }

        if (updateTimeType.equalsIgnoreCase("WEEK")) {
            String weekDay = "1";
            if (sourceObj.containsField("weekDay")) {
                weekDay = sourceObj.get("weekDay").toString();
            }
            date = TimeUtil.parseDate(updateTimeCycle, "HH:mm");
            if (date == null) return "";
            sb.append("0 ").append(TimeUtil.extractFixedTime(date, Calendar.MINUTE)).append(" ")
                    .append(TimeUtil.extractFixedTime(date, Calendar.HOUR_OF_DAY)).append(" ? * ")
                    .append(TimeUtil.extractFixedTime(weekDay));
        }

        if (updateTimeType.equalsIgnoreCase("HOUR")) {
            try {
                int hour = Integer.parseInt(updateTimeCycle);
                sb.append(TimeUtil.extractFixedTimeByHour(hour, 0));
            } catch (NumberFormatException e) {
            }
        }

        if (updateTimeType.equalsIgnoreCase("MINUTE")) {
            try {
                int minute = Integer.parseInt(updateTimeCycle);
                sb.append(TimeUtil.extractFixedTimeByMinute(minute));
            } catch (NumberFormatException e) {
            }
        }

        if (updateTimeType.equalsIgnoreCase("SECOND")) {
            sb.append("*/").append(updateTimeCycle).append(" * * * * ?");
        }

        return sb.toString();
    }

    /**
     * 过滤下线的任务
     *
     * @param tasks
     * @return
     */
    public static List<TaskInfo> filterTask(List<TaskInfo> tasks) {
        List<TaskInfo> taskInfos = Lists.newArrayList();
        for (TaskInfo taskInfo : tasks) {
            // 过滤下线的信源状态或实时的信源
            if (taskInfo.getSourceStatus() == StatusType.OFFLINE
                    || taskInfo.getSourceType() != SourceType.OFF_LINE_PROCESS) {
                continue;
            }
            taskInfos.add(taskInfo);
        }
        return taskInfos;
    }

    /**
     * 基于业务名称对任务进行分组
     *
     * @param oriTasks
     * @return
     */
    public static Map<String, List<TaskInfo>> groupTaskByCategory(List<TaskInfo> oriTasks) {
        Map<String, List<TaskInfo>> categoryTasks = Maps.newHashMap();
        for (TaskInfo oriTask : oriTasks) {
            if (!categoryTasks.containsKey(oriTask.getCategoryId())) {
                List<TaskInfo> taskInfos = Lists.newArrayList();
                taskInfos.add(oriTask);
                categoryTasks.put(oriTask.getCategoryId(), taskInfos);
            } else {
                boolean hasSameSourceId = false;
                for (TaskInfo taskInfo : categoryTasks.get(oriTask.getCategoryId())) {
                    if (taskInfo.getSourceId().equals(oriTask.getSourceId())) {
                        hasSameSourceId = true;
                        break;
                    }
                }
                if (!hasSameSourceId) {
                    categoryTasks.get(oriTask.getCategoryId()).add(oriTask);
                }
            }
        }
        return categoryTasks;
    }
}

3.4 调用下载接口的任务

import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import com.pipes.entity.CrawlerLog;
import com.pipes.out.IDataOut;
import com.pipes.parser.PipeExecuter;
import com.quartz.consts.SourceType;
import com.quartz.consts.StatusType;
import com.quartz.consts.StoreType;
import com.quartz.module.TaskInfo;
import com.quartz.output.*;
import com.quartz.util.CrawlerLogUtil;
import org.apache.log4j.PropertyConfigurator;
import org.elasticsearch.common.Strings;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

/**
 * 离线存储任务
 * 注意：上一个任务如未完成，且下一次的定时任务已到执行时间，则需要等待上一个任务
 * 执行完成，再进行下一个任务
 */
@DisallowConcurrentExecution
public class ScheduleJob implements Job {
    static Logger logger = LoggerFactory.getLogger(ScheduleJob.class);

    public ScheduleJob() {
    }

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail = jobExecutionContext.getJobDetail();

        JSONObject json = new JSONObject();
        json.put("jobName", jobDetail.getKey().getName());
        json.put("jobGroup", jobDetail.getKey().getGroup());
        json.put("triggerName", jobExecutionContext.getTrigger().getKey().getName());
        json.put("triggerGroup", jobExecutionContext.getTrigger().getKey().getGroup());

        logger.info("job is running: " + json.toString());

        JobDataMap dataMap = jobDetail.getJobDataMap();
        JSONObject confJson = null;
        try {
            confJson = JSONObject.parseObject(dataMap.getString(SchedulerFactory.CONF_INFO));
        } catch (JSONException e) {
        }
        if (confJson == null) {
            logger.error("conf is empty: " + json.toString());
            return;
        }

        // 获取存储类型
        TaskInfo taskInfo = new Gson().fromJson(confJson.toString(), TaskInfo.class);
        if (!isNeedtoRun(taskInfo)) {
            logger.info("no need to run: " + json.toString());
            return;
        }

        List<IDataOut> dataOuts = Lists.newArrayList();
        for (String dbStoreType : taskInfo.getDbStoreTypes()) {
            switch (dbStoreType) {
                case StoreType.STR_MONGO_STORE:
                    dataOuts.add(new DataOut2Mongo(taskInfo.getFunctionName(), taskInfo.getSourceName(), taskInfo.getIdBuildEles(), taskInfo.getOutputType(),taskInfo.getProviderName()));
                    break;
                case StoreType.STR_ES_STORE:
                    dataOuts.add(new DataOut2ES(taskInfo.getCategoryName(),taskInfo.getFunctionName(), taskInfo.getSourceName(), taskInfo.getIdBuildEles(), taskInfo.getIndexBuildEles(), taskInfo.getOutputType(),taskInfo.getProviderName()));
                    break;
                case StoreType.STR_REDIS_STORE:
                    dataOuts.add(new DataOut2Redis(taskInfo.getSourceName(), taskInfo.getIdBuildEles(), taskInfo.getOutputType(),taskInfo.getProviderName()));
                    break;
            }
        }

        // 创建数据拉取对象，拉取前存储一次，拉取后存储一次
        CrawlerLog crawlerLog = createCrawlerLog(taskInfo);
        if (dataOuts.size() > 0) {
            PipeExecuter.executeSave(taskInfo.getPipelineConf(), dataOuts, crawlerLog);
        }
    }

    /**
     * 判断job是否需要执行
     *
     * @param taskInfo
     * @return
     */
    public static boolean isNeedtoRun(TaskInfo taskInfo) {

        // 实时or离线
        if (taskInfo.getSourceType() == SourceType.REAL_TIME_PROCESS) {
            logger.warn("the job is real-time process, no need to run");
            return false;
        }

        // job的上下线状态
        if (taskInfo.getSourceStatus() == StatusType.OFFLINE) {
            logger.warn("the job status is offline, no need to run");
            return false;
        }

        // pipeline的配置信息
        if (Strings.isNullOrEmpty(taskInfo.getPipelineConf()) || taskInfo.getPipelineConf().trim().length() == 0) {
            logger.warn("no pipeline configure info, no need to run");
            return false;
        }

        // job的存储信息
        if (taskInfo.getDbStoreTypes().size() == 0) {
            logger.warn("the job store type is 0, no need to store");
            return false;
        }
        return true;
    }

    /**
     * 创建拉取数据的日志，以便管理系统查看
     *
     * @param taskInfo
     * @return
     */
    public CrawlerLog createCrawlerLog(TaskInfo taskInfo) {
        CrawlerLog crawlerLog = new CrawlerLog();
        crawlerLog.setIndexType(taskInfo.getIndexType()); // 增量还是全量
        crawlerLog.setCategoryLv1(taskInfo.getCategoryLevel1());
        String sourceName = taskInfo.getSourceName();
        String sourceZhName = taskInfo.getZhName();
        String sourceArr[] = sourceName.split("_");
        String sourceZhArr[] = sourceZhName.split("_");

        crawlerLog.setCategoryLv2((sourceArr != null && sourceArr.length > 0) ? sourceArr[0] : "");
        crawlerLog.setFunctionName((sourceArr != null && sourceArr.length > 1) ? sourceArr[1] : "");
        crawlerLog.setProviderName((sourceArr != null && sourceArr.length > 2) ? sourceArr[2] : "");

        crawlerLog.setFunctionZhName((sourceZhArr != null && sourceZhArr.length > 1) ? sourceZhArr[1] : "");
        crawlerLog.setProviderZhName((sourceZhArr != null && sourceZhArr.length > 2) ? sourceZhArr[2] : "");
        crawlerLog.setId();
        return crawlerLog;
    }
}

3.5 任务调度工厂

工厂用于生成任务的触发器Trigger，以及创建任务Job。

import com.google.gson.Gson;
import com.quartz.consts.PrefixType;
import com.quartz.module.TaskInfo;
import org.quartz.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SchedulerFactory {
    static Logger logger = LoggerFactory.getLogger(SchedulerFactory.class);

    public static final String CONF_INFO = "conf_info";
    public static final String DYNAMIC_UPDATE_JOB_NAME = "dynamicUpdateJob";
    public static final String DYNAMIC_UPDATE_GROUP_NAME = "dynamicUpdateGroup";
    public static final String DYNAMIC_UPDATE_CRONTINFO = "*/30 * * * * ?";

    /**
     * 将任务加入任务调度中
     * @param taskInfo
     * @param scheduler
     */
    public static void addJob2Scheduler(TaskInfo taskInfo, Scheduler scheduler) {
        try {
            JobDetail jobDetail = generateJobDetail(taskInfo);
            if(jobDetail == null){
                logger.error("create job failed!");
                return;
            }

            Trigger triger = generateTrigger(taskInfo);
            if(triger == null){
                logger.error("create trigger failed!");
                return;
            }

            // 加载执行Job及定时器
            scheduler.scheduleJob(jobDetail,triger);
        } catch (SchedulerException e) {
            logger.error("create scheduler error, error message: "+e.toString());
        }
    }

    public static void addDynamicUpdateJob2Scheduler(Scheduler scheduler) {
        try {
            JobDetail jobDetail = generateDynamicUpdateJobDetail(DYNAMIC_UPDATE_JOB_NAME, DYNAMIC_UPDATE_GROUP_NAME);
            if(jobDetail == null){
                logger.error("create job failed!");
                return;
            }

            Trigger triger = generateTrigger(DYNAMIC_UPDATE_JOB_NAME, DYNAMIC_UPDATE_GROUP_NAME, DYNAMIC_UPDATE_CRONTINFO);
            if(triger == null){
                logger.error("create trigger failed!");
                return;
            }

            // 加载执行Job及定时器
            scheduler.scheduleJob(jobDetail,triger);
        } catch (SchedulerException e) {
            logger.error("create scheduler error, error message: "+e.toString());
        }
    }

    /**
     * 于信源信息生成对应的job
     * @param taskInfo
     * @return
     */
    public static JobDetail generateJobDetail(TaskInfo taskInfo) {
        String jobName = taskInfo.getSourceName();
        if(jobName.trim().length() == 0){
            logger.error("job name is empty, please check!");
            return null;
        }

        String jobGroup = taskInfo.getCategoryName();
        if(jobGroup.trim().length() == 0){
            logger.error("job group is empty, please check!");
            return null;
        }

        return JobBuilder.newJob(ScheduleJob.class)
                .withIdentity(PrefixType.JOB_PREFIX+jobName, PrefixType.JOB_PREFIX+jobGroup)
                .requestRecovery()
                .usingJobData(CONF_INFO, new Gson().toJson(taskInfo)).build();
    }

    public static JobDetail generateDynamicUpdateJobDetail(String jobName, String jobGroup) {
        if(jobName.trim().length() == 0){
            logger.error("job name is empty, please check!");
            return null;
        }

        if(jobGroup.trim().length() == 0){
            logger.error("job group is empty, please check!");
            return null;
        }

        return JobBuilder.newJob(DynamicUpdateJob.class)
                .withIdentity(PrefixType.JOB_PREFIX+jobName, PrefixType.JOB_PREFIX+jobGroup)
                .requestRecovery()
                .build();
    }

    /**
     * 基于信源信息生成对应的trigger
     * @param taskInfo
     * @return
     */
    public static Trigger generateTrigger(TaskInfo taskInfo) {
        String sourceTriggerName = taskInfo.getSourceName();
        if(sourceTriggerName.trim().length() == 0){
            logger.error("trigger name is empty, please check!");
            return null;
        }
        String sourceTriggerGroup = taskInfo.getCategoryName();
        if(sourceTriggerGroup.trim().length() == 0){
            logger.error("trigger group is empty, please check!");
            return null;
        }
        String cronInfo = taskInfo.getCronInfo();
        if(cronInfo.trim().length() == 0){
            logger.error("cron timer info is empty, please check!");
            return null;
        }
        return TriggerBuilder.newTrigger().withIdentity(PrefixType.TRIGGER_PREFIX+sourceTriggerName,
                PrefixType.TRIGGER_PREFIX+sourceTriggerGroup)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronInfo))
                .build();
    }

    public static Trigger generateTrigger(String sourceTriggerName, String sourceTriggerGroup, String cronInfo) {
        if(sourceTriggerName.trim().length() == 0){
            logger.error("trigger name is empty, please check!");
            return null;
        }
        if(sourceTriggerGroup.trim().length() == 0){
            logger.error("trigger group is empty, please check!");
            return null;
        }
        if(cronInfo.trim().length() == 0){
            logger.error("cron timer info is empty, please check!");
            return null;
        }
        return TriggerBuilder.newTrigger().withIdentity(PrefixType.TRIGGER_PREFIX+sourceTriggerName,
                PrefixType.TRIGGER_PREFIX+sourceTriggerGroup)
                .withSchedule(CronScheduleBuilder.cronSchedule(cronInfo))
                .build();
    }
}

3.6 动态检测任务更新的Job

import com.alibaba.fastjson.JSONObject;
import com.google.common.collect.Lists;
import com.google.gson.Gson;
import com.quartz.consts.PrefixType;
import com.quartz.module.TaskInfo;
import org.quartz.*;
import org.quartz.impl.matchers.GroupMatcher;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;

@DisallowConcurrentExecution
public class DynamicUpdateJob implements Job{

    private static Logger logger = LoggerFactory.getLogger(DynamicUpdateJob.class);

    public DynamicUpdateJob(){}

    @Override
    public void execute(JobExecutionContext jobExecutionContext) throws JobExecutionException {
        JobDetail jobDetail = jobExecutionContext.getJobDetail();

        JSONObject json = new JSONObject();
        json.put("jobName", jobDetail.getKey().getName());
        json.put("jobGroup", jobDetail.getKey().getGroup());
        json.put("triggerName", jobExecutionContext.getTrigger().getKey().getName());
        json.put("triggerGroup", jobExecutionContext.getTrigger().getKey().getGroup());

        logger.info("job is running: "+json.toString());

        // 获取当前的调度器
        Scheduler scheduler = jobExecutionContext.getScheduler();

        // 获取配置信息中的任务(注意需要保持)
        List<TaskInfo> confTaskInfos = GenerateTaskInfo.generateTaskInfoFromMysql();

        // 获取所有的job信息
        List<JobKey> schedulerJobKeys = acquireJobKeysWithinSceduler(scheduler);

        // 1. 配置任务不存在，而sheduler相关任务存在，则进行下线处理
        for(JobKey schedulerJobKey : schedulerJobKeys ){
            boolean hasSameJobKeyInConfTask = false;
            for(TaskInfo confTaskInfo : confTaskInfos){
                if(generateJobKey(confTaskInfo).equals(schedulerJobKey)){
                    hasSameJobKeyInConfTask = true;
                    break;
                }
            }
            if(!hasSameJobKeyInConfTask){
                try {
                    scheduler.deleteJob(schedulerJobKey);
                    logger.info("delete offline job: "+schedulerJobKey.toString());
                } catch (SchedulerException e) {
                    logger.error("delete offline job error: "+json.toString());
                }
            }
        }

        // 2 配置任务与调度器任务比较
        for(TaskInfo confTaskInfo : confTaskInfos){
            JobKey confJobKey = generateJobKey(confTaskInfo);

            boolean hasSameJob = false;
            for(JobKey schedulerJobKey : schedulerJobKeys ){
                if(confJobKey.equals(schedulerJobKey)){
                    hasSameJob = true;
                    break;
                }
            }

            if(hasSameJob){  //具有相同名称的job
                logger.info("has same jobKey: "+confJobKey);
                JobDetail schedulerJobDetail = null;
                try {
                    schedulerJobDetail = scheduler.getJobDetail(confJobKey);
                } catch (SchedulerException e) {
                    logger.error("get job detail from scheduler error: "+confJobKey);
                }
                if(schedulerJobDetail == null) continue;

                // 1) 是否需要下线
                if(!ScheduleJob.isNeedtoRun(confTaskInfo)){
                    try {
                        logger.info("has same jobKey and offline the job "+confJobKey);
                        scheduler.deleteJob(confJobKey);
                    } catch (SchedulerException e) {
                        logger.error("delete offline job error: "+confJobKey);
                    }
                }else{
                    // 2) 是否需要更新任务
                    TaskInfo schedulerTaskInfo = parseTaskInfoFromJobDataMap(schedulerJobDetail);
                    logger.info("confTaskInfo: " + confTaskInfo);
                    logger.info("schedulerTaskInfo: " + schedulerTaskInfo);
                    if(!confTaskInfo.equals(schedulerTaskInfo)){
                        try {
                            logger.info("has same jobKey and update the job "+confJobKey);
                            scheduler.deleteJob(confJobKey);
                            SchedulerFactory.addJob2Scheduler(confTaskInfo, scheduler);
                        } catch (SchedulerException e) {
                            logger.error("update scheduler info error: "+confJobKey);
                        }
                    }else{
                        logger.info("the job info is same "+confJobKey);
                    }
                }
            }else{ // 创建新的Job
                // 1) 是否满足上线的条件
                if(!ScheduleJob.isNeedtoRun(confTaskInfo)){
                    logger.info("the status is offline, no need to create new job: "+confJobKey);
                    continue;
                }

                logger.info("no same jobKey and create job "+confJobKey);

                // 2) 上线
                SchedulerFactory.addJob2Scheduler(confTaskInfo, scheduler);
            }
        }
    }

    protected List<JobKey> acquireJobKeysWithinSceduler(Scheduler scheduler){
        List<JobKey> jobKeys = Lists.newArrayList();
        try {
            for(String groupName : scheduler.getJobGroupNames()){
                if(groupName.equals(PrefixType.JOB_PREFIX+SchedulerFactory.DYNAMIC_UPDATE_GROUP_NAME)){
                    continue;
                }
                for(JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))){
                    jobKeys.add(jobKey);
                }
            }
        } catch (SchedulerException e) {
        }
        return jobKeys;
    }

    protected  TaskInfo parseTaskInfoFromJobDataMap(JobDetail jobDetail){
        try {
            String confInfo = jobDetail.getJobDataMap().getString(SchedulerFactory.CONF_INFO);
            return new Gson().fromJson(confInfo, TaskInfo.class);
        } catch (Exception e) {
            logger.error("parse task info from JobDataMap error!");
            return null;
        }
    }

    protected JobKey generateJobKey(TaskInfo taskInfo){
        return generateJobKey(taskInfo.getSourceName(), taskInfo.getCategoryName());
    }

    protected JobKey generateJobKey(String jobName, String jobGroup){
        return JobKey.jobKey(PrefixType.JOB_PREFIX+jobName,PrefixType.JOB_PREFIX+jobGroup);
    }
}

3.7 Es数据库存储

import com.alibaba.fastjson.JSONObject;
import com.pipes.out.IDataOut;
import com.quartz.conf.Configuration;
import com.quartz.conf.OcpConfHelper;
import com.quartz.util.IdBuilder;
import com.quartz.util.OutputTypeTransform;
import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.action.ActionListener;
import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.InetSocketTransportAddress;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.reindex.DeleteByQueryAction;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.List;
import java.util.Map;

/**
 * Created by songwang4 on 2017/6/7.
 */
public class DataOut2ES implements IDataOut, IDataClose {

    static Logger logger = LoggerFactory.getLogger(DataOut2ES.class);

    static TransportClient client;

    String indexName; // 默认为ocp

    String typeName;
    String sourceName;

    List<String> indexBuildEles;
    List<String> idBuilderEles;

    Map<String,String> outputType;

    String providerName;

    public DataOut2ES(String indexName,String type){
        this.indexName = indexName;
        this.typeName = type;
        init();
    }

    public DataOut2ES(String indexName,String type, List<String> indexBuildEles){
        this(indexName,type);
        this.indexBuildEles = indexBuildEles;
    }

    public DataOut2ES(String indexName,String type, List<String> idBuilderEles, List<String> indexBuildEles){
        this(indexName,type, indexBuildEles);
        this.idBuilderEles = idBuilderEles;
    }

    public DataOut2ES(String indexName,String type, String sourceName, List<String> idBuilderEles, List<String> indexBuildEles){
        this(indexName,type, idBuilderEles, indexBuildEles);
        this.sourceName = sourceName;
    }

    public DataOut2ES(String indexName,String type, String sourceName, List<String> idBuilderEles, List<String> indexBuildEles, Map<String,String> outputType,String providerName){
        this(indexName,type,sourceName, idBuilderEles, indexBuildEles);
        this.outputType = outputType;
        this.providerName = providerName;
    }

    public static void init() {
        if(client == null){
            Configuration conf = OcpConfHelper.getInstance().getOcpConf();

            String esClusterName = conf.getStringValue("ocp_es_cluster_name", "");
            String esIp = conf.getStringValue("ocp_es_ip", "");
            int esPort = conf.getIntValue("ocp_es_port", "");

            Settings settings = Settings.builder()
                    .put("cluster.name",esClusterName)
                    .put("client.transport.sniff", true)
                    .put("client.transport.ping_timeout", "120s")
                    .put("client.transport.nodes_sampler_interval","30s").build();
            try {
                client = new PreBuiltTransportClient(settings)
                        .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName(esIp),esPort));
            } catch (UnknownHostException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 批量写入
     * @param datas
     */
    public void save(List<JSONObject> datas) {
        // 批量的插入数据
        BulkRequestBuilder bulkRequest = client.prepareBulk();
        for(JSONObject data : datas){

            //按输出字段类型进行转换
//            data = OutputTypeTransform.transform(data,outputType);

            String id64 = IdBuilder.generateId(this.sourceName, data, this.idBuilderEles);
            if(id64.trim().length() == 0) continue;

            JSONObject indexJson = new JSONObject();
            for(String indexBuildEle : this.indexBuildEles){
                if(data.containsKey(indexBuildEle)){
                    indexJson.put(indexBuildEle, data.get(indexBuildEle));
                }
            }
            if(indexJson.keySet().isEmpty()){
                logger.info("no json fields, so no need to save");
                return;
            }

            bulkRequest.add(client.prepareIndex(indexName, typeName, id64).setSource(indexJson.toString()));
        }
        BulkResponse bulkResponse = bulkRequest.execute().actionGet();
        if(bulkResponse.hasFailures()){
            logger.error("insert data 2 es error "+indexName);
            System.out.println(bulkResponse.buildFailureMessage());
        }
    }

    public void saveWithoutIndexBuilds(List<JSONObject> datas) {
        // 批量的插入数据
        BulkRequestBuilder bulkRequest = client.prepareBulk();
        for(JSONObject data : datas){
            bulkRequest.add(client.prepareIndex(indexName, typeName).setSource(data.toString()));
        }
        BulkResponse bulkResponse = bulkRequest.execute().actionGet();
        if(bulkResponse.hasFailures()){
            logger.error("insert data 2 es error "+indexName);
            System.out.println(bulkResponse.buildFailureMessage());
        }
    }

    public void saveWithoutIndexBuilds2(List<JSONObject> datas) {
        // 批量的插入数据
        BulkRequestBuilder bulkRequest = client.prepareBulk();
        for(JSONObject data : datas){
            String _id = data.getString("_id");
            JSONObject source = data.getJSONObject("_source");
            bulkRequest.add(client.prepareIndex(indexName, typeName,_id).setSource(source.toString()));
        }
        BulkResponse bulkResponse = bulkRequest.execute().actionGet();
        if(bulkResponse.hasFailures()){
            logger.error("insert data 2 es error "+indexName);
            System.out.println(bulkResponse.buildFailureMessage());
        }
    }

    /**
     * 判断索引是否存在
     * @param indexName
     * @return
     */
    public boolean isExistsIndex(String indexName){
        IndicesExistsResponse response = client.admin().indices()
                .exists(new IndicesExistsRequest().indices(new String[]{indexName})).actionGet();
        return response.isExists();
    }

    /**
     * 创建索引信息
     * @param indexName
     * @return
     */
    public boolean createIndex(String indexName){
        try {
            CreateIndexResponse indexResponse = this.client
                    .admin()
                    .indices()
                    .prepareCreate(indexName)
                    .get();
            return indexResponse.isAcknowledged();
        } catch (ElasticsearchException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public void save(Object data) {
        if(this.indexBuildEles.size() == 0){
            logger.error("index fields are empty in es, no index need to save, info: " + data.toString());
            return;
        }

        // 逐条插入数据
        JSONObject json = null;
        try {
            json = (JSONObject)data;
        } catch (Exception e) {
            logger.error("trans data to json error in es :" + data.toString());
            return;
        }
        if(json == null){
            logger.error("trans data to Json error in es, info " + data.toString());
            return;
        }

//        json = OutputTypeTransform.transform(json,outputType);

        // 构建索引id
        String id64 = IdBuilder.generateId(this.sourceName, json, this.idBuilderEles);
        if(id64.trim().length() == 0){
            logger.error("generate 64 bit id is null,please check: " + data.toString());
            return;
        }

        JSONObject indexJson = new JSONObject();
        for(String indexBuildEle : this.indexBuildEles){
            if(json.containsKey(indexBuildEle)){
                indexJson.put(indexBuildEle, json.get(indexBuildEle));
            }
        }

        if(indexJson.keySet().isEmpty()){
            logger.info("no json fields, so no need to save");
            return;
        }

        logger.info("index info: "+indexJson);

        IndexResponse response = client.prepareIndex(this.indexName, this.typeName, id64).setSource(indexJson.toString()).get();
        if(response.status() != RestStatus.CREATED && response.status() != RestStatus.OK){
            logger.error("index error in es, status is "+response.status().getStatus()+"info: " + data.toString());
            return;
        }
    }

    @Override
    public void close() {
    }
}

　　以上代码均为与Quartz相关的整体流程，虽然各个细节方面的代码，如配置类，数据库初始化类或加载类、以及部分帮助类没有展示，但对于Quartz的核心使用，已略窥一二。如有问题，可留言回复。

4. 集群模式

注意：上述默认使用Quartz集群模式，从主流程加载的quartz.properties中配置的集群模式如下，可进行参考。

#============================================================================
# Configure Main Scheduler Properties
#============================================================================

org.quartz.scheduler.instanceName: OcpScheduler
org.quartz.scheduler.instanceId: OcpInstance

org.quartz.scheduler.skipUpdateCheck: true

#============================================================================
# Configure ThreadPool
#============================================================================
org.quartz.threadPool.class: org.quartz.simpl.SimpleThreadPool
org.quartz.threadPool.threadCount: 50
org.quartz.threadPool.threadPriority: 5
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread: true

#============================================================================
# Configure JobStore
#============================================================================
org.quartz.jobStore.misfireThreshold: 120000

org.quartz.jobStore.class: org.quartz.impl.jdbcjobstore.JobStoreTX
org.quartz.jobStore.driverDelegateClass: org.quartz.impl.jdbcjobstore.StdJDBCDelegate
org.quartz.jobStore.useProperties: false
org.quartz.jobStore.tablePrefix: QRTZ_
org.quartz.jobStore.dataSource: ocpQzDs
org.quartz.jobStore.isClustered: true
org.quartz.jobStore.clusterCheckinInterval = 60000 

#============================================================================
# Configure Datasources
#============================================================================
org.quartz.dataSource.ocpQzDs.driver: com.mysql.jdbc.Driver
org.quartz.dataSource.ocpQzDs.URL:jdbc:mysql://192.168.1.1:3306/test?useUnicode=true&characterEncoding=utf-8
org.quartz.dataSource.ocpQzDs.user: test
org.quartz.dataSource.ocpQzDs.password: test
org.quartz.dataSource.ocpQzDs.maxConnection: 30

#============================================================================
# Configure Plugins
#============================================================================
org.quartz.plugin.shutdownHook.class: org.quartz.plugins.management.ShutdownHookPlugin
org.quartz.plugin.shutdownHook.cleanShutdown: true

#org.quartz.plugin.triggHistory.class: org.quartz.plugins.history.LoggingJobHistoryPlugin