Elastic-Job源码分析之JobScheduler类分析

JobScheduler这个类是EJ中比较核心的一个类，我们现在开始解析这个类。

一、构造器

首先我们看一下JobScheduler的几个构造器。

    private JobScheduler(final CoordinatorRegistryCenter regCenter, final LiteJobConfiguration liteJobConfig, final JobEventBus jobEventBus, final ElasticJobListener... elasticJobListeners) {

        JobRegistry.getInstance().addJobInstance(liteJobConfig.getJobName(), new JobInstance());

        this.liteJobConfig = liteJobConfig;

        this.regCenter = regCenter;

        List<ElasticJobListener> elasticJobListenerList = Arrays.asList(elasticJobListeners);

        setGuaranteeServiceForElasticJobListeners(regCenter, elasticJobListenerList);

        schedulerFacade = new SchedulerFacade(regCenter, liteJobConfig.getJobName(), elasticJobListenerList);

        jobFacade = new LiteJobFacade(regCenter, liteJobConfig.getJobName(), Arrays.asList(elasticJobListeners), jobEventBus);

    }

这个构造器比较清晰，第一个参数regCenter表示的是注册中心，这里我们用的是zk作为我们的注册中心，所以这块的配置我们一般从xml配置文件中读取即可。我们按照官方文档配置即可。

    <!--配置作业注册中心 -->

    <reg:zookeeper id="regCenter" server-lists="ip1:2181,ip2:2181"

                   namespace="your-job-name" base-sleep-time-milliseconds="1000" max-sleep-time-milliseconds="3000"

                   max-retries="3"/>

然后从xml文件中取出该配置即可。

ApplicationContext context = new ClassPathXmlApplicationContext("classpath:spring/applicationContext-job.xml");

		ZookeeperRegistryCenter zookeeperRegistryCenter = context.getBean(ZookeeperRegistryCenter.class);

第二个参数liteJobConfig表示的是作业的一些配置，这块我们后续再细细了解。

第三个参数jobEventBus表示作业运行痕迹总线。如果想把作业运行的内容写到DB中，我们需要用到另一个构造器，同时定义自己的JobEventConfiguration，目前来说实现这个接口的只有一个类JobEventRdbConfiguration，通过这个可以将作业运行的痕迹进行持久化到DB的操作。

第四个参数elasticJobListeners表示一些监听器，这里我们可以定义一些监听器，具体的监听器我们可以参考官方文档。

二、初始化

定义好我们的作业后，怎么将我们的作业运行起来呢？这块就需要用到我们的初始化作业的方法init()。

public void init() {

    JobRegistry.getInstance().setCurrentShardingTotalCount(liteJobConfig.getJobName(), liteJobConfig.getTypeConfig().getCoreConfig().getShardingTotalCount());

    JobScheduleController jobScheduleController = new JobScheduleController(createScheduler(), createJobDetail(liteJobConfig.getTypeConfig().getJobClass()), liteJobConfig.getJobName());

    JobRegistry.getInstance().registerJob(liteJobConfig.getJobName(), jobScheduleController, regCenter);

    schedulerFacade.registerStartUpInfo(liteJobConfig);

    jobScheduleController.scheduleJob(liteJobConfig.getTypeConfig().getCoreConfig().getCron());

    }

初始化主要做了以下几个动作：

设置当前分片总数setCurrentShardingTotalCount
创建调度器createScheduler
创建任务详情createJobDetail
将作业在zk上面进行注册registerJob
注册作业启动信息registerStartUpInfo
开始进行作业调度scheduleJob

这几个动作是一个作业能够最终被调度的关键，我们来一一分析。

2.1 createScheduler

    private Scheduler createScheduler() {

        Scheduler result;

        try {

            StdSchedulerFactory factory = new StdSchedulerFactory();

            factory.initialize(getBaseQuartzProperties());//TODO 每次新建任务都会创建一个线程，会导致线程数过多

            result = factory.getScheduler();

        } catch (final SchedulerException ex) {

            throw new JobSystemException(ex);

        }

        return result;

    }

这个方法调用了quartz底层的方法，创建了一个调度器。我们看看quartz中的一些配置：

private Properties getBaseQuartzProperties() {

    Properties result = new Properties();

    result.put("org.quartz.threadPool.class", org.quartz.simpl.SimpleThreadPool.class.getName());

    result.put("org.quartz.threadPool.threadCount", "1");

    result.put("org.quartz.scheduler.instanceName", liteJobConfig.getJobName());

    result.put("org.quartz.jobStore.misfireThreshold", "1");

    result.put("org.quartz.plugin.shutdownhook.class", JobShutdownHookPlugin.class.getName());

    result.put("org.quartz.plugin.shutdownhook.cleanShutdown", Boolean.TRUE.toString());

    return result;

}

我们可以看到一个比较重要的参数：org.quartz.threadPool.threadCount，这里设置为了1，也就是说每个任务，EJ默认都会创建一个线程来进行调度，所以如果想动态的创建任务，你就要考虑好你的内存够不够这些线程使用了。

2.2 createJobDetail

private JobDetail createJobDetail(final String jobClass) {

    JobDetail result = JobBuilder.newJob(LiteJob.class).withIdentity(liteJobConfig.getJobName()).build();

    result.getJobDataMap().put(JOB_FACADE_DATA_MAP_KEY, jobFacade);

    Optional<ElasticJob> elasticJobInstance = createElasticJobInstance();

    if (elasticJobInstance.isPresent()) {

        result.getJobDataMap().put(ELASTIC_JOB_DATA_MAP_KEY, elasticJobInstance.get());

    } else if (!jobClass.equals(ScriptJob.class.getCanonicalName())) {

        try {

            result.getJobDataMap().put(ELASTIC_JOB_DATA_MAP_KEY, Class.forName(jobClass).newInstance());

        } catch (final ReflectiveOperationException ex) {

            throw new JobConfigurationException("Elastic-Job: Job class '%s' can not initialize.", jobClass);

        }

    }

    return result;

}

这个方法创建了任务的一些属性。

首先调用JobBuilder的构造器方法，生成了一个详细的任务。
然后将作业的门面放入到作业内部的一个作业数据map中，相当于是一个缓存。
调用createElasticJobInstance创建实例，生成一个Optional的类，这个Optional是Guava中的一个类，后续咱们再研究。我们只需要知道创建了一个实例就行了，实例放在了Optional这个容器中，而Optional可以做一些额外的判断。我们可以联想一下，利用Optional来处理null？
判断实例是否创建成功，通过isPresent()方法来判断。Optional的这个方法判断实例是否为空。
- 如果不为空，就把实例放入到缓存map中。
- 否则，调用反射，把实例放入缓存map中。如果异常的话，直接抛出异常，说明实例化失败。

2.3 registerJob

看方法名我们就能知道，这个方法的作用是注册我们的任务。

/**

 * 添加作业调度控制器.

 *

 * @param jobName 作业名称

 * @param jobScheduleController 作业调度控制器

 * @param regCenter 注册中心

 */

public void registerJob(final String jobName, final JobScheduleController jobScheduleController, final CoordinatorRegistryCenter regCenter) {

    schedulerMap.put(jobName, jobScheduleController);

    regCenterMap.put(jobName, regCenter);

    regCenter.addCacheData("/" + jobName);

}

这步的操作，把作业控制调度器放入到调度缓存中，把任务信息放入到regCenter的缓存中。另外还把任务名称加入到本地缓存中。

2.4 registerStartUpInfo

这个方法是注册一些任务的启动信息，这块的步骤比较多，需要细细理解一下。

    public void registerStartUpInfo(final boolean enabled) {

        listenerManager.startAllListeners();

        leaderService.electLeader();

        serverService.persistOnline(enabled);

        instanceService.persistOnline();

        shardingService.setReshardingFlag();

        monitorService.listen();

        if (!reconcileService.isRunning()) {

            reconcileService.startAsync();

        }

    }

第一步，启动所有监听器。

    public void startAllListeners() {

        electionListenerManager.start();//主节点选举

        shardingListenerManager.start();//分片

        failoverListenerManager.start();//失效转移

        shutdownListenerManager.start();//关闭

        triggerListenerManager.start();//触发器

        rescheduleListenerManager.start();//重新调度

        guaranteeListenerManager.start();//保证分布式任务全部开始和结束状态

        jobNodeStorage.addConnectionStateListener(regCenterConnectionStateListener);//注册中心与任务节点的连接状态

    }

第二步，选举主节点。这块底层调用的是curator的方法，一个zk的客户端。
第三步，持久化作业信息到zk中。先把服务器信息持久化，再把作业实例信息持久化，
第四步，设置重新分片的信息，同样也是在zk中。
第五步，初始化作业监听服务。
最后，调解分布式作业不一致状态服务异步启动。

可以看到，这块做的东西比较多，而且最近版本这块修改的内容也比较多。总的来说，就是启动监听器，同时将作业的信息持久化到zk中。

2.5 scheduleJob

调度作业，这块是一个比较基础的服务。底层调用的是quartz的方法。

初始化这块就分析完了，里面的东西还是挺多的。今天就先分析到这里，咱们以后再细细分析吧。

巴特西