pursuing_tech
pursuing_tech

elasticjob-lite源码解析

写在前面

elasticjob是当当开源的分布式定时任务调度中间件，目前在github上有6k+的star。elasticjob有两种模式：lite模式和cloud模式，本文只是想探究主流分布式定时任务调度中间件的实现原理，因此只解析较为简单的lite模式。

不知道大家有没有想过一个单机定时任务是怎么去驱动的？我们很容易想到jdk的ScheduledExecutorService，它的原理就是将任务丢进按照执行时间排序的队列，然后线程池中的线程不断扫描最近的任务，如果任务已经到了执行时间，取出并执行任务即可。那还有没有其他方式呢？是不是也可以把任务存储在非本地内存上，存在本地文件或者redis zetset或者db，然后也是通过线程不断扫描取出任务执行，这样做能够有效避免本地内存任务数据的丢失。或者也可以通过更好的数据结构如时间轮存储任务数据，这样做能够有效减少任务的扫描范围，提高执行效率。

理解了这一单机定时任务的实现原理后，对于分布式的定时任务就很容易理解了，需要解决的就是如何跟执行同一任务的集群协调、如何获取分布式任务、如何将分布式任务分片"降级"成单机任务罢了。重点已经不是最后的单机任务执行，而是集群的任务协调处理方式。

elasticjob的分布式任务的集群协调通过成熟的分布式协调服务zookeeper来实现，而单机定时任务通过成熟的定时任务框架quartz来实现。elasticjob的架构图如下。

elasticjob-lite架构图

job的初始化

下面开始源码解析，ScheduleJobBootstrap是elasticjob的启动器，JobScheduler的构造方法拥有三个必选的入参：CoordinatorRegistryCenter协调中心、ElasticJob自定义任务处理器、JobConfiguration任务配置，一个可选入参：ElasticJobListener任务监听器。然后调用schedule方法，进而调用jobScheduler.getJobScheduleController().scheduleJob进行定时任务的调度。

    public ScheduleJobBootstrap(final CoordinatorRegistryCenter regCenter, final ElasticJob elasticJob, final JobConfiguration jobConfig, final ElasticJobListener... elasticJobListeners) {
        jobScheduler = new JobScheduler(regCenter, elasticJob, jobConfig, elasticJobListeners);
    }

    public void schedule() {
        Preconditions.checkArgument(!Strings.isNullOrEmpty(jobScheduler.getJobConfig().getCron()), "Cron can not be empty.");
        jobScheduler.getJobScheduleController().scheduleJob(jobScheduler.getJobConfig().getCron());
    }

进入JobScheduler的构造方法，主要有5种类型的方法：生成SetUpFacade、SchedulerFacade、LiteJobFacade，生成ElasticJobExecutor，调用setUpFacade.setUpJobConfiguration初始化配置，调用setGuaranteeServiceForElasticJobListeners为listener设置GuaranteeService，createJobScheduleController完成收尾，接下来一个个分析这些方法。

    public JobScheduler(final CoordinatorRegistryCenter regCenter, final ElasticJob elasticJob, final JobConfiguration jobConfig, final TracingConfiguration tracingConfig,
                        final ElasticJobListener... elasticJobListeners) {
        this.regCenter = regCenter;
        this.elasticJob = elasticJob;
        elasticJobType = null;
        this.elasticJobListeners = Arrays.asList(elasticJobListeners);
        setUpFacade = new SetUpFacade(regCenter, jobConfig.getJobName(), this.elasticJobListeners);
        schedulerFacade = new SchedulerFacade(regCenter, jobConfig.getJobName());
        jobFacade = new LiteJobFacade(regCenter, jobConfig.getJobName(), this.elasticJobListeners, tracingConfig);
        jobExecutor = null == elasticJob ? new ElasticJobExecutor(elasticJobType, jobConfig, jobFacade) : new ElasticJobExecutor(elasticJob, jobConfig, jobFacade);
        String jobClassName = JobClassNameProviderFactory.getProvider().getJobClassName(elasticJob);
        this.jobConfig = setUpFacade.setUpJobConfiguration(jobClassName, jobConfig);
        setGuaranteeServiceForElasticJobListeners(regCenter, this.elasticJobListeners);
        jobScheduleController = createJobScheduleController();
    }

生成SetUpFacade、SchedulerFacade、LiteJobFacade，这三个Facade都是对regCenter的封装，可以向zookeeper进行增删改查，先不细说。

public SetUpFacade(final CoordinatorRegistryCenter regCenter, final String jobName, final List elasticJobListeners) {
        configService = new ConfigurationService(regCenter, jobName);
        leaderService = new LeaderService(regCenter, jobName);
        serverService = new ServerService(regCenter, jobName);
        instanceService = new InstanceService(regCenter, jobName);
        shardingService = new ShardingService(regCenter, jobName);
        reconcileService = new ReconcileService(regCenter, jobName);
        listenerManager = new ListenerManager(regCenter, jobName, elasticJobListeners);
    }

public SchedulerFacade(final CoordinatorRegistryCenter regCenter, final String jobName) {
        this.jobName = jobName;
        leaderService = new LeaderService(regCenter, jobName);
        shardingService = new ShardingService(regCenter, jobName);
        executionService = new ExecutionService(regCenter, jobName);
        reconcileService = new ReconcileService(regCenter, jobName);
    }

  public LiteJobFacade(final CoordinatorRegistryCenter regCenter, final String jobName, final List elasticJobListeners, final TracingConfiguration tracingConfig) {
        configService = new ConfigurationService(regCenter, jobName);
        shardingService = new ShardingService(regCenter, jobName);
        executionContextService = new ExecutionContextService(regCenter, jobName);
        executionService = new ExecutionService(regCenter, jobName);
        failoverService = new FailoverService(regCenter, jobName);
        this.elasticJobListeners = elasticJobListeners;
        this.jobEventBus = null == tracingConfig ? new JobEventBus() : new JobEventBus(tracingConfig);
    }

生成ElasticJobExecutor，对elasticJob、jobConfig、jobFacade进行赋值，通过JobItemExecutorFactory.getExecutor获取到jobItemExecutor，JobExecutorServiceHandlerFactory.getHandler(jobConfig.getJobExecutorServiceHandlerType()).createExecutorService获取到executorService，JobErrorHandlerFactory.getHandler获取到jobErrorHandler，对itemErrorMessages进行赋值。

   public ElasticJobExecutor(final ElasticJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade) {
        this(elasticJob, jobConfig, jobFacade, JobItemExecutorFactory.getExecutor(elasticJob.getClass()));
    }

    private ElasticJobExecutor(final ElasticJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final JobItemExecutor jobItemExecutor) {
        this.elasticJob = elasticJob;
        this.jobConfig = jobConfig;
        this.jobFacade = jobFacade;
        this.jobItemExecutor = jobItemExecutor;
        executorService = JobExecutorServiceHandlerFactory.getHandler(jobConfig.getJobExecutorServiceHandlerType()).createExecutorService(jobConfig.getJobName());
        jobErrorHandler = JobErrorHandlerFactory.getHandler(jobConfig.getJobErrorHandlerType());
        itemErrorMessages = new ConcurrentHashMap<>(jobConfig.getShardingTotalCount(), 1);
    }

setUpFacade.setUpJobConfiguration会判断是否config路径还没有数据并且需要覆盖配置，如果是就将config写入zookeeper的/jobName/config的路径中，并且写入jobClassName到/jobName的路径中。否则调用load从本地缓存或者zookeeper的config路径读取配置。

    public JobConfiguration setUpJobConfiguration(final String jobClassName, final JobConfiguration jobConfig) {
        return configService.setUpJobConfiguration(jobClassName, jobConfig);
    }

    public JobConfiguration setUpJobConfiguration(final String jobClassName, final JobConfiguration jobConfig) {
        checkConflictJob(jobClassName, jobConfig);
        if (!jobNodeStorage.isJobNodeExisted(ConfigurationNode.ROOT) || jobConfig.isOverwrite()) {
            jobNodeStorage.replaceJobNode(ConfigurationNode.ROOT, YamlEngine.marshal(JobConfigurationPOJO.fromJobConfiguration(jobConfig)));
            jobNodeStorage.replaceJobRootNode(jobClassName);
            return jobConfig;
        }
        return load(false);
    }

    public JobConfiguration load(final boolean fromCache) {
        String result;
        if (fromCache) {
            result = jobNodeStorage.getJobNodeData(ConfigurationNode.ROOT);
            if (null == result) {
                result = jobNodeStorage.getJobNodeDataDirectly(ConfigurationNode.ROOT);
            }
        } else {
            result = jobNodeStorage.getJobNodeDataDirectly(ConfigurationNode.ROOT);
        }
        return YamlEngine.unmarshal(result, JobConfigurationPOJO.class).toJobConfiguration();
    }

setGuaranteeServiceForElasticJobListeners将生成GuaranteeService设置到listener中，不再细说。

    private void setGuaranteeServiceForElasticJobListeners(final CoordinatorRegistryCenter regCenter, final List elasticJobListeners) {
        GuaranteeService guaranteeService = new GuaranteeService(regCenter, jobConfig.getJobName());
        for (ElasticJobListener each : elasticJobListeners) {
            if (each instanceof AbstractDistributeOnceElasticJobListener) {
                ((AbstractDistributeOnceElasticJobListener) each).setGuaranteeService(guaranteeService);
            }
        }
    }

createJobScheduleController是重头戏，首先会创建调用createScheduler、createJobDetail、 getJobConfig().getJobName()获取入参生成JobScheduleController，然后调用 JobRegistry.getInstance().registerJob向本地的map注册JobScheduleController，然后调用registerStartUpInfo注册启动信息。

    private JobScheduleController createJobScheduleController() {
        JobScheduleController result = new JobScheduleController(createScheduler(), createJobDetail(), getJobConfig().getJobName());
        JobRegistry.getInstance().registerJob(getJobConfig().getJobName(), result);
        registerStartUpInfo();
        return result;
    }

先来看JobScheduleController的生成，入参是quartz的Scheduler、JobDetail、triggerIdentity。
Scheduler通过StdSchedulerFactory并且注入一些quartz的配置参数，然后调用其getScheduler获取，最后注册listener到Scheduler，来处理错过调度到的任务。
JobDetail通过注入jobExecutor来生成，使得任务执行时会调用jobExecutor的execute方法。
triggerIdentity即是jobName。

 private Scheduler createScheduler() {
        Scheduler result;
        try {
            StdSchedulerFactory factory = new StdSchedulerFactory();
            factory.initialize(getQuartzProps());
            result = factory.getScheduler();
            result.getListenerManager().addTriggerListener(schedulerFacade.newJobTriggerListener());
        } catch (final SchedulerException ex) {
            throw new JobSystemException(ex);
        }
        return result;
    }
    
    private Properties getQuartzProps() {
        Properties result = new Properties();
        result.put("org.quartz.threadPool.class", SimpleThreadPool.class.getName());
        result.put("org.quartz.threadPool.threadCount", "1");
        result.put("org.quartz.scheduler.instanceName", getJobConfig().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;
    }
    
    private JobDetail createJobDetail() {
        JobDetail result = JobBuilder.newJob(LiteJob.class).withIdentity(getJobConfig().getJobName()).build();
        result.getJobDataMap().put(JOB_EXECUTOR_DATA_MAP_KEY, jobExecutor);
        return result;
    }

接下来是registerStartUpInfo，分别会调用JobRegistry的registerRegistryCenter、addJobInstance、setCurrentShardingTotalCount，最后调用setUpFacade.registerStartUpInfo。

    private void registerStartUpInfo() {
        JobRegistry.getInstance().registerRegistryCenter(jobConfig.getJobName(), regCenter);
        JobRegistry.getInstance().addJobInstance(jobConfig.getJobName(), new JobInstance());
        JobRegistry.getInstance().setCurrentShardingTotalCount(jobConfig.getJobName(), jobConfig.getShardingTotalCount());
        setUpFacade.registerStartUpInfo(!jobConfig.isDisabled());
    }

JobRegistry的registerRegistryCenter、addJobInstance、setCurrentShardingTotalCount三个是将regCenter、jobInstance、currentShardingTotalCount进行缓存，并且初始化对/jobName路径下数据的缓存。

    public void registerRegistryCenter(final String jobName, final CoordinatorRegistryCenter regCenter) {
        regCenterMap.put(jobName, regCenter);
        regCenter.addCacheData("/" + jobName);
    }

    public void addJobInstance(final String jobName, final JobInstance jobInstance) {
        jobInstanceMap.put(jobName, jobInstance);
    }

    public void setCurrentShardingTotalCount(final String jobName, final int currentShardingTotalCount) {
        currentShardingTotalCountMap.put(jobName, currentShardingTotalCount);
    }

setUpFacade.registerStartUpInfo是最终的初始化方法，里面的方法很重要，对每一个都分析一下。

    public void registerStartUpInfo(final boolean enabled) {
        listenerManager.startAllListeners();
        leaderService.electLeader();
        serverService.persistOnline(enabled);
        instanceService.persistOnline();
        shardingService.setReshardingFlag();
        if (!reconcileService.isRunning()) {
            reconcileService.startAsync();
        }
    }

listenerManager.startAllListeners会启动所有对zookeeper路径数据变化的listener。

 public void startAllListeners() {
    electionListenerManager.start();
    shardingListenerManager.start();
    failoverListenerManager.start();
    monitorExecutionListenerManager.start();
    shutdownListenerManager.start();
    triggerListenerManager.start();
    rescheduleListenerManager.start();
    guaranteeListenerManager.start();
    jobNodeStorage.addConnectionStateListener(regCenterConnectionStateListener);
    }

electionListenerManager监听以下事件：
1.当leader节点被删除或者leader节点不存在时，触发leaderService.electLeader选举。
2.如果本身节点被置为不可用并且本身节点是leader，则移除本身节点的leader节点，以此来触发leaderService.electLeader选举。

    class LeaderElectionJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!JobRegistry.getInstance().isShutdown(jobName) && (isActiveElection(path, data) || isPassiveElection(path, eventType))) {
                leaderService.electLeader();
            }
        }
        
        private boolean isActiveElection(final String path, final String data) {
            return !leaderService.hasLeader() && isLocalServerEnabled(path, data);
        }
        
        private boolean isPassiveElection(final String path, final Type eventType) {
            JobInstance jobInstance = JobRegistry.getInstance().getJobInstance(jobName);
            return !Objects.isNull(jobInstance) && isLeaderCrashed(path, eventType) && serverService.isAvailableServer(jobInstance.getIp());
        }
        
        private boolean isLeaderCrashed(final String path, final Type eventType) {
            return leaderNode.isLeaderInstancePath(path) && Type.NODE_DELETED == eventType;
        }
        
        private boolean isLocalServerEnabled(final String path, final String data) {
            return serverNode.isLocalServerPath(path) && !ServerStatus.DISABLED.name().equals(data);
        }
    }

    class LeaderAbdicationJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (leaderService.isLeader() && isLocalServerDisabled(path, data)) {
                leaderService.removeLeader();
            }
        }
        
        private boolean isLocalServerDisabled(final String path, final String data) {
            return serverNode.isLocalServerPath(path) && ServerStatus.DISABLED.name().equals(data);
        }
    }

shardingListenerManager监听以下事件：
1.配置节点中的shardingTotalCount发生改变，调用shardingService.setReshardingFlag，强制任务执行时重新分配分片。
2.server或者instance节点发生改变，调用shardingService.setReshardingFlag，强制任务执行时重新分配分片。

    class ShardingTotalCountChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (configNode.isConfigPath(path) && 0 != JobRegistry.getInstance().getCurrentShardingTotalCount(jobName)) {
                int newShardingTotalCount = YamlEngine.unmarshal(data, JobConfigurationPOJO.class).toJobConfiguration().getShardingTotalCount();
                if (newShardingTotalCount != JobRegistry.getInstance().getCurrentShardingTotalCount(jobName)) {
                    shardingService.setReshardingFlag();
                    JobRegistry.getInstance().setCurrentShardingTotalCount(jobName, newShardingTotalCount);
                }
            }
        }
    }
    
    class ListenServersChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!JobRegistry.getInstance().isShutdown(jobName) && (isInstanceChange(eventType, path) || isServerChange(path))) {
                shardingService.setReshardingFlag();
            }
        }
        
        private boolean isInstanceChange(final Type eventType, final String path) {
            return instanceNode.isInstancePath(path) && Type.NODE_CHANGED != eventType;
        }
        
        private boolean isServerChange(final String path) {
            return serverNode.isServerPath(path);
        }
    }

failoverListenerManager监听以下事件：
1.instance节点发生下线，将其拥有的失效转移任务再次触发失效转移到其他节点执行。
2.配置节点中的isFailover发生改变，若不需要失效转移，则直接清除现有的失效转移任务。

class JobCrashedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!JobRegistry.getInstance().isShutdown(jobName) && isFailoverEnabled() && Type.NODE_DELETED == eventType && instanceNode.isInstancePath(path)) {
                String jobInstanceId = path.substring(instanceNode.getInstanceFullPath().length() + 1);
                if (jobInstanceId.equals(JobRegistry.getInstance().getJobInstance(jobName).getJobInstanceId())) {
                    return;
                }
                List failoverItems = failoverService.getFailoverItems(jobInstanceId);
                if (!failoverItems.isEmpty()) {
                    for (int each : failoverItems) {
                        failoverService.setCrashedFailoverFlag(each);
                        failoverService.failoverIfNecessary();
                    }
                } else {
                    for (int each : shardingService.getShardingItems(jobInstanceId)) {
                        failoverService.setCrashedFailoverFlag(each);
                        failoverService.failoverIfNecessary();
                    }
                }
            }
        }
    }
    
    class FailoverSettingsChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (configNode.isConfigPath(path) && Type.NODE_CHANGED == eventType && !YamlEngine.unmarshal(data, JobConfigurationPOJO.class).toJobConfiguration().isFailover()) {
                failoverService.removeFailoverInfo();
            }
        }
    }

monitorExecutionListenerManager监听以下事件：
1.配置节点中的isMonitorExecution发生改变，若不需要提醒执行信息，则直接清除现有的显示执行的节点。

    class MonitorExecutionSettingsChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (configNode.isConfigPath(path) && Type.NODE_CHANGED == eventType && !YamlEngine.unmarshal(data, JobConfigurationPOJO.class).toJobConfiguration().isMonitorExecution()) {
                executionService.clearAllRunningInfo();
            }
        }
    }

shutdownListenerManager监听以下事件：
1.本身的instance节点被删除，需要调用schedulerFacade.shutdownInstance关闭掉本身节点的定时任务。

    class InstanceShutdownStatusJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!JobRegistry.getInstance().isShutdown(jobName) && !JobRegistry.getInstance().getJobScheduleController(jobName).isPaused()
                    && isRemoveInstance(path, eventType) && !isReconnectedRegistryCenter()) {
                schedulerFacade.shutdownInstance();
            }
        }
        
        private boolean isRemoveInstance(final String path, final Type eventType) {
            return instanceNode.isLocalInstancePath(path) && Type.NODE_DELETED == eventType;
        }
        
        private boolean isReconnectedRegistryCenter() {
            return instanceService.isLocalJobInstanceExisted();
        }
    }

triggerListenerManager监听以下事件：
1.出现指定本身节点的trigger节点，将清除trigger节点，然后调用triggerJob立刻执行一次任务。

    class JobTriggerStatusJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (!InstanceOperation.TRIGGER.name().equals(data) || !instanceNode.isLocalInstancePath(path) || Type.NODE_CHANGED != eventType) {
                return;
            }
            instanceService.clearTriggerFlag();
            if (!JobRegistry.getInstance().isShutdown(jobName) && !JobRegistry.getInstance().isJobRunning(jobName)) {
                // TODO At present, it cannot be triggered when the job is running, and it will be changed to a stacked trigger in the future.
                JobRegistry.getInstance().getJobScheduleController(jobName).triggerJob();
            }
        }
    }

rescheduleListenerManager监听以下事件：
1.配置节点中的cron发生改变，则调用rescheduleJob重新调度定时任务。

class CronSettingAndJobEventChangedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (configNode.isConfigPath(path) && Type.NODE_CHANGED == eventType && !JobRegistry.getInstance().isShutdown(jobName)) {
                JobRegistry.getInstance().getJobScheduleController(jobName).rescheduleJob(YamlEngine.unmarshal(data, JobConfigurationPOJO.class).toJobConfiguration().getCron());
            }
        }
    }

guaranteeListenerManager监听以下事件：
1.start节点发生改变，将调用listener的notifyWaitingTaskStart通知任务启动。
2.complete发生改变，将调用listener的notifyWaitingTaskComplete通知任务完成。

   class StartedNodeRemovedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (Type.NODE_DELETED == eventType && guaranteeNode.isStartedRootNode(path)) {
                for (ElasticJobListener each : elasticJobListeners) {
                    if (each instanceof AbstractDistributeOnceElasticJobListener) {
                        ((AbstractDistributeOnceElasticJobListener) each).notifyWaitingTaskStart();
                    }
                }
            }
        }
    }
    
    class CompletedNodeRemovedJobListener extends AbstractJobListener {
        
        @Override
        protected void dataChanged(final String path, final Type eventType, final String data) {
            if (Type.NODE_DELETED == eventType && guaranteeNode.isCompletedRootNode(path)) {
                for (ElasticJobListener each : elasticJobListeners) {
                    if (each instanceof AbstractDistributeOnceElasticJobListener) {
                        ((AbstractDistributeOnceElasticJobListener) each).notifyWaitingTaskComplete();
                    }
                }
            }
        }
    }

regCenterConnectionStateListener监听的是对zookeeper的连接状态，若连接出现挂起或者丢失状态，则暂停任务，如果重新连接上，则重新写入server、instance本身节点到zookeeper，清除本身节点的运行节点，然后重新调度定时任务。

  @Override
    public void stateChanged(final CuratorFramework client, final ConnectionState newState) {
        if (JobRegistry.getInstance().isShutdown(jobName)) {
            return;
        }
        JobScheduleController jobScheduleController = JobRegistry.getInstance().getJobScheduleController(jobName);
        if (ConnectionState.SUSPENDED == newState || ConnectionState.LOST == newState) {
            jobScheduleController.pauseJob();
        } else if (ConnectionState.RECONNECTED == newState) {
            serverService.persistOnline(serverService.isEnableServer(JobRegistry.getInstance().getJobInstance(jobName).getIp()));
            instanceService.persistOnline();
            executionService.clearRunningInfo(shardingService.getLocalShardingItems());
            jobScheduleController.resumeJob();
        }
    }

完成所有listener的初始化后，将调用leaderService.electLeader开始选举，将使用zookeeper分布式锁的机制，所有节点都往同一路径下创建顺序节点，只有获取到最小序号的节点会执行LeaderElectionExecutionCallback的execute方法，将本身节点的信息写入leader节点，宣布选举成功。因此后续其他节点再进入LeaderElectionExecutionCallback的execute方法时，发现leader节点拥有数据，自己只能成为follower结束选举流程。

  public void executeInLeader(final String latchNode, final LeaderExecutionCallback callback) {
        try (LeaderLatch latch = new LeaderLatch(getClient(), jobNodePath.getFullPath(latchNode))) {
            latch.start();
            latch.await();
            callback.execute();
        //CHECKSTYLE:OFF
        } catch (final Exception ex) {
        //CHECKSTYLE:ON
            handleException(ex);
        }
    }

    public void electLeader() {
        log.debug("Elect a new leader now.");
        jobNodeStorage.executeInLeader(LeaderNode.LATCH, new LeaderElectionExecutionCallback());
        log.debug("Leader election completed.");
    }

   @RequiredArgsConstructor
    class LeaderElectionExecutionCallback implements LeaderExecutionCallback {
        
        @Override
        public void execute() {
            if (!hasLeader()) {
                jobNodeStorage.fillEphemeralJobNode(LeaderNode.INSTANCE, JobRegistry.getInstance().getJobInstance(jobName).getJobInstanceId());
            }
        }
    }

由上文讲到，listener基本上都是围绕server、instance节点来进行处理，接下来serverService.persistOnline和instanceService.persistOnline就是创建本身节点的server、instance节点。

    public void persistOnline(final boolean enabled) {
        if (!JobRegistry.getInstance().isShutdown(jobName)) {
            jobNodeStorage.fillJobNode(serverNode.getServerNode(JobRegistry.getInstance().getJobInstance(jobName).getIp()), enabled ? ServerStatus.ENABLED.name() : ServerStatus.DISABLED.name());
        }
    }

  public void persistOnline() {
        jobNodeStorage.fillEphemeralJobNode(instanceNode.getLocalInstanceNode(), "");
    }

因为是初始化，还是需要调用shardingService.setReshardingFlag，强制定时任务执行前进行分片。

   public void setReshardingFlag() {
        jobNodeStorage.createJobNodeIfNeeded(ShardingNode.NECESSARY);
    }

最后是reconcileService.startAsync，会定时检测leader状态触发重新选举和触发重新分片，避免完全依赖listener处理核心逻辑，使得系统拥有一个自检测修复的功能。

    @Override
    protected void runOneIteration() {
        int reconcileIntervalMinutes = configService.load(true).getReconcileIntervalMinutes();
        if (reconcileIntervalMinutes > 0 && (System.currentTimeMillis() - lastReconcileTime >= reconcileIntervalMinutes * 60 * 1000)) {
            lastReconcileTime = System.currentTimeMillis();
            if (leaderService.isLeaderUntilBlock() && !shardingService.isNeedSharding() && shardingService.hasShardingInfoInOfflineServers()) {
                log.warn("Elastic Job: job status node has inconsistent value,start reconciling...");
                shardingService.setReshardingFlag();
            }
        }
    }
    
    @Override
    protected Scheduler scheduler() {
        return Scheduler.newFixedDelaySchedule(0, 1, TimeUnit.MINUTES);
    }

job的执行

来到job的执行流程解析，在定时任务执行时，会调用到ElasticJobExecutor的execute方法，下面会一步步分析。

    public void execute() {
        try {
            jobFacade.checkJobExecutionEnvironment();
        } catch (final JobExecutionEnvironmentException cause) {
            jobErrorHandler.handleException(jobConfig.getJobName(), cause);
        }
        ShardingContexts shardingContexts = jobFacade.getShardingContexts();
        jobFacade.postJobStatusTraceEvent(shardingContexts.getTaskId(), State.TASK_STAGING, String.format("Job '%s' execute begin.", jobConfig.getJobName()));
        if (jobFacade.misfireIfRunning(shardingContexts.getShardingItemParameters().keySet())) {
            jobFacade.postJobStatusTraceEvent(shardingContexts.getTaskId(), State.TASK_FINISHED, String.format(
                    "Previous job '%s' - shardingItems '%s' is still running, misfired job will start after previous job completed.", jobConfig.getJobName(),
                    shardingContexts.getShardingItemParameters().keySet()));
            return;
        }
        try {
            jobFacade.beforeJobExecuted(shardingContexts);
            //CHECKSTYLE:OFF
        } catch (final Throwable cause) {
            //CHECKSTYLE:ON
            jobErrorHandler.handleException(jobConfig.getJobName(), cause);
        }
        execute(shardingContexts, ExecutionSource.NORMAL_TRIGGER);
        while (jobFacade.isExecuteMisfired(shardingContexts.getShardingItemParameters().keySet())) {
            jobFacade.clearMisfire(shardingContexts.getShardingItemParameters().keySet());
            execute(shardingContexts, ExecutionSource.MISFIRE);
        }
        jobFacade.failoverIfNecessary();
        try {
            jobFacade.afterJobExecuted(shardingContexts);
            //CHECKSTYLE:OFF
        } catch (final Throwable cause) {
            //CHECKSTYLE:ON
            jobErrorHandler.handleException(jobConfig.getJobName(), cause);
        }
    }

jobFacade.checkJobExecutionEnvironment最终会调用到ConfigurationService的checkMaxTimeDiffSecondsTolerable方法，原理是通过在zookeeper写入一个节点，然后获取其写入时间，然后与本地时间对比获取时间差，若时间差大于最大容忍的时间差则抛出错误，不执行任务。

   public void checkMaxTimeDiffSecondsTolerable() throws JobExecutionEnvironmentException {
        int maxTimeDiffSeconds = load(true).getMaxTimeDiffSeconds();
        if (-1 == maxTimeDiffSeconds) {
            return;
        }
        long timeDiff = Math.abs(timeService.getCurrentMillis() - jobNodeStorage.getRegistryCenterTime());
        if (timeDiff > maxTimeDiffSeconds * 1000L) {
            throw new JobExecutionEnvironmentException(
                    "Time different between job server and register center exceed '%s' seconds, max time different is '%s' seconds.", timeDiff / 1000, maxTimeDiffSeconds);
        }
    }

jobFacade.getShardingContexts是获取ShardingContexts的方法，主要是获取到具体的分片items，然后将jobConfig和分片items结合生成ShardingContexts返回。如果是支持failover则返回failover的分片，否则需要调用shardingService.shardingIfNecessary检测是否需要重新分片，然后再获取到分到本节点的分片返回。

@Override
    public ShardingContexts getShardingContexts() {
        boolean isFailover = configService.load(true).isFailover();
        if (isFailover) {
            List failoverShardingItems = failoverService.getLocalFailoverItems();
            if (!failoverShardingItems.isEmpty()) {
                return executionContextService.getJobShardingContext(failoverShardingItems);
            }
        }
        shardingService.shardingIfNecessary();
        List shardingItems = shardingService.getLocalShardingItems();
        if (isFailover) {
            shardingItems.removeAll(failoverService.getLocalTakeOffItems());
        }
        shardingItems.removeAll(executionService.getDisabledItems(shardingItems));
        return executionContextService.getJobShardingContext(shardingItems);
    }

    public ShardingContexts getJobShardingContext(final List shardingItems) {
        JobConfiguration jobConfig = configService.load(false);
        removeRunningIfMonitorExecution(jobConfig.isMonitorExecution(), shardingItems);
        if (shardingItems.isEmpty()) {
            return new ShardingContexts(buildTaskId(jobConfig, shardingItems), jobConfig.getJobName(), jobConfig.getShardingTotalCount(), 
                    jobConfig.getJobParameter(), Collections.emptyMap());
        }
        Map shardingItemParameterMap = new ShardingItemParameters(jobConfig.getShardingItemParameters()).getMap();
        return new ShardingContexts(buildTaskId(jobConfig, shardingItems), jobConfig.getJobName(), jobConfig.getShardingTotalCount(), 
                jobConfig.getJobParameter(), getAssignedShardingItemParameterMap(shardingItems, shardingItemParameterMap));
    }

shardingService.shardingIfNecessary是重新分片的方法，上文已经说到，如果需要分片，则会在zookeeper加上shard目录加上necessary节点。如果检测到需要重新分片，follower会等待重新分片完成，leader则执行重新分片逻辑，需要先等到正在执行的分片item完成，然后标记重新分片为进行中，调用resetShardingInfo将shard节点调整为正确数量（扩缩容），然后调用jobShardingStrategy的sharding方法，获取到分片结果，最终调用jobNodeStorage.executeInTransaction将分片结果写入到zookeeper。

    public void shardingIfNecessary() {
        List availableJobInstances = instanceService.getAvailableJobInstances();
        if (!isNeedSharding() || availableJobInstances.isEmpty()) {
            return;
        }
        if (!leaderService.isLeaderUntilBlock()) {
            blockUntilShardingCompleted();
            return;
        }
        waitingOtherShardingItemCompleted();
        JobConfiguration jobConfig = configService.load(false);
        int shardingTotalCount = jobConfig.getShardingTotalCount();
        log.debug("Job '{}' sharding begin.", jobName);
        jobNodeStorage.fillEphemeralJobNode(ShardingNode.PROCESSING, "");
        resetShardingInfo(shardingTotalCount);
        JobShardingStrategy jobShardingStrategy = JobShardingStrategyFactory.getStrategy(jobConfig.getJobShardingStrategyType());
        jobNodeStorage.executeInTransaction(new PersistShardingInfoTransactionExecutionCallback(jobShardingStrategy.sharding(availableJobInstances, jobName, shardingTotalCount)));
        log.debug("Job '{}' sharding complete.", jobName);
    }

继续回到主流程，拿到ShardingContexts后就调用execute方法执行，忽略一些前后钩子方法的执行，其实就是根据分片号执行任务，如果是只有1个分片，则直接在原线程执行。否则将丢进线程池，然后使用CountDownLatch等待所有任务执行完成返回。

    private void execute(final ShardingContexts shardingContexts, final ExecutionSource executionSource) {
        if (shardingContexts.getShardingItemParameters().isEmpty()) {
            jobFacade.postJobStatusTraceEvent(shardingContexts.getTaskId(), State.TASK_FINISHED, String.format("Sharding item for job '%s' is empty.", jobConfig.getJobName()));
            return;
        }
        jobFacade.registerJobBegin(shardingContexts);
        String taskId = shardingContexts.getTaskId();
        jobFacade.postJobStatusTraceEvent(taskId, State.TASK_RUNNING, "");
        try {
            process(shardingContexts, executionSource);
        } finally {
            // TODO Consider increasing the status of job failure, and how to handle the overall loop of job failure
            jobFacade.registerJobCompleted(shardingContexts);
            if (itemErrorMessages.isEmpty()) {
                jobFacade.postJobStatusTraceEvent(taskId, State.TASK_FINISHED, "");
            } else {
                jobFacade.postJobStatusTraceEvent(taskId, State.TASK_ERROR, itemErrorMessages.toString());
            }
        }
    }

private void process(final ShardingContexts shardingContexts, final ExecutionSource executionSource) {
        Collection items = shardingContexts.getShardingItemParameters().keySet();
        if (1 == items.size()) {
            int item = shardingContexts.getShardingItemParameters().keySet().iterator().next();
            JobExecutionEvent jobExecutionEvent = new JobExecutionEvent(IpUtils.getHostName(), IpUtils.getIp(), shardingContexts.getTaskId(), jobConfig.getJobName(), executionSource, item);
            process(shardingContexts, item, jobExecutionEvent);
            return;
        }
        CountDownLatch latch = new CountDownLatch(items.size());
        for (int each : items) {
            JobExecutionEvent jobExecutionEvent = new JobExecutionEvent(IpUtils.getHostName(), IpUtils.getIp(), shardingContexts.getTaskId(), jobConfig.getJobName(), executionSource, each);
            if (executorService.isShutdown()) {
                return;
            }
            executorService.submit(() -> {
                try {
                    process(shardingContexts, each, jobExecutionEvent);
                } finally {
                    latch.countDown();
                }
            });
        }
        try {
            latch.await();
        } catch (final InterruptedException ex) {
            Thread.currentThread().interrupt();
        }
    }

   private void process(final ShardingContexts shardingContexts, final int item, final JobExecutionEvent startEvent) {
        jobFacade.postJobExecutionEvent(startEvent);
        log.trace("Job '{}' executing, item is: '{}'.", jobConfig.getJobName(), item);
        JobExecutionEvent completeEvent;
        try {
            jobItemExecutor.process(elasticJob, jobConfig, jobFacade, shardingContexts.createShardingContext(item));
            completeEvent = startEvent.executionSuccess();
            log.trace("Job '{}' executed, item is: '{}'.", jobConfig.getJobName(), item);
            jobFacade.postJobExecutionEvent(completeEvent);
            // CHECKSTYLE:OFF
        } catch (final Throwable cause) {
            // CHECKSTYLE:ON
            completeEvent = startEvent.executionFailure(ExceptionUtils.transform(cause));
            jobFacade.postJobExecutionEvent(completeEvent);
            itemErrorMessages.put(item, ExceptionUtils.transform(cause));
            jobErrorHandler.handleException(jobConfig.getJobName(), cause);
        }
    }

下面来分析一下elasticjob三种job形态。
SimpleJobExecutor直接调用用户定义的elasticJob的execute执行即可。

    @Override
    public void process(final SimpleJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final ShardingContext shardingContext) {
        elasticJob.execute(shardingContext);
    }

ScriptJobExecutor将分片参数转化成命令行，调用底层的命令行执行方法即可。

    @Override
    public void process(final ElasticJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final ShardingContext shardingContext) {
        CommandLine commandLine = CommandLine.parse(getScriptCommandLine(jobConfig.getProps()));
        commandLine.addArgument(GsonFactory.getGson().toJson(shardingContext), false);
        try {
            new DefaultExecutor().execute(commandLine);
        } catch (final IOException ex) {
            throw new JobSystemException("Execute script failure.", ex);
        }
    }
    
    private String getScriptCommandLine(final Properties props) {
        String result = props.getProperty(ScriptJobProperties.SCRIPT_KEY);
        if (Strings.isNullOrEmpty(result)) {
            throw new JobConfigurationException("Cannot find script command line, job is not executed.");
        }
        return result;
    }

DataflowJobExecutor会根据配置选择对应的流式处理模式，如果是oneOffExecute，则调用一次fetchData拉取数据，再调用一次processData处理数据就结束。如果是streamingExecute，则会不断进行拉取处理的循环，直到拉取的数据为空。

 @Override
    public void process(final DataflowJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final ShardingContext shardingContext) {
        if (Boolean.parseBoolean(jobConfig.getProps().getOrDefault(DataflowJobProperties.STREAM_PROCESS_KEY, false).toString())) {
            streamingExecute(elasticJob, jobConfig, jobFacade, shardingContext);
        } else {
            oneOffExecute(elasticJob, shardingContext);
        }
    }
    
    private void streamingExecute(final DataflowJob elasticJob, final JobConfiguration jobConfig, final JobFacade jobFacade, final ShardingContext shardingContext) {
        List data = fetchData(elasticJob, shardingContext);
        while (null != data && !data.isEmpty()) {
            processData(elasticJob, shardingContext, data);
            if (!isEligibleForJobRunning(jobConfig, jobFacade)) {
                break;
            }
            data = fetchData(elasticJob, shardingContext);
        }
    }
    
    private boolean isEligibleForJobRunning(final JobConfiguration jobConfig, final JobFacade jobFacade) {
        return !jobFacade.isNeedSharding() && Boolean.parseBoolean(jobConfig.getProps().getOrDefault(DataflowJobProperties.STREAM_PROCESS_KEY, false).toString());
    }
    
    private void oneOffExecute(final DataflowJob elasticJob, final ShardingContext shardingContext) {
        List data = fetchData(elasticJob, shardingContext);
        if (null != data && !data.isEmpty()) {
            processData(elasticJob, shardingContext, data);
        }
    }
    
    @SuppressWarnings("unchecked")
    private List fetchData(final DataflowJob elasticJob, final ShardingContext shardingContext) {
        return elasticJob.fetchData(shardingContext);
    }
    
    @SuppressWarnings("unchecked")
    private void processData(final DataflowJob elasticJob, final ShardingContext shardingContext, final List data) {
        elasticJob.processData(shardingContext, data);
    }
    
 
 
继续主流程的错过调度的分片item处理，上文分析到本地的quartz是注册了错过调度listener，如果检测到错过调度，则向zookeeper注册错过调度节点。此时则是取出错过调度节点，然后执行。
 
 
       execute(shardingContexts, ExecutionSource.NORMAL_TRIGGER);
        while (jobFacade.isExecuteMisfired(shardingContexts.getShardingItemParameters().keySet())) {
            jobFacade.clearMisfire(shardingContexts.getShardingItemParameters().keySet());
            execute(shardingContexts, ExecutionSource.MISFIRE);
        }

 
 
最后是jobFacade.failoverIfNecessary，也就是再一次取出failover的节点进行执行。
 
 
  @Override
    public void failoverIfNecessary() {
        if (configService.load(true).isFailover()) {
            failoverService.failoverIfNecessary();
        }
    }

   public void failoverIfNecessary() {
        if (needFailover()) {
            jobNodeStorage.executeInLeader(FailoverNode.LATCH, new FailoverLeaderExecutionCallback());
        }
    }

    private boolean needFailover() {
        return jobNodeStorage.isJobNodeExisted(FailoverNode.ITEMS_ROOT) && !jobNodeStorage.getJobNodeChildrenKeys(FailoverNode.ITEMS_ROOT).isEmpty()
                && !JobRegistry.getInstance().isJobRunning(jobName);
    }

       @Override
        public void execute() {
            if (JobRegistry.getInstance().isShutdown(jobName) || !needFailover()) {
                return;
            }
            int crashedItem = Integer.parseInt(jobNodeStorage.getJobNodeChildrenKeys(FailoverNode.ITEMS_ROOT).get(0));
            log.debug("Failover job '{}' begin, crashed item '{}'", jobName, crashedItem);
            jobNodeStorage.fillEphemeralJobNode(FailoverNode.getExecutionFailoverNode(crashedItem), JobRegistry.getInstance().getJobInstance(jobName).getJobInstanceId());
            jobNodeStorage.removeJobNodeIfExisted(FailoverNode.getItemsNode(crashedItem));
            // TODO Instead of using triggerJob, use executor for unified scheduling
            JobScheduleController jobScheduleController = JobRegistry.getInstance().getJobScheduleController(jobName);
            if (null != jobScheduleController) {
                jobScheduleController.triggerJob();
            }
        }

 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(elasticjob-lite源码解析)

        

            

                
    
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Istio pilot-discovery服务发现源码解析（1.13版本）
                        xidianjiapei001
#Istioistio云原生服务发现
                        
    Istiopilot-discovery服务发现介绍工作机制初始化初始化Config控制器初始化Service控制器controller初始化NamespaceServiceNodePodPilotDiscovery各组件启动流程DiscoveryServer接收Envoy的gRPC连接请求流程Config变化后向Envoy推送更新的流程总结参考介绍IstioPilot的代码分为Pilot-Dis
    
                    
    • 
                    
  • Java集合类框架源码分析 之 RoleList源码解析 【6】
                        yunzhonghefei
Java集合类源码分析RoleList源码解析
                        
    该类继承于ArrayList，针对Role进行了一些扩展。其他方法和ArrayList中基本相同，源码不做针对性分析：看一下类简介：/***代表了一个roles的列表，作为方法setRoles()的参数，去创建一个关联关系，并且尝试在同一个关系中设置多个角色。*ARoleListrepresentsalistofroles(Roleobjects).Itisusedas*parameterwhen
    
                    
    • 
                    
  • VITS 源码解析2-模型概述
                        迪三
#NN_Audio音频人工智能
                        
    VITs是文本到语音(Text-to-Speech,TTS)任务中最流行的技术之一，其实现思路是将文本语音信息融合到了HiFiGAN潜空间内,通过文本控制HiFiGAN的生成器，输出含文本语义的声音。VITs主要以GAN的方式训练,其生成器G是SynthesizerTrn，判别器D是MPD。VITS的判别器几乎和HiFiGAN一样，生成器则融合了文本、时序、声音三大类模型1.文件概述模型部分包含三
    
                    
    • 
                    
  • RBtree
                        努力的小带土
侯捷老师STLc++蓝桥杯
                        
    终结B站没人能讲清楚红黑树的历史，不服等你来踢馆！-【码炫课堂收费课节选之-红黑树源码解析及手写红黑树】_哔哩哔哩_bilibiliB站的听课记录，并写下如下红黑树c++版本代码，该课程真的史诗级推荐！/*RBtreeNode.h*****/#pragmaonceenum{RED=false,BLACK=true};templateclassRBtreeNode{public://红黑树的左右节点
    
                    
    • 
                    
  • 深入理解Kubernetes：kube-scheduler源码解析
                        mujingluo
kubernetes容器云原生
                        
    Kubernetes的调度器（kube-scheduler）是整个系统中至关重要的组件，它负责将待调度的Pods分配到合适的节点上。本文将深入分析kube-scheduler的源码，揭示其内部工作机制。kube-scheduler的核心功能kube-scheduler的核心功能包括：监听Pod变化：通过KubernetesAPI监听所有未调度的Pods。过滤（Filtering）：根据一系列规则（
    
                    
    • 
                    
  • 【Vesta发号器源码】PropertyMachineIdsProvider
                        DeanChangDM

                        
    Vesta发号器源码解析——PropertyMachineIdsProvider属性配置文件持有Id的模式,没啥东西，比单个的多了一个获取下一个的方法封装实现上略有一点点区别privatelong[]machineIds;privateintcurrentIndex;publiclonggetNextMachineId(){returngetMachineId();}publiclonggetMa
    
                    
    • 
                    
  • StarRocks分布式元数据源码解析
                        不甚了然
Iceberg知识集StarRocksIceberg数据湖湖仓一体大数据
                        
    1.支持元数据表https://github.com/StarRocks/starrocks/pull/44276/files核心类：LogicalIcebergMetadataTable，Iceberg元数据表，将元数据的各个字段做成表的列，后期可以通过sql操作从元数据获取字段，这个表的组成字段是DataFile相关的字段public static LogicalIcebergMetadata
    
                    
    • 
                    
  • 【Starrocks】建表篇Fe源码解析
                        数算七弦
Starrocks大数据
                        
    Starrocks系统架构简述现在市面上主流的OLAP存算一体架构主要有两类进程：Frontend（FE）和Backend（BE）Frontend一般是用Java写的。主要职责有：接收用户连接请求（MySQL协议层）元数据存储与管理查询语句的解析与查询计划的生成集群管控Backend一般是用C++写的，主要职责有：数据存储与管理查询计划的执行建表语句的执行过程与Mysql协议层交互词法解析语法解析
    
                    
    • 
                    
  • 智能农业设备软件工程师如何集成和管理农业物联网（IoT）平台
                        openwin_top
智能农业设备软件工程师物联网python开发语言深度学习大数据智能农业
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业物联网（IoT）平台涉及多个步骤，包括设备连接、数据收集、数据传输、数据存储、数据分析和展示。以下是详细分析和示例代码展示。1.设备连接和数据收集首先，智能农业设备需要能够与传感器和执
    
                    
    • 
                    
  • 智能农业设备软件工程师如何集成和管理农业设备的远程更新系统
                        openwin_top
智能农业设备软件工程师深度学习大数据物联网人工智能网络智能农业
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位集成和管理农业设备的远程更新系统涉及多个技术层面，包括设备固件的安全更新、版本控制、网络通信，以及设备管理平台的开发。下面我们详细分析这些步骤，并提供一个基本的示例代码来展示如何实现这个系统。1.系
    
                    
    • 
                    
  • 智能农业设备软件工程师如何处理设备的远程诊断和修复
                        openwin_top
智能农业设备软件工程师网络智能农业物联网人工智能大数据深度学习
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位处理智能农业设备的远程诊断和修复涉及几个关键步骤，包括设备的数据采集、数据传输、远程诊断、远程控制和修复。以下是详细分析和示例代码：1.数据采集智能农业设备通常配备传感器和控制器，这些设备不断采集环
    
                    
    • 
                    
  • android10 按键音量调节源码解析
                        @OuYang
android
                        
    /frameworks/base/services/core/java/com/android/server/policy/PhoneWindowManager.javastaticIAudioServicegetAudioService(){IAudioServiceaudioService=IAudioService.Stub.asInterface(ServiceManager.checkS
    
                    
    • 
                    
  • android10 Settings源码解析
                        @OuYang
android
                        
    /packages/apps/Settings/AndroidManifest.xml.................................................................................activity-alias是Android里为了重复使用Activity而设计的。对于activity-alias标签，它有一个属性叫android:
    
                    
    • 
                    
  • MyBatis 源码解析：XMLScriptBuilder 工作机制
                        捕风捉你
MyBatis源码解读mybatisjava
                        
    摘要MyBatis提供了强大的动态SQL功能，它通过解析XML配置文件中的动态SQL标签（如、、等），来实现灵活的SQL生成。而XMLScriptBuilder类则负责解析这些XML配置并生成最终的SQL语句。本文将详细解析XMLScriptBuilder的工作机制，并通过自定义实现来帮助您深入理解该类的功能。前言MyBatis中的动态SQL功能是通过解析XML配置文件实现的。XML文件中包含了动
    
                    
    • 
                    
  • c#视觉应用开发中如何使用Emgu CV在C#中进行图像处理？
                        openwin_top
C#视觉应用开发问题系列c#图像处理开发语言
                        
    microPythonPython最小内核源码解析NI-motion运动控制c语言示例代码解析python编程示例系列python编程示例系列二python的Web神器Streamlit如何应聘高薪职位EmguCV是OpenCV的.NET包装器，可以让开发者在.NET语言（如C#）中使用OpenCV的功能进行图像处理。在进行图像处理时，EmguCV提供了丰富的API可以使用。以下是使用EmguCV
    
                    
    • 
                    
  • Elasticsearch——配置详解
                        smart哥
elasticsearch专题elasticsearch搜索引擎
                        
    作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬学习必须往深处挖，挖的越深，基础越扎实！阶段1、深入多线程阶段2、深入多线程设计模式阶段3、深入juc源码解析阶段4、深入jdk其余源码解析阶段5、深入jvm源码解析码哥源码部分码哥讲源码-原理源码篇【2024年最新大厂关于线程池使用的场
    
                    
    • 
                    
  • Eventbus3.0源码解析
                        超威蓝猫l

                        
    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
    
                    
    • 
                    
  • 前端宝典之三：React源码解析之Fiber架构
                        桃子叔叔
大厂进阶前端深度解析系列react.js架构javascript
                        
    本文主要内容：1、ReactConcurrent2、React15架构3、React16架构4、Fiber架构5、任务调度循环和fiber构造循环区别一、ReactConcurrentReact在解决CPU卡顿是会用到ReactConcurrent的概念，它是React中的一个重要特性和模块，主要的特点和原理如下一、主要特点和优势1、时间切片（TimeSlicing）允许将长时间运行的任务分割成小
    
                    
    • 
                    
  • Java集合之HashSet源码解析
                        气宇轩昂固执狂
JAVA面试笔试通关指南java开发语言HashSetHashSet源码
                        
    一、HashSet概述：1、HashSet底层实现实际上就是利用HashMap的键（Key）来存储对象，原HashMap的键key的位置存放对象，值value的位置存放空的Object对象作为虚拟值；2、增加和删除都是直接调用HashMap的方法来实现的，没有修改和具体的查询方法，获取值只能通过iterator方法来迭代，迭代方法也是建立在HashMap的键的迭代方法上的。相关HashSet的操作
    
                    
    • 
                    
  • Spring之AOP底层源码解析（上）
                        阿立聊代码
spring代理模式
                        
    动态代理代理模式的解释：为其他对象提供一种代理以控制对这个对象的访问，增强一个类中的某个方法，对程序进行扩展。比如，现在存在一个UserService类：public class UserService  { public void test() {  System.out.println("test..."); }}此时，我们new一个UserService对象，然后执行test()方法，结果是
    
                    
    • 
                    
  • Spring Boot自动配置源码解析
                        一休哥助手
springbootjava数据库
                        
    一、自动配置概述1.1什么是自动配置SpringBoot的自动配置是一种能够根据类路径中的依赖、配置文件中的属性以及其他条件，自动配置Spring应用上下文的功能。它通过扫描项目中的类和配置文件，判断哪些组件需要自动装配，从而减少了手动编写配置代码的繁琐过程。1.2自动配置的优点减少配置工作量：自动配置能够帮助开发者快速启动一个Spring应用，而不必担心各种复杂的XML或Java配置。智能化配置
    
                    
    • 
                    
  • Spring扩展点系列-InstantiationAwareBeanPostProcessor
                        码至终章
Spring生命周期扩展接口springsqljava扩展接口mavenspringboot
                        
    文章目录简介测试一1、配置文件Bean注册2、单元测试方法3、测试类4、输出结果结论测试二1、测试类2、输出结果结论源码解析postProcessPropertiesCommonAnnotationBeanPostProcessorAnnotationInjectedBeanPostProcessor总结简介spring容器中Bean的生命周期内所有可扩展的点的调用顺序扩展接口实现接口Applic
    
                    
    • 
                    
  • MyBatis 源码解析：DefaultSqlSessionFactory 的创建与管理
                        捕风捉你
MyBatis源码解读mybatis
                        
    摘要在MyBatis中，SqlSessionFactory是执行数据库操作的核心对象，它负责创建和管理SqlSession的生命周期。你是否想了解SqlSessionFactory的创建和管理过程？本文将通过自定义实现一个简化版的DefaultSqlSessionFactory，带你深入探讨MyBatis中DefaultSqlSessionFactory的创建与管理机制，并帮助你更好地掌握SqlS
    
                    
    • 
                    
  • FFmpeg源码解析系列（一）目录和编译
                        头快撑不住了
FFmpeg源码解析ffmpeg音视频视频编解码实时音视频图像处理
                        
    引言当我们欣赏一部电影、观看一段视频或者享受一首音乐时，很少有人会停下来思考这一切是如何呈现在我们眼前的。然而，在每一帧的画面、每一秒的声音背后，有着一个不可思议的技术世界这个充满音视频的世界的核心之一，就是FFmpeg。FFmpeg是一个强大而复杂的多媒体处理工具，它为视频和音频编解码、流媒体传输、格式转换等提供了优秀的解决方案。在这个系列博客中，我们将深入探讨FFmpeg源码，解析它的工作原理
    
                    
    • 
                    
  • Spark MLlib LinearRegression线性回归算法源码解析
                        SmileySure
Spark人工智能算法SparkMLlib
                        
    线性回归一元线性回归hθ(x)=θ0+θ1xhθ(x)=θ0+θ1x——————–1多元线性回归hθ(x)=∑mi=1θixi=θTXhθ(x)=∑i=1mθixi=θTX—————–2损失函数J(θ)=1/2∑mi=1(hθ(xi)−yi)2J(θ)=1/2∑i=1m(hθ(xi)−yi)2—————31/2是为了求导时系数为1，平方里是真实值减去估计值我们的目的就是求其最小值最小二乘法要求较为
    
                    
    • 
                    
  • HashMap源码解析
                        dlwlrma ⥳
兴趣类哈希算法散列表算法
                        
    目录一:put方法流程二：get方法三：扩容机制一：put方法流程publicVput(Kkey,Vvalue){returnputVal(hash(key),key,value,false,true);}finalVputVal(inthash,Kkey,Vvalue,booleanonlyIfAbsent,booleanevict){Node[]tab;Nodep;intn,i;//判断数组是
    
                    
    • 
                    
  • Spring之启动过程源码解析
                        阿立聊代码
springspring数据库oracle
                        
    前言分析通常，我们说的Spring启动，就是构造ApplicationContext对象以及调用refresh()方法的过程。首先，Spring启动过程主要做了这么几件事情：构造一个BeanFactory对象解析配置类，得到BeanDefinition，并注册到BeanFactory中解析@ComponentScan，此时就会完成扫描解析@Import解析@Bean...因为Application
    
                    
    • 
                    
  • 【HuggingFace Transformers】BertIntermediate 和 BertPooler源码解析
                        CS_木成河
HuggingFace深度学习人工智能bertpython大模型Transformer
                        
    BertIntermediate和BertPooler源码解析1.介绍1.1位置与功能1.2相似点与不同点2.源码解析2.1BertIntermediate源码解析2.2BertPooler源码解析1.介绍1.1位置与功能(1)BertIntermediate位置：位于BertLayer的注意力层（BertSelfAttention）和输出层（BertOutput）之间。功能：它执行一个线性变换（
    
                    
    • 
                    
  • vue.js项目实战案例详细源码讲解
                        程序员小羊！
Javavue.js前端javascript
                        
    大家好，我是程序员小羊！前言：为帮助大家更好地掌握Vue.js项目的开发流程，我将为你讲解一个完整的Vue.js实战案例，并提供详细的源码解析。这个案例将涵盖从项目创建到实现各种功能模块的全过程，适合用于构建一个具有基本CRUD功能的简单任务管理应用。案例介绍我们将开发一个任务管理应用（TaskManager），它允许用户添加、查看、编辑和删除任务。这个应用将包括以下主要功能模块：任务列表显示：展
    
                    
    • 
                                
  • PHP，安卓，UI，java，linux视频教程合集
                                    cocos2d-x小菜
javaUIlinuxPHPandroid
                                    
    ╔-----------------------------------╗┆                           
    
                                
    • 
                                
  • zookeeper admin 笔记
                                    braveCS
zookeeper
                                    
      
Required Software 
1) JDK>=1.6 
2)推荐使用ensemble的ZooKeeper(至少3台)，并run on separate machines 
3)在Yahoo!，zk配置在特定的RHEL boxes里，2个cpu，2G内存，80G硬盘 
   


数据和日志目录  
1)数据目录里的文件是zk节点的持久化备份，包括快照和事务日
    
                                
    • 
                                
  • Spring配置多个连接池
                                    easterfly
spring
                                    
    项目中需要同时连接多个数据库的时候，如何才能在需要用到哪个数据库就连接哪个数据库呢？ 
Spring中有关于dataSource的配置： 
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" 
  &nb
    
                                
    • 
                                
  • Mysql
                                    171815164
mysql
                                    
    例如，你想myuser使用mypassword从任何主机连接到mysql服务器的话。 
 
GRANT ALL PRIVILEGES ON *.* TO 'myuser'@'%'IDENTIFIED BY 'mypassword' WI 
 
TH GRANT OPTION; 
 
如果你想允许用户myuser从ip为192.168.1.6的主机连接到mysql服务器，并使用mypassword作
    
                                
    • 
                                
  • CommonDAO（公共/基础DAO）
                                    g21121
DAO
                                    
            好久没有更新博客了，最近一段时间工作比较忙，所以请见谅，无论你是爱看呢还是爱看呢还是爱看呢，总之或许对你有些帮助。 
        DAO(Data Access Object)是一个数据访问（顾名思义就是与数据库打交道）接口，DAO一般在业
    
                                
    • 
                                
  • 直言有讳
                                    永夜-极光
感悟随笔
                                    
      
1.转载地址:http://blog.csdn.net/jasonblog/article/details/10813313 
  
精华: 
“直言有讳”是阿里巴巴提倡的一种观念，而我在此之前并没有很深刻的认识。为什么呢？就好比是读书时候做阅读理解，我喜欢我自己的解读，并不喜欢老师给的意思。在这里也是。我自己坚持的原则是互相尊重，我觉得阿里巴巴很多价值观其实是基本的做人
    
                                
    • 
                                
  • 安装CentOS 7 和Win 7后，Win7 引导丢失
                                    随便小屋
centos
                                    
    一般安装双系统的顺序是先装Win7，然后在安装CentOS，这样CentOS可以引导WIN 7启动。但安装CentOS7后，却找不到Win7 的引导，稍微修改一点东西即可。 
一、首先具有root 的权限。 
     即进入Terminal后输入命令su，然后输入密码即可 
二、利用vim编辑器打开/boot/grub2/grub.cfg文件进行修改 
v
    
                                
    • 
                                
  • Oracle备份与恢复案例
                                    aijuans
oracle
                                    
    Oracle备份与恢复案例 
一. 理解什么是数据库恢复当我们使用一个数据库时，总希望数据库的内容是可靠的、正确的，但由于计算机系统的故障（硬件故障、软件故障、网络故障、进程故障和系统故障）影响数据库系统的操作，影响数据库中数据的正确性，甚至破坏数据库，使数据库中全部或部分数据丢失。因此当发生上述故障后，希望能重构这个完整的数据库，该处理称为数据库恢复。恢复过程大致可以分为复原(Restore)与
    
                                
    • 
                                
  • JavaEE开源快速开发平台G4Studio v5.0发布
                                    無為子

                                    
      
我非常高兴地宣布,今天我们最新的JavaEE开源快速开发平台G4Studio_V5.0版本已经正式发布。 
  
访问G4Studio网站  
http://www.g4it.org       
2013-04-06 发布G4Studio_V5.0版本 
功能新增 
(1). 新增了调用Oracle存储过程返回游标，并将游标映射为Java List集合对象的标
    
                                
    • 
                                
  • Oracle显示根据高考分数模拟录取
                                    百合不是茶
PL/SQL编程oracle例子模拟高考录取学习交流
                                    
    题目要求: 
1,创建student表和result表
2,pl/sql对学生的成绩数据进行处理
3,处理的逻辑是根据每门专业课的最低分线和总分的最低分数线自动的将录取和落选 
  
  
1,创建student表,和result表 
学生信息表; 
create table student(
   student_id number primary key,--学生id
    
                                
    • 
                                
  • 优秀的领导与差劲的领导
                                    bijian1013
领导管理团队
                                    
    责任 

  优秀的领导：优秀的领导总是对他所负责的项目担负起责任。如果项目不幸失败了，那么他知道该受责备的人是他自己，并且敢于承认错误。 
  
 差劲的领导：差劲的领导觉得这不是他的问题，因此他会想方设法证明是他的团队不行，或是将责任归咎于团队中他不喜欢的那几个成员身上。 
 
努力工作 

  优秀的领导：团队领导应该是团队成员的榜样。至少，他应该与团队中的其他成员一样努力工作。这仅仅因为他
    
                                
    • 
                                
  • js函数在浏览器下的兼容
                                    Bill_chen
jquery浏览器IEDWRext
                                    
      做前端开发的工程师，少不了要用FF进行测试，纯js函数在不同浏览器下，名称也可能不同。对于IE6和FF，取得下一结点的函数就不尽相同： 
 
  IE6：node.nextSibling,对于FF是不能识别的； 
 
  FF：node.nextElementSibling,对于IE是不能识别的； 
 
兼容解决方式：var Div = node.nextSibl
    
                                
    • 
                                
  • 【JVM四】老年代垃圾回收：吞吐量垃圾收集器(Throughput GC)
                                    bit1129
垃圾回收
                                    
    吞吐量与用户线程暂停时间 
  
衡量垃圾回收算法优劣的指标有两个： 
 
 吞吐量越高，则算法越好 
 暂停时间越短，则算法越好 
 
首先说明吞吐量和暂停时间的含义。 
  
垃圾回收时，JVM会启动几个特定的GC线程来完成垃圾回收的任务，这些GC线程与应用的用户线程产生竞争关系，共同竞争处理器资源以及CPU的执行时间。GC线程不会对用户带来的任何价值，因此，好的GC应该占
    
                                
    • 
                                
  • J2EE监听器和过滤器基础
                                    白糖_
J2EE
                                    
     Servlet程序由Servlet，Filter和Listener组成，其中监听器用来监听Servlet容器上下文。 
监听器通常分三类：基于Servlet上下文的ServletContex监听，基于会话的HttpSession监听和基于请求的ServletRequest监听。 
  
 
 ServletContex监听器 
   ServletContex又叫application
    
                                
    • 
                                
  • 博弈AngularJS讲义(16) - 提供者
                                    boyitech
jsAngularJSapiAngularProvider
                                    
      Angular框架提供了强大的依赖注入机制，这一切都是有注入器(injector)完成. 注入器会自动实例化服务组件和符合Angular API规则的特殊对象，例如控制器，指令，过滤器动画等。 
  那注入器怎么知道如何去创建这些特殊的对象呢？ Angular提供了5种方式让注入器创建对象，其中最基础的方式就是提供者(provider), 其余四种方式(Value, Fac
    
                                
    • 
                                
  • java-写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。
                                    bylijinnan
java
                                    
    

public class CommonSubSequence {

	/**
	 * 题目：写一函数f(a,b)，它带有两个字符串参数并返回一串字符，该字符串只包含在两个串中都有的并按照在a中的顺序。
	 * 写一个版本算法复杂度O(N^2)和一个O(N) 。
	 * 
	 * O(N^2)：对于a中的每个字符，遍历b中的每个字符，如果相同，则拷贝到新字符串中。
	 * O(
    
                                
    • 
                                
  • sqlserver 2000 无法验证产品密钥
                                    Chen.H
sqlwindowsSQL ServerMicrosoft
                                    
    在 Service Pack 4 (SP 4), 是运行 Microsoft Windows Server 2003、 Microsoft Windows Storage Server 2003 或 Microsoft Windows 2000 服务器上您尝试安装 Microsoft SQL Server 2000 通过卷许可协议 (VLA) 媒体。 这样做, 收到以下错误信息CD KEY的 SQ
    
                                
    • 
                                
  • [新概念武器]气象战争
                                    comsci

                                    
     
 
       气象战争的发动者必须是拥有发射深空航天器能力的国家或者组织.... 
 
       原因如下: 
 
       地球上的气候变化和大气层中的云层涡旋场有密切的关系,而维持一个在大气层某个层次
    
                                
    • 
                                
  • oracle 中 rollup、cube、grouping 使用详解
                                    daizj
oraclegroupingrollupcube
                                    
    oracle 中 rollup、cube、grouping 使用详解 -- 使用oracle 样例表演示 转自namesliu 
 
-- 使用oracle 的样列库，演示 rollup, cube, grouping 的用法与使用场景  
  
--- ROLLUP ， 为了理解分组的成员数量，我增加了 分组的计数  COUNT(SAL)  
 
    
                                
    • 
                                
  • 技术资料汇总分享
                                    Dead_knight
技术资料汇总 分享
                                    
    本人汇总的技术资料，分享出来，希望对大家有用。 
 
http://pan.baidu.com/s/1jGr56uE 
 
资料主要包含： 
Workflow->工作流相关理论、框架(OSWorkflow、JBPM、Activiti、fireflow...) 
Security->java安全相关资料(SSL、SSO、SpringSecurity、Shiro、JAAS...) 
Ser
    
                                
    • 
                                
  • 初一下学期难记忆单词背诵第一课
                                    dcj3sjt126com
englishword
                                    
    could 能够 
minute 分钟 
Tuesday 星期二 
February 二月 
eighteenth 第十八 
listen 听 
careful 小心的，仔细的 
short 短的 
heavy 重的 
empty 空的 
certainly 当然 
carry 携带；搬运 
tape 磁带 
basket 蓝子 
bottle 瓶 
juice 汁，果汁 
head 头；头部 

    
                                
    • 
                                
  • 截取视图的图片, 然后分享出去
                                    dcj3sjt126com
OSObjective-C
                                    
    OS 7 has a new method that allows you to draw a view hierarchy into the current graphics context. This can be used to get an UIImage very fast. 
I implemented a category method on UIView to get the vi
    
                                
    • 
                                
  • MySql重置密码
                                    fanxiaolong
MySql重置密码
                                    
    方法一: 
 在my.ini的[mysqld]字段加入： 
skip-grant-tables 
重启mysql服务，这时的mysql不需要密码即可登录数据库 
 然后进入mysql 
mysql>use mysql; 
 mysql>更新 user set password=password('新密码') WHERE User='root'; 
mysq
    
                                
    • 
                                
  • Ehcache（03）——Ehcache中储存缓存的方式
                                    234390216
ehcacheMemoryStoreDiskStore存储驱除策略
                                    
    Ehcache中储存缓存的方式 
  
目录 
1     堆内存（MemoryStore） 
1.1     指定可用内存 
1.2     驱除策略 
1.3     元素过期 
2   &nbs
    
                                
    • 
                                
  • spring mvc中的@propertysource
                                    jackyrong
spring mvc
                                    
      在spring mvc中，在配置文件中的东西，可以在java代码中通过注解进行读取了： 
 
@PropertySource  在spring 3.1中开始引入 
 
比如有配置文件 
config.properties 
 
mongodb.url=1.2.3.4 
mongodb.db=hello 
 
则代码中 
  

@PropertySource(&
    
                                
    • 
                                
  • 重学单例模式
                                    lanqiu17
单例Singleton模式
                                    
    最近在重新学习设计模式，感觉对模式理解更加深刻。觉得有必要记下来。 
	第一个学的就是单例模式，单例模式估计是最好理解的模式了。它的作用就是防止外部创建实例，保证只有一个实例。
	单例模式的常用实现方式有两种，就人们熟知的饱汉式与饥汉式，具体就不多说了。这里说下其他的实现方式
	静态内部类方式: 
package test.pattern.singleton.statics;

publ
    
                                
    • 
                                
  • .NET开源核心运行时，且行且珍惜
                                    netcome
java.net开源
                                    
    背景 
2014年11月12日，ASP.NET之父、微软云计算与企业级产品工程部执行副总裁Scott Guthrie，在Connect全球开发者在线会议上宣布，微软将开源全部.NET核心运行时，并将.NET 扩展为可在 Linux 和 Mac OS 平台上运行。.NET核心运行时将基于MIT开源许可协议发布，其中将包括执行.NET代码所需的一切项目——CLR、JIT编译器、垃圾收集器（GC）和核心
    
                                
    • 
                                
  • 使用oscahe缓存技术减少与数据库的频繁交互
                                    Everyday都不同
Web高并发oscahe缓存
                                    
    此前一直不知道缓存的具体实现，只知道是把数据存储在内存中，以便下次直接从内存中读取。对于缓存的使用也没有概念，觉得缓存技术是一个比较”神秘陌生“的领域。但最近要用到缓存技术，发现还是很有必要一探究竟的。 
  
缓存技术使用背景：一般来说，对于web项目，如果我们要什么数据直接jdbc查库好了，但是在遇到高并发的情形下，不可能每一次都是去查数据库，因为这样在高并发的情形下显得不太合理——
    
                                
    • 
                                
  • Spring+Mybatis 手动控制事务
                                    toknowme
mybatis
                                    
    @Override 
   public boolean testDelete(String jobCode) throws Exception { 
      boolean flag = false; 
 &nbs
    
                                
    • 
                                
  • 菜鸟级的android程序员面试时候需要掌握的知识点
                                    xp9802
android
                                    
    熟悉Android开发架构和API调用 
掌握APP适应不同型号手机屏幕开发技巧 
熟悉Android下的数据存储  
熟练Android Debug Bridge Tool 
熟练Eclipse/ADT及相关工具  
熟悉Android框架原理及Activity生命周期 
熟练进行Android UI布局 
熟练使用SQLite数据库； 
熟悉Android下网络通信机制，S
    
                                
    •